diff --git a/.gitignore b/.gitignore
index 87904ecb..0b92d9cf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,4 @@
 /laminas-mkdoc-theme/
 /phpunit.xml
 /vendor/
+.phpunit.result.cache
diff --git a/.travis.yml b/.travis.yml
index d1f2636a..a3e3ef11 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -19,47 +19,36 @@ services:
 matrix:
   fast_finish: true
   include:
-    - php: 5.6
-      env:
-        - DEPS=lowest
-    - php: 5.6
-      env:
-        - DEPS=latest
-    - php: 7
-      env:
-        - DEPS=lowest
-    - php: 7
-      env:
-        - DEPS=latest
-    - php: 7.1
-      env:
-        - DEPS=lowest
-    - php: 7.1
+    - php: 7.3
       env:
         - DEPS=latest
         - CS_CHECK=true
         - TEST_COVERAGE=true
-    - php: 7.2
+    - php: 7.3
       env:
         - DEPS=lowest
-    - php: 7.2
-      env:
-        - DEPS=latest
-    - php: 7.3
+    - php: 7.4
       env:
         - DEPS=lowest
-    - php: 7.3
+    - php: 7.4
       env:
         - DEPS=latest
-    - php: 7.4
+    - php: nightly
+      env:
+        - DEPS=lowest
+        - COMPOSER_ARGS="--no-interaction --ignore-platform-reqs"
+        - SKIP_MONGODB=true # ext-mongodb does not build on php8 yet (https://github.com/mongodb/mongo-php-driver/issues/1161)
+    - php: nightly
       env:
         - DEPS=latest
+        - COMPOSER_ARGS="--no-interaction --ignore-platform-reqs"
+        - SKIP_MONGODB=true # ext-mongodb does not build on php8 yet (https://github.com/mongodb/mongo-php-driver/issues/1161)
 
 before_install:
   - if [[ $TEST_COVERAGE != 'true' ]]; then phpenv config-rm xdebug.ini || return 0 ; fi
   - pecl channel-update pecl.php.net
-  - pecl -q upgrade mongodb
-  - $(php -m | grep -q mongodb) || echo "extension=mongodb.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini
+  - if [[ $SKIP_MONGODB != 'true' ]]; then pecl -q upgrade mongodb ; fi
+  - if [[ $SKIP_MONGODB != 'true' ]]; then $(php -m | grep -q mongodb) || echo "extension=mongodb.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini ; fi
   - psql -c 'create database laminas_session_test;' -U postgres
   - mysql -e 'CREATE DATABASE laminas_session_test;'
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5eb5983b..a999b598 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,7 @@ All notable changes to this project will be documented in this file, in reverse
 
 ### Added
 
-- Nothing.
+- [#35](https://github.com/laminas/laminas-session/pull/35) Adds PHP 8.0 support
 
 ### Changed
 
@@ -14,11 +14,23 @@ All notable changes to this project will be documented in this file, in reverse
 
 ### Deprecated
 
-- Nothing.
+- [#35](https://github.com/laminas/laminas-session/pull/35) Marks some methods in `StandardConfig` and `SessionConfig` as deprecated as the functionality behind these methods was dropped in PHP 7.1
+  - `StandardConfig::setEntropyFile`
+  - `StandardConfig::getEntropyFile`
+  - `StandardConfig::setEntropyLength`
+  - `StandardConfig::getEntropyLength`
+  - `StandardConfig::setHashFunction`
+  - `StandardConfig::getHashFunction`
+  - `StandardConfig::setHashBitsPerCharacter`
+  - `StandardConfig::getHashBitsPerCharacter`
+  - `SessionConfig::setHashFunction`
+  - `SessionConfig::setHashBitsPerCharacter`
+
+- [#35](https://github.com/laminas/laminas-session/pull/35) Marks the `AbstractValidatorChain`, `ValidatorChainTrait` and `AbstractValidatorChainEM3` as deprecated as they can be replaced by using the `ValidatorChain` instead.
 
 ### Removed
 
-- Nothing.
+- [#35](https://github.com/laminas/laminas-session/pull/35) Removed compatibility with laminas-eventmanager v2
 
 ### Fixed
 
diff --git a/composer.json b/composer.json
index 0798fb17..fbf62711 100644
--- a/composer.json
+++ b/composer.json
@@ -25,8 +25,8 @@
         }
     },
     "require": {
-        "php": "^5.6 || ^7.0",
-        "laminas/laminas-eventmanager": "^2.6.2 || ^3.0",
+        "php": "^7.3 || ~8.0.0",
+        "laminas/laminas-eventmanager": "^3.0",
         "laminas/laminas-stdlib": "^3.2.1",
         "laminas/laminas-zendframework-bridge": "^1.0"
     },
@@ -36,11 +36,12 @@
         "laminas/laminas-coding-standard": "~1.0.0",
         "laminas/laminas-db": "^2.7",
         "laminas/laminas-http": "^2.5.4",
-        "laminas/laminas-servicemanager": "^2.7.5 || ^3.0.3",
+        "laminas/laminas-servicemanager": "^3.0.3",
         "laminas/laminas-validator": "^2.6",
         "mongodb/mongodb": "^1.0.1",
         "php-mock/php-mock-phpunit": "^1.1.2 || ^2.0",
-        "phpunit/phpunit": "^5.7.27 || ^6.5.14 || ^7.5.20"
+        "phpspec/prophecy-phpunit": "^2.0",
+        "phpunit/phpunit": "^9.3"
     },
     "suggest": {
         "laminas/laminas-cache": "Laminas\\Cache component",
@@ -56,9 +57,6 @@
         }
     },
     "autoload-dev": {
-        "files": [
-            "test/autoload.php"
-        ],
         "psr-4": {
             "LaminasTest\\Session\\": "test/"
         }
diff --git a/phpunit.xml.dist b/phpunit.xml.dist
index 7f93db01..b468d5a0 100644
--- a/phpunit.xml.dist
+++ b/phpunit.xml.dist
@@ -15,18 +15,17 @@
         </exclude>
     </groups>
 
-    <filter>
-        <whitelist processUncoveredFilesFromWhitelist="true">
+    <coverage>
+        <include>
             <directory suffix=".php">./src</directory>
-            <exclude>
-                <file>src/compatibility/autoload.php</file>
-                <file>src/Validator/AbstractValidatorChainEM2.php</file>
-            </exclude>
-        </whitelist>
-    </filter>
+        </include>
+        <exclude>
+            <file>src/compatibility/autoload.php</file>
+        </exclude>
+    </coverage>
 
     <php>
-        <ini name="date.timezone" value="UTC"/>
+        <ini name="date.timezone" value="UTC" />
 
         <!-- OB_ENABLED should be enabled for some tests to check if all
              functionality works as expected. Such tests include those for
diff --git a/src/AbstractValidatorChain.php b/src/AbstractValidatorChain.php
new file mode 100644
index 00000000..ae74a5b1
--- /dev/null
+++ b/src/AbstractValidatorChain.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laminas\Session;
+
+use Laminas\Session\Validator\AbstractValidatorChainEM3;
+
+/**
+ * Dummy class to keep backwards compatibility
+ *
+ * @deprecated Use {@see \Laminas\Session\ValidatorChain} directly
+ */
+abstract class AbstractValidatorChain extends AbstractValidatorChainEM3
+{
+}
diff --git a/src/Config/SessionConfig.php b/src/Config/SessionConfig.php
index ce006cb7..7e70efaf 100644
--- a/src/Config/SessionConfig.php
+++ b/src/Config/SessionConfig.php
@@ -284,6 +284,7 @@ public function setCacheLimiter($cacheLimiter)
      * @param  string|int $hashFunction
      * @return SessionConfig
      * @throws Exception\InvalidArgumentException
+     * @deprecated removed in PHP 7.1
      */
     public function setHashFunction($hashFunction)
     {
@@ -308,6 +309,7 @@ public function setHashFunction($hashFunction)
      * @param  int $hashBitsPerCharacter
      * @return SessionConfig
      * @throws Exception\InvalidArgumentException
+     * @deprecated removed in PHP 7.1
      */
     public function setHashBitsPerCharacter($hashBitsPerCharacter)
     {
diff --git a/src/Config/StandardConfig.php b/src/Config/StandardConfig.php
index ae4a63af..36d08f82 100644
--- a/src/Config/StandardConfig.php
+++ b/src/Config/StandardConfig.php
@@ -582,6 +582,7 @@ public function getUseCookies()
      * @param  string $entropyFile
      * @return StandardConfig
      * @throws Exception\InvalidArgumentException
+     * @deprecated removed in PHP 7.1
      */
     public function setEntropyFile($entropyFile)
     {
@@ -605,6 +606,7 @@ public function setEntropyFile($entropyFile)
      * Get session.entropy_file
      *
      * @return string
+     * @deprecated removed in PHP 7.1
      */
     public function getEntropyFile()
     {
@@ -625,6 +627,7 @@ public function getEntropyFile()
      * @param  int $entropyLength
      * @return StandardConfig
      * @throws Exception\InvalidArgumentException
+     * @deprecated removed in PHP 7.1
      */
     public function setEntropyLength($entropyLength)
     {
@@ -648,6 +651,7 @@ public function setEntropyLength($entropyLength)
      * Get session.entropy_length
      *
      * @return string
+     * @deprecated removed in PHP 7.1
      */
     public function getEntropyLength()
     {
@@ -704,6 +708,7 @@ public function getCacheExpire()
      *
      * @param  string $hashFunction
      * @return mixed
+     * @deprecated removed in PHP 7.1
      */
     public function setHashFunction($hashFunction)
     {
@@ -718,6 +723,7 @@ public function setHashFunction($hashFunction)
      * Get session.hash_function
      *
      * @return string
+     * @deprecated removed in PHP 7.1
      */
     public function getHashFunction()
     {
@@ -734,6 +740,7 @@ public function getHashFunction()
      * @param  int $hashBitsPerCharacter
      * @return StandardConfig
      * @throws Exception\InvalidArgumentException
+     * @deprecated removed in PHP 7.1
      */
     public function setHashBitsPerCharacter($hashBitsPerCharacter)
     {
@@ -754,6 +761,7 @@ public function setHashBitsPerCharacter($hashBitsPerCharacter)
      * Get session.hash_bits_per_character
      *
      * @return string
+     * @deprecated removed in PHP 7.1
      */
     public function getHashBitsPerCharacter()
     {
diff --git a/src/Validator/AbstractValidatorChainEM2.php b/src/Validator/AbstractValidatorChainEM2.php
deleted file mode 100644
index a8bf9dd0..00000000
--- a/src/Validator/AbstractValidatorChainEM2.php
+++ /dev/null
@@ -1,55 +0,0 @@
-<?php
-
-/**
- * @see       https://github.com/laminas/laminas-session for the canonical source repository
- * @copyright https://github.com/laminas/laminas-session/blob/master/COPYRIGHT.md
- * @license   https://github.com/laminas/laminas-session/blob/master/LICENSE.md New BSD License
- */
-
-namespace Laminas\Session\Validator;
-
-use Laminas\EventManager\EventManager;
-use Laminas\Session\Storage\StorageInterface;
-
-/**
- * Abstract validator chain for validating sessions (for use with laminas-eventmanager v2).
- */
-abstract class AbstractValidatorChainEM2 extends EventManager
-{
-    use ValidatorChainTrait;
-
-    /**
-     * Construct the validation chain
-     *
-     * Retrieves validators from session storage and attaches them.
-     *
-     * Duplicated in ValidatorChainEM3 to prevent trait collision with parent.
-     *
-     * @param StorageInterface $storage
-     */
-    public function __construct(StorageInterface $storage)
-    {
-        parent::__construct();
-
-        $this->storage = $storage;
-        $validators = $storage->getMetadata('_VALID');
-        if ($validators) {
-            foreach ($validators as $validator => $data) {
-                $this->attachValidator('session.validate', [new $validator($data), 'isValid'], 1);
-            }
-        }
-    }
-
-    /**
-     * Attach a listener to the session validator chain.
-     *
-     * @param string $event
-     * @param null|callable $callback
-     * @param int $priority
-     * @return \Laminas\Stdlib\CallbackHandler
-     */
-    public function attach($event, $callback = null, $priority = 1)
-    {
-        return $this->attachValidator($event, $callback, $priority);
-    }
-}
diff --git a/src/Validator/AbstractValidatorChainEM3.php b/src/Validator/AbstractValidatorChainEM3.php
index 85bfc5ba..273c2fea 100644
--- a/src/Validator/AbstractValidatorChainEM3.php
+++ b/src/Validator/AbstractValidatorChainEM3.php
@@ -13,6 +13,8 @@
 
 /**
  * Abstract validator chain for validating sessions (for use with laminas-eventmanager v3)
+ *
+ * @deprecated Use {@see \Laminas\Session\ValidatorChain} directly
  */
 abstract class AbstractValidatorChainEM3 extends EventManager
 {
diff --git a/src/Validator/Id.php b/src/Validator/Id.php
index 771143fe..98cfb515 100644
--- a/src/Validator/Id.php
+++ b/src/Validator/Id.php
@@ -48,7 +48,7 @@ public function isValid()
     {
         $id = $this->id;
         $saveHandler = ini_get('session.save_handler');
-        if ($saveHandler == 'cluster') { // Zend Server SC, validate only after last dash
+        if ($saveHandler === 'cluster') { // Zend Server SC, validate only after last dash
             $dashPos = strrpos($id, '-');
             if ($dashPos) {
                 $id = substr($id, $dashPos + 1);
@@ -56,10 +56,7 @@ public function isValid()
         }
 
         // Get the session id bits per character INI setting, using 5 if unavailable
-        $bitsPerCharacter = PHP_VERSION_ID >= 70100
-            ? 'session.sid_bits_per_character'
-            : 'session.hash_bits_per_character';
-        $hashBitsPerChar = ini_get($bitsPerCharacter) ?: 5;
+        $hashBitsPerChar = ini_get('session.sid_bits_per_character') ?: 5;
 
         switch ($hashBitsPerChar) {
             case 4:
diff --git a/src/Validator/ValidatorChainTrait.php b/src/Validator/ValidatorChainTrait.php
index a8feb29e..2bd2c226 100644
--- a/src/Validator/ValidatorChainTrait.php
+++ b/src/Validator/ValidatorChainTrait.php
@@ -12,6 +12,8 @@
 
 /**
  * Base trait for validator chain implementations
+ *
+ * @deprecated Use {@see \Laminas\Session\ValidatorChain} directly
  */
 trait ValidatorChainTrait
 {
diff --git a/src/ValidatorChain.php b/src/ValidatorChain.php
index 527724cb..00743924 100644
--- a/src/ValidatorChain.php
+++ b/src/ValidatorChain.php
@@ -8,35 +8,78 @@
 
 namespace Laminas\Session;
 
-use Laminas\EventManager\GlobalEventManager;
+use Laminas\EventManager\EventManager;
+use Laminas\Session\Storage\StorageInterface;
+use Laminas\Session\Validator\ValidatorInterface;
 
-/**
- * Polyfill for AbstractValidatorChain.
- *
- * The definitions for EventManagerInterface::attach differ between versions 2
- * and 3 of laminas-eventmanager, which makes it impossible to override the method
- * in a way that is compatible with both.
- *
- * To get around that, we define 2 abstract classes, one targeting each major
- * version of laminas-eventmanager, and each defining attach() per the EM version
- * they target.
- *
- * This conditional below then aliases the appropriate one to `AbstractValidatorChain`,
- * based on which version of the EM is present. Since the `GlobalEventManager`
- * is only present in v2, we can use that as our test.
- */
-if (class_exists(GlobalEventManager::class)) {
-    class_alias(Validator\AbstractValidatorChainEM2::class, AbstractValidatorChain::class);
-} else {
-    class_alias(Validator\AbstractValidatorChainEM3::class, AbstractValidatorChain::class);
-}
-
-/**
- * Validator chain implementation.
- *
- * Extends the laminas-eventmanager-version-specific base class implementation
- * as polyfilled above.
- */
-class ValidatorChain extends AbstractValidatorChain
+class ValidatorChain extends EventManager
 {
+    /** @var StorageInterface */
+    protected $storage;
+
+    public function __construct(StorageInterface $storage)
+    {
+        parent::__construct();
+
+        $this->storage = $storage;
+        $validators    = $storage->getMetadata('_VALID');
+        if ($validators) {
+            foreach ($validators as $validator => $data) {
+                $this->attachValidator('session.validate', [new $validator($data), 'isValid'], 1);
+            }
+        }
+    }
+
+    /**
+     * Attach a listener to the session validator chain.
+     *
+     * @param string   $eventName
+     * @param callable $callback
+     * @param int      $priority
+     * @return callable
+     */
+    public function attach($eventName, callable $callback, $priority = 1)
+    {
+        return $this->attachValidator($eventName, $callback, $priority);
+    }
+
+    /**
+     * Retrieve session storage object
+     *
+     * @return StorageInterface
+     */
+    public function getStorage()
+    {
+        return $this->storage;
+    }
+
+    /**
+     * Internal implementation for attaching a listener to the
+     * session validator chain.
+     *
+     * @param string   $event
+     * @param callable $callback
+     * @param int      $priority
+     * @return callable
+     */
+    private function attachValidator($event, $callback, $priority)
+    {
+        $context = null;
+        if ($callback instanceof ValidatorInterface) {
+            $context = $callback;
+        } elseif (is_array($callback)) {
+            $test = array_shift($callback);
+            if ($test instanceof ValidatorInterface) {
+                $context = $test;
+            }
+            array_unshift($callback, $test);
+        }
+        if ($context instanceof ValidatorInterface) {
+            $data = $context->getData();
+            $name = $context->getName();
+            $this->getStorage()->setMetadata('_VALID', [$name => $data]);
+        }
+
+        return parent::attach($event, $callback, $priority);
+    }
 }
diff --git a/test/AbstractContainerTest.php b/test/AbstractContainerTest.php
index 01f08205..dd6c6638 100644
--- a/test/AbstractContainerTest.php
+++ b/test/AbstractContainerTest.php
@@ -36,20 +36,18 @@ class AbstractContainerTest extends TestCase
      */
     protected $container;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $_SESSION = [];
         Container::setDefaultManager(null);
 
-        $config = new StandardConfig([
-            'storage' => 'Laminas\\Session\\Storage\\ArrayStorage',
-        ]);
+        $config = new StandardConfig();
 
-        $this->manager = $manager = new TestAsset\TestManager($config);
+        $this->manager   = $manager = new TestAsset\TestManager($config);
         $this->container = new TestContainer('Default', $manager);
     }
 
-    protected function tearDown()
+    protected function tearDown(): void
     {
         $_SESSION = [];
         Container::setDefaultManager(null);
@@ -59,7 +57,7 @@ protected function tearDown()
      * This test case fails on laminas-session 2.8.0 with the php error below and works fine on 2.7.*.
      * "Only variable references should be returned by reference"
      */
-    public function testOffsetGetMissingKey()
+    public function testOffsetGetMissingKey(): void
     {
         self::assertNull($this->container->offsetGet('this key does not exist in the container'));
     }
diff --git a/test/Config/SessionConfigTest.php b/test/Config/SessionConfigTest.php
index 3dad0778..5a451806 100644
--- a/test/Config/SessionConfigTest.php
+++ b/test/Config/SessionConfigTest.php
@@ -10,7 +10,7 @@
 
 use Laminas\Session\Config\SessionConfig;
 use Laminas\Session\Exception;
-use Laminas\Session\SaveHandler\SaveHandlerInterface;
+use Laminas\Session\Exception\InvalidArgumentException;
 use LaminasTest\Session\TestAsset\TestSaveHandler;
 use phpmock\phpunit\PHPMock;
 use PHPUnit\Framework\TestCase;
@@ -31,598 +31,505 @@ class SessionConfigTest extends TestCase
      */
     protected $config;
 
-    protected function setUp()
+    protected function setUp(): void
     {
-        $this->config = new SessionConfig;
+        $this->config = new SessionConfig();
     }
 
-    protected function tearDown()
+    protected function tearDown(): void
     {
         $this->config = null;
     }
 
-    public function assertPhpLessThan71($message = 'This test requires a PHP version less than 7.1.0')
-    {
-        if (PHP_VERSION_ID < 70100) {
-            return true;
-        }
-        $this->markTestSkipped($message);
-    }
-
     // session.save_path
 
-    public function testSetSavePathErrorsOnInvalidPath()
+    public function testSetSavePathErrorsOnInvalidPath(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid save_path provided');
         $this->config->setSavePath(__DIR__ . '/foobarboguspath');
     }
 
-    public function testSavePathDefaultsToIniSettings()
+    public function testSavePathDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.save_path'), $this->config->getSavePath());
+        self::assertSame(ini_get('session.save_path'), $this->config->getSavePath());
     }
 
-    public function testSavePathIsMutable()
+    public function testSavePathIsMutable(): void
     {
         $this->config->setSavePath(__DIR__);
-        $this->assertEquals(__DIR__, $this->config->getSavePath());
+        self::assertEquals(__DIR__, $this->config->getSavePath());
     }
 
-    public function testSavePathAltersIniSetting()
+    public function testSavePathAltersIniSetting(): void
     {
         $this->config->setSavePath(__DIR__);
-        $this->assertEquals(__DIR__, ini_get('session.save_path'));
+        self::assertEquals(__DIR__, ini_get('session.save_path'));
     }
 
-    public function testSavePathCanBeNonDirectoryWhenSaveHandlerNotFiles()
+    public function testSavePathCanBeNonDirectoryWhenSaveHandlerNotFiles(): void
     {
         $this->config->setPhpSaveHandler(TestSaveHandler::class);
         $this->config->setSavePath('/tmp/sessions.db');
-        $this->assertEquals('/tmp/sessions.db', ini_get('session.save_path'));
+        self::assertEquals('/tmp/sessions.db', ini_get('session.save_path'));
     }
 
     // session.name
 
-    public function testNameDefaultsToIniSettings()
+    public function testNameDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.name'), $this->config->getName());
+        self::assertSame(ini_get('session.name'), $this->config->getName());
     }
 
-    public function testNameIsMutable()
+    public function testNameIsMutable(): void
     {
         $this->config->setName('FOOBAR');
-        $this->assertEquals('FOOBAR', $this->config->getName());
+        self::assertEquals('FOOBAR', $this->config->getName());
     }
 
-    public function testNameAltersIniSetting()
+    public function testNameAltersIniSetting(): void
     {
         $this->config->setName('FOOBAR');
-        $this->assertEquals('FOOBAR', ini_get('session.name'));
+        self::assertEquals('FOOBAR', ini_get('session.name'));
     }
 
-    public function testNameAltersIniSettingAfterSessionStart()
+    public function testNameAltersIniSettingAfterSessionStart(): void
     {
         session_start();
 
         $this->config->setName('FOOBAR');
-        $this->assertEquals('FOOBAR', ini_get('session.name'));
+        self::assertEquals('FOOBAR', ini_get('session.name'));
     }
 
-    public function testIdempotentNameAltersIniSettingWithSameValueAfterSessionStart()
+    public function testIdempotentNameAltersIniSettingWithSameValueAfterSessionStart(): void
     {
         $this->config->setName('FOOBAR');
         session_start();
 
         $this->config->setName('FOOBAR');
-        $this->assertEquals('FOOBAR', ini_get('session.name'));
+        self::assertEquals('FOOBAR', ini_get('session.name'));
     }
 
     // session.save_handler
 
-    public function testSaveHandlerDefaultsToIniSettings()
+    public function testSaveHandlerDefaultsToIniSettings(): void
     {
-        $this->assertSame(
+        self::assertSame(
             ini_get('session.save_handler'),
             $this->config->getSaveHandler(),
             var_export($this->config->toArray(), 1)
         );
     }
 
-    public function testSaveHandlerIsMutable()
+    public function testSaveHandlerIsMutable(): void
     {
         $this->config->setSaveHandler(TestSaveHandler::class);
-        $this->assertSame(TestSaveHandler::class, $this->config->getSaveHandler());
+        self::assertSame(TestSaveHandler::class, $this->config->getSaveHandler());
     }
 
-    public function testSaveHandlerDoesNotAlterIniSetting()
+    public function testSaveHandlerDoesNotAlterIniSetting(): void
     {
         $this->config->setSaveHandler(TestSaveHandler::class);
-        $this->assertNotSame(TestSaveHandler::class, ini_get('session.save_handler'));
+        self::assertNotSame(TestSaveHandler::class, ini_get('session.save_handler'));
     }
 
-    public function testSettingInvalidSaveHandlerRaisesException()
+    public function testSettingInvalidSaveHandlerRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid save handler specified');
         $this->config->setPhpSaveHandler('foobar_bogus');
     }
 
     // session.gc_probability
 
-    public function testGcProbabilityDefaultsToIniSettings()
+    public function testGcProbabilityDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.gc_probability'), $this->config->getGcProbability());
+        self::assertSame(ini_get('session.gc_probability'), $this->config->getGcProbability());
     }
 
-    public function testGcProbabilityIsMutable()
+    public function testGcProbabilityIsMutable(): void
     {
         $this->config->setGcProbability(20);
-        $this->assertEquals(20, $this->config->getGcProbability());
+        self::assertEquals(20, $this->config->getGcProbability());
     }
 
-    public function testGcProbabilityAltersIniSetting()
+    public function testGcProbabilityAltersIniSetting(): void
     {
         $this->config->setGcProbability(24);
-        $this->assertEquals(24, ini_get('session.gc_probability'));
+        self::assertEquals(24, ini_get('session.gc_probability'));
     }
 
-    public function testSettingInvalidGcProbabilityRaisesException()
+    public function testSettingInvalidGcProbabilityRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid gc_probability; must be numeric');
         $this->config->setGcProbability('foobar_bogus');
     }
 
-    public function testSettingInvalidGcProbabilityRaisesException2()
+    public function testSettingInvalidGcProbabilityRaisesException2(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid gc_probability; must be a percentage');
         $this->config->setGcProbability(-1);
     }
 
-    public function testSettingInvalidGcProbabilityRaisesException3()
+    public function testSettingInvalidGcProbabilityRaisesException3(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid gc_probability; must be a percentage');
         $this->config->setGcProbability(101);
     }
 
     // session.gc_divisor
 
-    public function testGcDivisorDefaultsToIniSettings()
+    public function testGcDivisorDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.gc_divisor'), $this->config->getGcDivisor());
+        self::assertSame(ini_get('session.gc_divisor'), $this->config->getGcDivisor());
     }
 
-    public function testGcDivisorIsMutable()
+    public function testGcDivisorIsMutable(): void
     {
         $this->config->setGcDivisor(20);
-        $this->assertEquals(20, $this->config->getGcDivisor());
+        self::assertEquals(20, $this->config->getGcDivisor());
     }
 
-    public function testGcDivisorAltersIniSetting()
+    public function testGcDivisorAltersIniSetting(): void
     {
         $this->config->setGcDivisor(24);
-        $this->assertEquals(24, ini_get('session.gc_divisor'));
+        self::assertEquals(24, ini_get('session.gc_divisor'));
     }
 
-    public function testSettingInvalidGcDivisorRaisesException()
+    public function testSettingInvalidGcDivisorRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid gc_divisor; must be numeric');
         $this->config->setGcDivisor('foobar_bogus');
     }
 
-    public function testSettingInvalidGcDivisorRaisesException2()
+    public function testSettingInvalidGcDivisorRaisesException2(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid gc_divisor; must be a positive integer');
         $this->config->setGcDivisor(-1);
     }
 
     // session.gc_maxlifetime
 
-    public function testGcMaxlifetimeDefaultsToIniSettings()
+    public function testGcMaxlifetimeDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.gc_maxlifetime'), $this->config->getGcMaxlifetime());
+        self::assertSame(ini_get('session.gc_maxlifetime'), $this->config->getGcMaxlifetime());
     }
 
-    public function testGcMaxlifetimeIsMutable()
+    public function testGcMaxlifetimeIsMutable(): void
     {
         $this->config->setGcMaxlifetime(20);
-        $this->assertEquals(20, $this->config->getGcMaxlifetime());
+        self::assertEquals(20, $this->config->getGcMaxlifetime());
     }
 
-    public function testGcMaxlifetimeAltersIniSetting()
+    public function testGcMaxlifetimeAltersIniSetting(): void
     {
         $this->config->setGcMaxlifetime(24);
-        $this->assertEquals(24, ini_get('session.gc_maxlifetime'));
+        self::assertEquals(24, ini_get('session.gc_maxlifetime'));
     }
 
-    public function testSettingInvalidGcMaxlifetimeRaisesException()
+    public function testSettingInvalidGcMaxlifetimeRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid gc_maxlifetime; must be numeric');
         $this->config->setGcMaxlifetime('foobar_bogus');
     }
 
-    public function testSettingInvalidGcMaxlifetimeRaisesException2()
+    public function testSettingInvalidGcMaxlifetimeRaisesException2(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid gc_maxlifetime; must be a positive integer');
         $this->config->setGcMaxlifetime(-1);
     }
 
     // session.serialize_handler
 
-    public function testSerializeHandlerDefaultsToIniSettings()
+    public function testSerializeHandlerDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.serialize_handler'), $this->config->getSerializeHandler());
+        self::assertSame(ini_get('session.serialize_handler'), $this->config->getSerializeHandler());
     }
 
-    public function testSerializeHandlerIsMutable()
+    public function testSerializeHandlerIsMutable(): void
     {
         $value = extension_loaded('wddx') ? 'wddx' : 'php_binary';
         $this->config->setSerializeHandler($value);
-        $this->assertEquals($value, $this->config->getSerializeHandler());
+        self::assertEquals($value, $this->config->getSerializeHandler());
     }
 
-    public function testSerializeHandlerAltersIniSetting()
+    public function testSerializeHandlerAltersIniSetting(): void
     {
         $value = extension_loaded('wddx') ? 'wddx' : 'php_binary';
         $this->config->setSerializeHandler($value);
-        $this->assertEquals($value, ini_get('session.serialize_handler'));
+        self::assertEquals($value, ini_get('session.serialize_handler'));
     }
 
-    public function testSettingInvalidSerializeHandlerRaisesException()
+    public function testSettingInvalidSerializeHandlerRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid serialize handler specified');
         $this->config->setSerializeHandler('foobar_bogus');
     }
 
     // session.cookie_lifetime
 
-    public function testCookieLifetimeDefaultsToIniSettings()
+    public function testCookieLifetimeDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.cookie_lifetime'), $this->config->getCookieLifetime());
+        self::assertSame(ini_get('session.cookie_lifetime'), $this->config->getCookieLifetime());
     }
 
-    public function testCookieLifetimeIsMutable()
+    public function testCookieLifetimeIsMutable(): void
     {
         $this->config->setCookieLifetime(20);
-        $this->assertEquals(20, $this->config->getCookieLifetime());
+        self::assertEquals(20, $this->config->getCookieLifetime());
     }
 
-    public function testCookieLifetimeAltersIniSetting()
+    public function testCookieLifetimeAltersIniSetting(): void
     {
         $this->config->setCookieLifetime(24);
-        $this->assertEquals(24, ini_get('session.cookie_lifetime'));
+        self::assertEquals(24, ini_get('session.cookie_lifetime'));
     }
 
-    public function testCookieLifetimeCanBeZero()
+    public function testCookieLifetimeCanBeZero(): void
     {
         $this->config->setCookieLifetime(0);
-        $this->assertEquals(0, ini_get('session.cookie_lifetime'));
+        self::assertEquals(0, ini_get('session.cookie_lifetime'));
     }
 
-    public function testSettingInvalidCookieLifetimeRaisesException()
+    public function testSettingInvalidCookieLifetimeRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid cookie_lifetime; must be numeric');
         $this->config->setCookieLifetime('foobar_bogus');
     }
 
-    public function testSettingInvalidCookieLifetimeRaisesException2()
+    public function testSettingInvalidCookieLifetimeRaisesException2(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid cookie_lifetime; must be a positive integer or zero');
         $this->config->setCookieLifetime(-1);
     }
 
     // session.cookie_path
 
-    public function testCookiePathDefaultsToIniSettings()
+    public function testCookiePathDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.cookie_path'), $this->config->getCookiePath());
+        self::assertSame(ini_get('session.cookie_path'), $this->config->getCookiePath());
     }
 
-    public function testCookiePathIsMutable()
+    public function testCookiePathIsMutable(): void
     {
         $this->config->setCookiePath('/foo');
-        $this->assertEquals('/foo', $this->config->getCookiePath());
+        self::assertEquals('/foo', $this->config->getCookiePath());
     }
 
-    public function testCookiePathAltersIniSetting()
+    public function testCookiePathAltersIniSetting(): void
     {
         $this->config->setCookiePath('/bar');
-        $this->assertEquals('/bar', ini_get('session.cookie_path'));
+        self::assertEquals('/bar', ini_get('session.cookie_path'));
     }
 
-    public function testSettingInvalidCookiePathRaisesException()
+    public function testSettingInvalidCookiePathRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid cookie path');
         $this->config->setCookiePath(24);
     }
 
-    public function testSettingInvalidCookiePathRaisesException2()
+    public function testSettingInvalidCookiePathRaisesException2(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid cookie path');
         $this->config->setCookiePath('foo');
     }
 
-    public function testSettingInvalidCookiePathRaisesException3()
+    public function testSettingInvalidCookiePathRaisesException3(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid cookie path');
         $this->config->setCookiePath('D:\\WINDOWS\\System32\\drivers\\etc\\hosts');
     }
 
     // session.cookie_domain
 
-    public function testCookieDomainDefaultsToIniSettings()
+    public function testCookieDomainDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.cookie_domain'), $this->config->getCookieDomain());
+        self::assertSame(ini_get('session.cookie_domain'), $this->config->getCookieDomain());
     }
 
-    public function testCookieDomainIsMutable()
+    public function testCookieDomainIsMutable(): void
     {
         $this->config->setCookieDomain('example.com');
-        $this->assertEquals('example.com', $this->config->getCookieDomain());
+        self::assertEquals('example.com', $this->config->getCookieDomain());
     }
 
-    public function testCookieDomainCanBeEmpty()
+    public function testCookieDomainCanBeEmpty(): void
     {
         $this->config->setCookieDomain('');
-        $this->assertEquals('', $this->config->getCookieDomain());
+        self::assertEquals('', $this->config->getCookieDomain());
     }
 
-    public function testCookieDomainAltersIniSetting()
+    public function testCookieDomainAltersIniSetting(): void
     {
         $this->config->setCookieDomain('localhost');
-        $this->assertEquals('localhost', ini_get('session.cookie_domain'));
+        self::assertEquals('localhost', ini_get('session.cookie_domain'));
     }
 
-    public function testSettingInvalidCookieDomainRaisesException()
+    public function testSettingInvalidCookieDomainRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid cookie domain: must be a string');
         $this->config->setCookieDomain(24);
     }
 
-    public function testSettingInvalidCookieDomainRaisesException2()
+    public function testSettingInvalidCookieDomainRaisesException2(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('does not match the expected structure for a DNS hostname');
         $this->config->setCookieDomain('D:\\WINDOWS\\System32\\drivers\\etc\\hosts');
     }
 
     // session.cookie_secure
 
-    public function testCookieSecureDefaultsToIniSettings()
+    public function testCookieSecureDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.cookie_secure'), $this->config->getCookieSecure());
+        self::assertSame(ini_get('session.cookie_secure'), $this->config->getCookieSecure());
     }
 
-    public function testCookieSecureIsMutable()
+    public function testCookieSecureIsMutable(): void
     {
         $value = ! ini_get('session.cookie_secure');
         $this->config->setCookieSecure($value);
-        $this->assertEquals($value, $this->config->getCookieSecure());
+        self::assertEquals($value, $this->config->getCookieSecure());
     }
 
-    public function testCookieSecureAltersIniSetting()
+    public function testCookieSecureAltersIniSetting(): void
     {
         $value = ! ini_get('session.cookie_secure');
         $this->config->setCookieSecure($value);
-        $this->assertEquals($value, ini_get('session.cookie_secure'));
+        self::assertEquals($value, ini_get('session.cookie_secure'));
     }
 
     // session.cookie_httponly
 
-    public function testCookieHttpOnlyDefaultsToIniSettings()
+    public function testCookieHttpOnlyDefaultsToIniSettings(): void
     {
-        $this->assertSame((bool) ini_get('session.cookie_httponly'), $this->config->getCookieHttpOnly());
+        self::assertSame((bool)ini_get('session.cookie_httponly'), $this->config->getCookieHttpOnly());
     }
 
-    public function testCookieHttpOnlyIsMutable()
+    public function testCookieHttpOnlyIsMutable(): void
     {
         $value = ! ini_get('session.cookie_httponly');
         $this->config->setCookieHttpOnly($value);
-        $this->assertEquals($value, $this->config->getCookieHttpOnly());
+        self::assertEquals($value, $this->config->getCookieHttpOnly());
     }
 
-    public function testCookieHttpOnlyAltersIniSetting()
+    public function testCookieHttpOnlyAltersIniSetting(): void
     {
         $value = ! ini_get('session.cookie_httponly');
         $this->config->setCookieHttpOnly($value);
-        $this->assertEquals($value, ini_get('session.cookie_httponly'));
+        self::assertEquals($value, ini_get('session.cookie_httponly'));
     }
 
     // session.use_cookies
 
-    public function testUseCookiesDefaultsToIniSettings()
+    public function testUseCookiesDefaultsToIniSettings(): void
     {
-        $this->assertSame((bool) ini_get('session.use_cookies'), $this->config->getUseCookies());
+        self::assertSame((bool)ini_get('session.use_cookies'), $this->config->getUseCookies());
     }
 
-    public function testUseCookiesIsMutable()
+    public function testUseCookiesIsMutable(): void
     {
         $value = ! ini_get('session.use_cookies');
         $this->config->setUseCookies($value);
-        $this->assertEquals($value, $this->config->getUseCookies());
+        self::assertEquals($value, $this->config->getUseCookies());
     }
 
-    public function testUseCookiesAltersIniSetting()
+    public function testUseCookiesAltersIniSetting(): void
     {
         $value = ! ini_get('session.use_cookies');
         $this->config->setUseCookies($value);
-        $this->assertEquals($value, (bool) ini_get('session.use_cookies'));
+        self::assertEquals($value, (bool)ini_get('session.use_cookies'));
     }
 
     // session.use_only_cookies
 
-    public function testUseOnlyCookiesDefaultsToIniSettings()
+    public function testUseOnlyCookiesDefaultsToIniSettings(): void
     {
-        $this->assertSame((bool) ini_get('session.use_only_cookies'), $this->config->getUseOnlyCookies());
+        self::assertSame((bool)ini_get('session.use_only_cookies'), $this->config->getUseOnlyCookies());
     }
 
-    public function testUseOnlyCookiesIsMutable()
+    public function testUseOnlyCookiesIsMutable(): void
     {
         $value = ! ini_get('session.use_only_cookies');
         $this->config->setOption('use_only_cookies', $value);
-        $this->assertEquals($value, (bool) $this->config->getOption('use_only_cookies'));
+        self::assertEquals($value, (bool)$this->config->getOption('use_only_cookies'));
     }
 
-    public function testUseOnlyCookiesAltersIniSetting()
+    public function testUseOnlyCookiesAltersIniSetting(): void
     {
         $value = ! ini_get('session.use_only_cookies');
         $this->config->setOption('use_only_cookies', $value);
-        $this->assertEquals($value, (bool) ini_get('session.use_only_cookies'));
+        self::assertEquals($value, (bool)ini_get('session.use_only_cookies'));
     }
 
     // session.referer_check
 
-    public function testRefererCheckDefaultsToIniSettings()
+    public function testRefererCheckDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.referer_check'), $this->config->getRefererCheck());
+        self::assertSame(ini_get('session.referer_check'), $this->config->getRefererCheck());
     }
 
-    public function testRefererCheckIsMutable()
+    public function testRefererCheckIsMutable(): void
     {
         $this->config->setOption('referer_check', 'FOOBAR');
-        $this->assertEquals('FOOBAR', $this->config->getOption('referer_check'));
+        self::assertEquals('FOOBAR', $this->config->getOption('referer_check'));
     }
 
-    public function testRefererCheckMayBeEmpty()
+    public function testRefererCheckMayBeEmpty(): void
     {
         $this->config->setOption('referer_check', '');
-        $this->assertEquals('', $this->config->getOption('referer_check'));
+        self::assertEquals('', $this->config->getOption('referer_check'));
     }
 
-    public function testRefererCheckAltersIniSetting()
+    public function testRefererCheckAltersIniSetting(): void
     {
         $this->config->setOption('referer_check', 'BARBAZ');
-        $this->assertEquals('BARBAZ', ini_get('session.referer_check'));
-    }
-
-    // session.entropy_file
-
-    public function testSetEntropyFileErrorsOnInvalidPath()
-    {
-        $this->assertPhpLessThan71('session.entropy_file directive removed in PHP 7.1');
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
-        $this->expectExceptionMessage('Invalid entropy_file provided');
-        $this->config->setEntropyFile(__DIR__ . '/foobarboguspath');
-    }
-
-    public function testEntropyFileDefaultsToIniSettings()
-    {
-        $this->assertPhpLessThan71('session.entropy_file directive removed in PHP 7.1');
-        $this->assertSame(ini_get('session.entropy_file'), $this->config->getEntropyFile());
-    }
-
-    public function testEntropyFileIsMutable()
-    {
-        $this->assertPhpLessThan71('session.entropy_file directive removed in PHP 7.1');
-        $this->config->setEntropyFile(__FILE__);
-        $this->assertEquals(__FILE__, $this->config->getEntropyFile());
+        self::assertEquals('BARBAZ', ini_get('session.referer_check'));
     }
 
-    public function testEntropyFileAltersIniSetting()
+    public function testSetEntropyFileError(): void
     {
-        $this->assertPhpLessThan71('session.entropy_file directive removed in PHP 7.1');
-        $this->config->setEntropyFile(__FILE__);
-        $this->assertEquals(__FILE__, ini_get('session.entropy_file'));
-    }
-
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSetEntropyFileError()
-    {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->getEntropyFile();
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testGetEntropyFileError()
+    public function testGetEntropyFileError(): void
     {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->setEntropyFile(__FILE__);
     }
 
     // session.entropy_length
 
-    public function testEntropyLengthDefaultsToIniSettings()
-    {
-        $this->assertPhpLessThan71('session.entropy_length directive removed in PHP 7.1');
-        $this->assertSame(ini_get('session.entropy_length'), $this->config->getEntropyLength());
-    }
-
-    public function testEntropyLengthIsMutable()
-    {
-        $this->assertPhpLessThan71('session.entropy_length directive removed in PHP 7.1');
-        $this->config->setEntropyLength(20);
-        $this->assertEquals(20, $this->config->getEntropyLength());
-    }
-
-    public function testEntropyLengthAltersIniSetting()
-    {
-        $this->assertPhpLessThan71('session.entropy_length directive removed in PHP 7.1');
-        $this->config->setEntropyLength(24);
-        $this->assertEquals(24, ini_get('session.entropy_length'));
-    }
-
-    public function testEntropyLengthCanBeZero()
-    {
-        $this->assertPhpLessThan71('session.entropy_length directive removed in PHP 7.1');
-        $this->config->setEntropyLength(0);
-        $this->assertEquals(0, ini_get('session.entropy_length'));
-    }
-
-    public function testSettingInvalidEntropyLengthRaisesException()
+    public function testGetEntropyLengthError(): void
     {
-        $this->assertPhpLessThan71('session.entropy_length directive removed in PHP 7.1');
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
-        $this->expectExceptionMessage('Invalid entropy_length; must be numeric');
-        $this->config->setEntropyLength('foobar_bogus');
-    }
-
-    public function testSettingInvalidEntropyLengthRaisesException2()
-    {
-        $this->assertPhpLessThan71('session.entropy_length directive removed in PHP 7.1');
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
-        $this->expectExceptionMessage('Invalid entropy_length; must be a positive integer or zero');
-        $this->config->setEntropyLength(-1);
-    }
-
-    /**
-     * @requires PHP 7.1
-     */
-    public function testGetEntropyLengthError()
-    {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->getEntropyLength();
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSetEntropyLengthError()
+    public function testSetEntropyLengthError(): void
     {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->setEntropyLength(0);
     }
 
     // session.cache_limiter
 
-    public function cacheLimiters()
+    public function cacheLimiters(): array
     {
         return [
             [''],
@@ -633,93 +540,93 @@ public function cacheLimiters()
         ];
     }
 
-    public function testCacheLimiterDefaultsToIniSettings()
+    public function testCacheLimiterDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.cache_limiter'), $this->config->getCacheLimiter());
+        self::assertSame(ini_get('session.cache_limiter'), $this->config->getCacheLimiter());
     }
 
     /**
      * @dataProvider cacheLimiters
      */
-    public function testCacheLimiterIsMutable($cacheLimiter)
+    public function testCacheLimiterIsMutable($cacheLimiter): void
     {
         $this->config->setCacheLimiter($cacheLimiter);
-        $this->assertEquals($cacheLimiter, $this->config->getCacheLimiter());
+        self::assertEquals($cacheLimiter, $this->config->getCacheLimiter());
     }
 
     /**
      * @dataProvider cacheLimiters
      */
-    public function testCacheLimiterAltersIniSetting($cacheLimiter)
+    public function testCacheLimiterAltersIniSetting($cacheLimiter): void
     {
         $this->config->setCacheLimiter($cacheLimiter);
-        $this->assertEquals($cacheLimiter, ini_get('session.cache_limiter'));
+        self::assertEquals($cacheLimiter, ini_get('session.cache_limiter'));
     }
 
-    public function testSettingInvalidCacheLimiterRaisesException()
+    public function testSettingInvalidCacheLimiterRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid cache limiter provided');
         $this->config->setCacheLimiter('foobar_bogus');
     }
 
     // session.cache_expire
 
-    public function testCacheExpireDefaultsToIniSettings()
+    public function testCacheExpireDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.cache_expire'), $this->config->getCacheExpire());
+        self::assertSame(ini_get('session.cache_expire'), $this->config->getCacheExpire());
     }
 
-    public function testCacheExpireIsMutable()
+    public function testCacheExpireIsMutable(): void
     {
         $this->config->setCacheExpire(20);
-        $this->assertEquals(20, $this->config->getCacheExpire());
+        self::assertEquals(20, $this->config->getCacheExpire());
     }
 
-    public function testCacheExpireAltersIniSetting()
+    public function testCacheExpireAltersIniSetting(): void
     {
         $this->config->setCacheExpire(24);
-        $this->assertEquals(24, ini_get('session.cache_expire'));
+        self::assertEquals(24, ini_get('session.cache_expire'));
     }
 
-    public function testSettingInvalidCacheExpireRaisesException()
+    public function testSettingInvalidCacheExpireRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid cache_expire; must be numeric');
         $this->config->setCacheExpire('foobar_bogus');
     }
 
-    public function testSettingInvalidCacheExpireRaisesException2()
+    public function testSettingInvalidCacheExpireRaisesException2(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid cache_expire; must be a positive integer');
         $this->config->setCacheExpire(-1);
     }
 
     // session.use_trans_sid
 
-    public function testUseTransSidDefaultsToIniSettings()
+    public function testUseTransSidDefaultsToIniSettings(): void
     {
-        $this->assertSame((bool) ini_get('session.use_trans_sid'), $this->config->getUseTransSid());
+        self::assertSame((bool)ini_get('session.use_trans_sid'), $this->config->getUseTransSid());
     }
 
-    public function testUseTransSidIsMutable()
+    public function testUseTransSidIsMutable(): void
     {
         $value = ! ini_get('session.use_trans_sid');
         $this->config->setOption('use_trans_sid', $value);
-        $this->assertEquals($value, (bool) $this->config->getOption('use_trans_sid'));
+        self::assertEquals($value, (bool)$this->config->getOption('use_trans_sid'));
     }
 
-    public function testUseTransSidAltersIniSetting()
+    public function testUseTransSidAltersIniSetting(): void
     {
         $value = ! ini_get('session.use_trans_sid');
         $this->config->setOption('use_trans_sid', $value);
-        $this->assertEquals($value, (bool) ini_get('session.use_trans_sid'));
+        self::assertEquals($value, (bool)ini_get('session.use_trans_sid'));
     }
 
     // session.hash_function
 
-    public function hashFunctions()
+    public function hashFunctions(): array
     {
         $hashFunctions = array_merge([0, 1], hash_algos());
         $provider      = [];
@@ -729,61 +636,21 @@ public function hashFunctions()
         return $provider;
     }
 
-    public function testHashFunctionDefaultsToIniSettings()
-    {
-        $this->assertPhpLessThan71('session.hash_function directive removed in PHP 7.1');
-        $this->assertSame(ini_get('session.hash_function'), $this->config->getHashFunction());
-    }
-
-    /**
-     * @dataProvider hashFunctions
-     */
-    public function testHashFunctionIsMutable($hashFunction)
+    public function testGetHashFunctionError(): void
     {
-        $this->assertPhpLessThan71('session.hash_function directive removed in PHP 7.1');
-        $this->config->setHashFunction($hashFunction);
-        $this->assertEquals($hashFunction, $this->config->getHashFunction());
-    }
-
-    /**
-     * @dataProvider hashFunctions
-     */
-    public function testHashFunctionAltersIniSetting($hashFunction)
-    {
-        $this->assertPhpLessThan71('session.hash_function directive removed in PHP 7.1');
-        $this->config->setHashFunction($hashFunction);
-        $this->assertEquals($hashFunction, ini_get('session.hash_function'));
-    }
-
-    public function testSettingInvalidHashFunctionRaisesException()
-    {
-        $this->assertPhpLessThan71('session.hash_function directive removed in PHP 7.1');
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
-        $this->expectExceptionMessage('Invalid hash function provided');
-        $this->config->setHashFunction('foobar_bogus');
-    }
-
-    /**
-     * @requires PHP 7.1
-     */
-    public function testGetHashFunctionError()
-    {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->getHashFunction();
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSetHashFunctionError()
+    public function testSetHashFunctionError(): void
     {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->setHashFunction('foobar_bogus');
     }
 
     // session.hash_bits_per_character
 
-    public function hashBitsPerCharacters()
+    public function hashBitsPerCharacters(): array
     {
         return [
             [4],
@@ -792,112 +659,54 @@ public function hashBitsPerCharacters()
         ];
     }
 
-    public function testHashBitsPerCharacterDefaultsToIniSettings()
-    {
-        if (PHP_VERSION_ID >= 70100) {
-            $this->markTestSkipped('session.hash_bits_per_character directive removed in PHP 7.1');
-        }
-
-        $this->assertSame(ini_get('session.hash_bits_per_character'), $this->config->getHashBitsPerCharacter());
-    }
-
-    /**
-     * @dataProvider hashBitsPerCharacters
-     */
-    public function testHashBitsPerCharacterIsMutable($hashBitsPerCharacter)
-    {
-        $this->assertPhpLessThan71('session.hash_bits_per_character directive removed in PHP 7.1');
-        $this->config->setHashBitsPerCharacter($hashBitsPerCharacter);
-        $this->assertEquals($hashBitsPerCharacter, $this->config->getHashBitsPerCharacter());
-    }
-
-    /**
-     * @dataProvider hashBitsPerCharacters
-     */
-    public function testHashBitsPerCharacterAltersIniSetting($hashBitsPerCharacter)
-    {
-        $this->assertPhpLessThan71('session.hash_bits_per_character directive removed in PHP 7.1');
-        $this->config->setHashBitsPerCharacter($hashBitsPerCharacter);
-        $this->assertEquals($hashBitsPerCharacter, ini_get('session.hash_bits_per_character'));
-    }
-
-    public function testSettingInvalidHashBitsPerCharacterRaisesException()
+    public function testGetHashBitsPerCharacterError(): void
     {
-        $this->assertPhpLessThan71('session.hash_bits_per_character directive removed in PHP 7.1');
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
-        $this->expectExceptionMessage('Invalid hash bits per character provided');
-        $this->config->setHashBitsPerCharacter('foobar_bogus');
-    }
-
-    /**
-     * @requires PHP 7.1
-     */
-    public function testGetHashBitsPerCharacterError()
-    {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->getHashBitsPerCharacter();
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSetHashBitsPerCharacterError()
+    public function testSetHashBitsPerCharacterError(): void
     {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->setHashBitsPerCharacter(5);
     }
 
     // session.sid_length
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSidLengthDefaultsToIniSettings()
+    public function testSidLengthDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.sid_length'), $this->config->getSidLength());
+        self::assertSame(ini_get('session.sid_length'), $this->config->getSidLength());
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSidLengthIsMutable()
+    public function testSidLengthIsMutable(): void
     {
         $this->config->setSidLength(40);
-        $this->assertEquals(40, $this->config->getSidLength());
+        self::assertEquals(40, $this->config->getSidLength());
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSidLengthAltersIniSetting()
+    public function testSidLengthAltersIniSetting(): void
     {
         $this->config->setSidLength(40);
-        $this->assertEquals(40, ini_get('session.sid_length'));
+        self::assertEquals(40, ini_get('session.sid_length'));
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSettingInvalidSidLengthRaisesException()
+    public function testSettingInvalidSidLengthRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid length provided');
         $this->config->setSidLength('foobar_bogus');
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSettingOutOfRangeSidLengthRaisesException()
+    public function testSettingOutOfRangeSidLengthRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid length provided');
         $this->config->setSidLength(999);
     }
 
     // session.sid_bits_per_character
 
-    public function sidSidPerCharacters()
+    public function sidSidPerCharacters(): array
     {
         return [
             [4],
@@ -906,84 +715,73 @@ public function sidSidPerCharacters()
         ];
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSidBitsPerCharacterDefaultsToIniSettings()
+    public function testSidBitsPerCharacterDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('session.sid_bits_per_character'), $this->config->getSidBitsPerCharacter());
+        self::assertSame(ini_get('session.sid_bits_per_character'), $this->config->getSidBitsPerCharacter());
     }
 
     /**
-     * @requires PHP 7.1
      * @dataProvider sidSidPerCharacters
      */
-    public function testSidBitsPerCharacterIsMutable($sidBitsPerCharacter)
+    public function testSidBitsPerCharacterIsMutable($sidBitsPerCharacter): void
     {
         $this->config->setSidBitsPerCharacter($sidBitsPerCharacter);
-        $this->assertEquals($sidBitsPerCharacter, $this->config->getSidBitsPerCharacter());
+        self::assertEquals($sidBitsPerCharacter, $this->config->getSidBitsPerCharacter());
     }
 
     /**
-     * @requires PHP 7.1
      * @dataProvider sidSidPerCharacters
      */
-    public function testSidBitsPerCharacterAltersIniSetting($sidBitsPerCharacter)
+    public function testSidBitsPerCharacterAltersIniSetting($sidBitsPerCharacter): void
     {
         $this->config->setSidBitsPerCharacter($sidBitsPerCharacter);
-        $this->assertEquals($sidBitsPerCharacter, ini_get('session.sid_bits_per_character'));
+        self::assertEquals($sidBitsPerCharacter, ini_get('session.sid_bits_per_character'));
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSettingInvalidSidBitsPerCharacterRaisesException()
+    public function testSettingInvalidSidBitsPerCharacterRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid sid bits per character provided');
         $this->config->setSidBitsPerCharacter('foobar_bogus');
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSettingOutOfBoundSidBitsPerCharacterRaisesException()
+    public function testSettingOutOfBoundSidBitsPerCharacterRaisesException(): void
     {
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
+        $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid sid bits per character provided');
         $this->config->setSidBitsPerCharacter(999);
     }
 
     // url_rewriter.tags
 
-    public function testUrlRewriterTagsDefaultsToIniSettings()
+    public function testUrlRewriterTagsDefaultsToIniSettings(): void
     {
-        $this->assertSame(ini_get('url_rewriter.tags'), $this->config->getUrlRewriterTags());
+        self::assertSame(ini_get('url_rewriter.tags'), $this->config->getUrlRewriterTags());
     }
 
-    public function testUrlRewriterTagsIsMutable()
+    public function testUrlRewriterTagsIsMutable(): void
     {
         $this->config->setUrlRewriterTags('a=href,form=action');
-        $this->assertEquals('a=href,form=action', $this->config->getUrlRewriterTags());
+        self::assertEquals('a=href,form=action', $this->config->getUrlRewriterTags());
     }
 
-    public function testUrlRewriterTagsAltersIniSetting()
+    public function testUrlRewriterTagsAltersIniSetting(): void
     {
         $this->config->setUrlRewriterTags('a=href,fieldset=');
-        $this->assertEquals('a=href,fieldset=', ini_get('url_rewriter.tags'));
+        self::assertEquals('a=href,fieldset=', ini_get('url_rewriter.tags'));
     }
 
     // remember_me_seconds
 
-    public function testRememberMeSecondsDefaultsToTwoWeeks()
+    public function testRememberMeSecondsDefaultsToTwoWeeks(): void
     {
-        $this->assertEquals(1209600, $this->config->getRememberMeSeconds());
+        self::assertEquals(1209600, $this->config->getRememberMeSeconds());
     }
 
-    public function testRememberMeSecondsIsMutable()
+    public function testRememberMeSecondsIsMutable(): void
     {
         $this->config->setRememberMeSeconds(604800);
-        $this->assertEquals(604800, $this->config->getRememberMeSeconds());
+        self::assertEquals(604800, $this->config->getRememberMeSeconds());
     }
 
     // setOption
@@ -991,33 +789,33 @@ public function testRememberMeSecondsIsMutable()
     /**
      * @dataProvider optionsProvider
      */
-    public function testSetOptionSetsIniSetting($option, $getter, $value)
+    public function testSetOptionSetsIniSetting($option, $getter, $value): void
     {
         // Leaving out special cases.
-        if ($option == 'remember_me_seconds' || $option == 'url_rewriter_tags') {
-            $this->markTestSkipped('remember_me_seconds && url_rewriter_tags');
+        if ($option === 'remember_me_seconds' || $option === 'url_rewriter_tags') {
+            self::markTestSkipped('remember_me_seconds && url_rewriter_tags');
         }
 
         $this->config->setStorageOption($option, $value);
-        $this->assertEquals(ini_get('session.' . $option), $value);
+        self::assertEquals(ini_get('session.' . $option), $value);
     }
 
-    public function testSetOptionUrlRewriterTagsGetsMunged()
+    public function testSetOptionUrlRewriterTagsGetsMunged(): void
     {
         $value = 'a=href';
         $this->config->setStorageOption('url_rewriter_tags', $value);
-        $this->assertEquals(ini_get('url_rewriter.tags'), $value);
+        self::assertEquals(ini_get('url_rewriter.tags'), $value);
     }
 
-    public function testSetOptionRememberMeSecondsDoesNothing()
+    public function testSetOptionRememberMeSecondsDoesNothing(): void
     {
-        $this->markTestIncomplete('I have no idea how to test this.');
+        self::markTestIncomplete('I have no idea how to test this.');
     }
 
-    public function testSetOptionsThrowsExceptionOnInvalidKey()
+    public function testSetOptionsThrowsExceptionOnInvalidKey(): void
     {
         $badKey = 'snarfblat';
-        $value = 'foobar';
+        $value  = 'foobar';
 
         $this->expectException('InvalidArgumentException');
         $this->config->setStorageOption($badKey, $value);
@@ -1028,18 +826,18 @@ public function testSetOptionsThrowsExceptionOnInvalidKey()
     /**
      * @dataProvider optionsProvider
      */
-    public function testSetOptionsTranslatesUnderscoreSeparatedKeys($option, $getter, $value)
+    public function testSetOptionsTranslatesUnderscoreSeparatedKeys($option, $getter, $value): void
     {
         $options = [$option => $value];
         $this->config->setOptions($options);
-        if ('getOption' == $getter) {
-            $this->assertSame($value, $this->config->getOption($option));
+        if ('getOption' === $getter) {
+            self::assertSame($value, $this->config->getOption($option));
         } else {
-            $this->assertSame($value, $this->config->$getter());
+            self::assertSame($value, $this->config->$getter());
         }
     }
 
-    public function optionsProvider()
+    public function optionsProvider(): array
     {
         $commonOptions = [
             [
@@ -1137,63 +935,29 @@ public function optionsProvider()
                 'getUrlRewriterTags',
                 'a=href',
             ],
-        ];
-
-        // These options are no longer present as of PHP 7.1.0
-        if (PHP_VERSION_ID < 70100) {
-            $commonOptions[] = [
-                'entropy_file',
-                'getEntropyFile',
-                __FILE__,
-            ];
-
-            $commonOptions[] = [
-                'entropy_length',
-                'getEntropyLength',
-                42,
-            ];
-
-            // The docs do not say this was removed for 7.1.0, but tests fail
-            // on 7.1.0 due to this one.
-            $commonOptions[] = [
-                'hash_function',
-                'getHashFunction',
-                'md5',
-            ];
-
-            $commonOptions[] = [
-                'hash_bits_per_character',
-                'getOption',
-                5,
-            ];
-        }
-
-        // New options as of PHP 7.1.0
-        if (PHP_VERSION_ID >= 70100) {
-            $commonOptions[] = [
+            [
                 'sid_length',
                 'getSidLength',
                 40,
-            ];
-
-            $commonOptions[] = [
+            ],
+            [
                 'sid_bits_per_character',
                 'getSidBitsPerCharacter',
                 5,
-            ];
-        }
+            ],
+        ];
 
         return $commonOptions;
     }
 
-    public function testSetPhpSaveHandlerRaisesExceptionForAttemptsToSetUserModule()
+    public function testSetPhpSaveHandlerRaisesExceptionForAttemptsToSetUserModule(): void
     {
         $this->expectException(Exception\InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid save handler specified ("user")');
         $this->config->setPhpSaveHandler('user');
     }
 
-    public function testErrorSettingKnownSaveHandlerResultsInException()
+    public function testErrorSettingKnownSaveHandlerResultsInException(): void
     {
         $r = new ReflectionProperty($this->config, 'knownSaveHandlers');
         $r->setAccessible(true);
@@ -1204,7 +968,7 @@ public function testErrorSettingKnownSaveHandlerResultsInException()
         $this->config->setPhpSaveHandler('notreallyredis');
     }
 
-    public function testProvidingNonSessionHandlerToSetPhpSaveHandlerResultsInException()
+    public function testProvidingNonSessionHandlerToSetPhpSaveHandlerResultsInException(): void
     {
         $handler = new stdClass();
 
@@ -1213,49 +977,57 @@ public function testProvidingNonSessionHandlerToSetPhpSaveHandlerResultsInExcept
         $this->config->setPhpSaveHandler($handler);
     }
 
-    public function testProvidingValidKnownSessionHandlerToSetPhpSaveHandlerResultsInNoErrors()
+    public function testProvidingValidKnownSessionHandlerToSetPhpSaveHandlerResultsInNoErrors(): void
     {
         $phpinfo = $this->getFunctionMock('Laminas\Session\Config', 'phpinfo');
         $phpinfo
-            ->expects($this->once())
-            ->will($this->returnCallback(function () {
-                echo "Registered save handlers => user files unittest";
-            }));
+            ->expects(self::once())
+            ->will(
+                self::returnCallback(
+                    function () {
+                        echo "Registered save handlers => user files unittest";
+                    }
+                )
+            );
 
         $sessionModuleName = $this->getFunctionMock('Laminas\Session\Config', 'session_module_name');
-        $sessionModuleName->expects($this->once());
+        $sessionModuleName->expects(self::once());
 
-        $this->assertSame($this->config, $this->config->setPhpSaveHandler('unittest'));
-        $this->assertEquals('unittest', $this->config->getOption('save_handler'));
+        self::assertSame($this->config, $this->config->setPhpSaveHandler('unittest'));
+        self::assertEquals('unittest', $this->config->getOption('save_handler'));
     }
 
-    public function testCanProvidePathWhenUsingRedisSaveHandler()
+    public function testCanProvidePathWhenUsingRedisSaveHandler(): void
     {
         $phpinfo = $this->getFunctionMock('Laminas\Session\Config', 'phpinfo');
         $phpinfo
-            ->expects($this->once())
-            ->will($this->returnCallback(function () {
-                echo "Registered save handlers => user files redis";
-            }));
+            ->expects(self::once())
+            ->will(
+                self::returnCallback(
+                    function () {
+                        echo "Registered save handlers => user files redis";
+                    }
+                )
+            );
 
         $sessionModuleName = $this->getFunctionMock('Laminas\Session\Config', 'session_module_name');
         $sessionModuleName
-            ->expects($this->once())
-            ->with($this->equalTo('redis'));
+            ->expects(self::once())
+            ->with(self::equalTo('redis'));
 
         $url = 'tcp://localhost:6379?auth=foobar&database=1';
 
         $this->config->setOption('save_handler', 'redis');
         $this->config->setOption('save_path', $url);
 
-        $this->assertSame($url, $this->config->getOption('save_path'));
+        self::assertSame($url, $this->config->getOption('save_path'));
     }
 
-    public function testNotCallLocateRegisteredSaveHandlersMethodIfSessionHandlerInterfaceWasPassed()
+    public function testNotCallLocateRegisteredSaveHandlersMethodIfSessionHandlerInterfaceWasPassed(): void
     {
         $phpinfo = $this->getFunctionMock('Laminas\Session\Config', 'phpinfo');
         $phpinfo
-            ->expects($this->never());
+            ->expects(self::never());
 
         $saveHandler = $this->createMock(SessionHandlerInterface::class);
         $this->config->setPhpSaveHandler($saveHandler);
diff --git a/test/Config/StandardConfigTest.php b/test/Config/StandardConfigTest.php
index 6600b5e3..872d8ebc 100644
--- a/test/Config/StandardConfigTest.php
+++ b/test/Config/StandardConfigTest.php
@@ -21,70 +21,71 @@ class StandardConfigTest extends TestCase
      */
     protected $config;
 
-    protected function setUp()
+    protected function setUp(): void
     {
-        $this->config = new StandardConfig;
+        $this->config = new StandardConfig();
     }
 
     // session.save_path
 
-    public function testSetSavePathErrorsOnInvalidPath()
+    public function testSetSavePathErrorsOnInvalidPath(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid save_path provided');
         $this->config->setSavePath(__DIR__ . '/foobarboguspath');
     }
 
-    public function testSavePathIsMutable()
+    public function testSavePathIsMutable(): void
     {
         $this->config->setSavePath(__DIR__);
-        $this->assertEquals(__DIR__, $this->config->getSavePath());
+        self::assertEquals(__DIR__, $this->config->getSavePath());
     }
+
     // session.name
 
-    public function testNameIsMutable()
+    public function testNameIsMutable(): void
     {
         $this->config->setName('FOOBAR');
-        $this->assertEquals('FOOBAR', $this->config->getName());
+        self::assertEquals('FOOBAR', $this->config->getName());
     }
 
     // session.save_handler
 
-    public function testSaveHandlerIsMutable()
+    public function testSaveHandlerIsMutable(): void
     {
         $this->config->setSaveHandler('user');
-        $this->assertEquals('user', $this->config->getSaveHandler());
+        self::assertEquals('user', $this->config->getSaveHandler());
     }
 
     // session.gc_probability
 
-    public function testGcProbabilityIsMutable()
+    public function testGcProbabilityIsMutable(): void
     {
         $this->config->setGcProbability(20);
-        $this->assertEquals(20, $this->config->getGcProbability());
+        self::assertEquals(20, $this->config->getGcProbability());
     }
 
-    public function testGcProbabilityCanBeSetToZero()
+    public function testGcProbabilityCanBeSetToZero(): void
     {
         $this->config->setGcProbability(0);
-        $this->assertEquals(0, $this->config->getGcProbability());
+        self::assertEquals(0, $this->config->getGcProbability());
     }
 
-    public function testSettingInvalidGcProbabilityRaisesException()
+    public function testSettingInvalidGcProbabilityRaisesException(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid gc_probability; must be numeric');
         $this->config->setGcProbability('foobar_bogus');
     }
 
-    public function testSettingInvalidGcProbabilityRaisesException2()
+    public function testSettingInvalidGcProbabilityRaisesException2(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid gc_probability; must be a percentage');
         $this->config->setGcProbability(-1);
     }
 
-    public function testSettingInvalidGcProbabilityRaisesException3()
+    public function testSettingInvalidGcProbabilityRaisesException3(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid gc_probability; must be a percentage');
@@ -93,20 +94,20 @@ public function testSettingInvalidGcProbabilityRaisesException3()
 
     // session.gc_divisor
 
-    public function testGcDivisorIsMutable()
+    public function testGcDivisorIsMutable(): void
     {
         $this->config->setGcDivisor(20);
-        $this->assertEquals(20, $this->config->getGcDivisor());
+        self::assertEquals(20, $this->config->getGcDivisor());
     }
 
-    public function testSettingInvalidGcDivisorRaisesException()
+    public function testSettingInvalidGcDivisorRaisesException(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid gc_divisor; must be numeric');
         $this->config->setGcDivisor('foobar_bogus');
     }
 
-    public function testSettingInvalidGcDivisorRaisesException2()
+    public function testSettingInvalidGcDivisorRaisesException2(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid gc_divisor; must be a positive integer');
@@ -115,20 +116,20 @@ public function testSettingInvalidGcDivisorRaisesException2()
 
     // session.gc_maxlifetime
 
-    public function testGcMaxlifetimeIsMutable()
+    public function testGcMaxlifetimeIsMutable(): void
     {
         $this->config->setGcMaxlifetime(20);
-        $this->assertEquals(20, $this->config->getGcMaxlifetime());
+        self::assertEquals(20, $this->config->getGcMaxlifetime());
     }
 
-    public function testSettingInvalidGcMaxlifetimeRaisesException()
+    public function testSettingInvalidGcMaxlifetimeRaisesException(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid gc_maxlifetime; must be numeric');
         $this->config->setGcMaxlifetime('foobar_bogus');
     }
 
-    public function testSettingInvalidGcMaxlifetimeRaisesException2()
+    public function testSettingInvalidGcMaxlifetimeRaisesException2(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid gc_maxlifetime; must be a positive integer');
@@ -137,35 +138,35 @@ public function testSettingInvalidGcMaxlifetimeRaisesException2()
 
     // session.serialize_handler
 
-    public function testSerializeHandlerIsMutable()
+    public function testSerializeHandlerIsMutable(): void
     {
         $value = extension_loaded('wddx') ? 'wddx' : 'php_binary';
         $this->config->setSerializeHandler($value);
-        $this->assertEquals($value, $this->config->getSerializeHandler());
+        self::assertEquals($value, $this->config->getSerializeHandler());
     }
 
     // session.cookie_lifetime
 
-    public function testCookieLifetimeIsMutable()
+    public function testCookieLifetimeIsMutable(): void
     {
         $this->config->setCookieLifetime(20);
-        $this->assertEquals(20, $this->config->getCookieLifetime());
+        self::assertEquals(20, $this->config->getCookieLifetime());
     }
 
-    public function testCookieLifetimeCanBeZero()
+    public function testCookieLifetimeCanBeZero(): void
     {
         $this->config->setCookieLifetime(0);
-        $this->assertEquals(0, $this->config->getCookieLifetime());
+        self::assertEquals(0, $this->config->getCookieLifetime());
     }
 
-    public function testSettingInvalidCookieLifetimeRaisesException()
+    public function testSettingInvalidCookieLifetimeRaisesException(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid cookie_lifetime; must be numeric');
         $this->config->setCookieLifetime('foobar_bogus');
     }
 
-    public function testSettingInvalidCookieLifetimeRaisesException2()
+    public function testSettingInvalidCookieLifetimeRaisesException2(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid cookie_lifetime; must be a positive integer or zero');
@@ -174,27 +175,27 @@ public function testSettingInvalidCookieLifetimeRaisesException2()
 
     // session.cookie_path
 
-    public function testCookiePathIsMutable()
+    public function testCookiePathIsMutable(): void
     {
         $this->config->setCookiePath('/foo');
-        $this->assertEquals('/foo', $this->config->getCookiePath());
+        self::assertEquals('/foo', $this->config->getCookiePath());
     }
 
-    public function testSettingInvalidCookiePathRaisesException()
+    public function testSettingInvalidCookiePathRaisesException(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid cookie path');
         $this->config->setCookiePath(24);
     }
 
-    public function testSettingInvalidCookiePathRaisesException2()
+    public function testSettingInvalidCookiePathRaisesException2(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid cookie path');
         $this->config->setCookiePath('foo');
     }
 
-    public function testSettingInvalidCookiePathRaisesException3()
+    public function testSettingInvalidCookiePathRaisesException3(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid cookie path');
@@ -203,26 +204,26 @@ public function testSettingInvalidCookiePathRaisesException3()
 
     // session.cookie_domain
 
-    public function testCookieDomainIsMutable()
+    public function testCookieDomainIsMutable(): void
     {
         $this->config->setCookieDomain('example.com');
-        $this->assertEquals('example.com', $this->config->getCookieDomain());
+        self::assertEquals('example.com', $this->config->getCookieDomain());
     }
 
-    public function testCookieDomainCanBeEmpty()
+    public function testCookieDomainCanBeEmpty(): void
     {
         $this->config->setCookieDomain('');
-        $this->assertEquals('', $this->config->getCookieDomain());
+        self::assertEquals('', $this->config->getCookieDomain());
     }
 
-    public function testSettingInvalidCookieDomainRaisesException()
+    public function testSettingInvalidCookieDomainRaisesException(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid cookie domain: must be a string');
         $this->config->setCookieDomain(24);
     }
 
-    public function testSettingInvalidCookieDomainRaisesException2()
+    public function testSettingInvalidCookieDomainRaisesException2(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('does not match the expected structure for a DNS hostname');
@@ -231,156 +232,77 @@ public function testSettingInvalidCookieDomainRaisesException2()
 
     // session.cookie_secure
 
-    public function testCookieSecureIsMutable()
+    public function testCookieSecureIsMutable(): void
     {
         $this->config->setCookieSecure(true);
-        $this->assertEquals(true, $this->config->getCookieSecure());
+        self::assertEquals(true, $this->config->getCookieSecure());
     }
 
     // session.cookie_httponly
 
-    public function testCookieHttpOnlyIsMutable()
+    public function testCookieHttpOnlyIsMutable(): void
     {
         $this->config->setCookieHttpOnly(true);
-        $this->assertEquals(true, $this->config->getCookieHttpOnly());
+        self::assertEquals(true, $this->config->getCookieHttpOnly());
     }
 
     // session.use_cookies
 
-    public function testUseCookiesIsMutable()
+    public function testUseCookiesIsMutable(): void
     {
         $this->config->setUseCookies(true);
-        $this->assertEquals(true, (bool) $this->config->getUseCookies());
+        self::assertEquals(true, (bool)$this->config->getUseCookies());
     }
 
     // session.use_only_cookies
 
-    public function testUseOnlyCookiesIsMutable()
+    public function testUseOnlyCookiesIsMutable(): void
     {
         $this->config->setUseOnlyCookies(true);
-        $this->assertEquals(true, (bool) $this->config->getUseOnlyCookies());
+        self::assertEquals(true, (bool)$this->config->getUseOnlyCookies());
     }
 
     // session.referer_check
 
-    public function testRefererCheckIsMutable()
+    public function testRefererCheckIsMutable(): void
     {
         $this->config->setRefererCheck('FOOBAR');
-        $this->assertEquals('FOOBAR', $this->config->getRefererCheck());
+        self::assertEquals('FOOBAR', $this->config->getRefererCheck());
     }
 
-    public function testRefererCheckMayBeEmpty()
+    public function testRefererCheckMayBeEmpty(): void
     {
         $this->config->setRefererCheck('');
-        $this->assertEquals('', $this->config->getRefererCheck());
-    }
-
-    // session.entropy_file
-
-    public function testSetEntropyFileErrorsOnInvalidPath()
-    {
-        if (PHP_VERSION_ID >= 70100) {
-            $this->markTestSkipped('session.entropy_file directive removed in PHP 7.1');
-        }
-
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
-        $this->expectExceptionMessage('Invalid entropy_file provided');
-        $this->config->setEntropyFile(__DIR__ . '/foobarboguspath');
+        self::assertEquals('', $this->config->getRefererCheck());
     }
 
-    public function testEntropyFileIsMutable()
+    public function testSetEntropyFileError(): void
     {
-        if (PHP_VERSION_ID >= 70100) {
-            $this->markTestSkipped('session.entropy_file directive removed in PHP 7.1');
-        }
-
-        $this->config->setEntropyFile(__FILE__);
-        $this->assertEquals(__FILE__, $this->config->getEntropyFile());
-    }
-
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSetEntropyFileError()
-    {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->getEntropyFile();
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testGetEntropyFileError()
+    public function testGetEntropyFileError(): void
     {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->setEntropyFile(__FILE__);
     }
 
-    // session.entropy_length
-
-    public function testEntropyLengthIsMutable()
-    {
-        if (PHP_VERSION_ID >= 70100) {
-            $this->markTestSkipped('session.entropy_length directive removed in PHP 7.1');
-        }
-
-        $this->config->setEntropyLength(20);
-        $this->assertEquals(20, $this->config->getEntropyLength());
-    }
-
-    public function testEntropyLengthCanBeZero()
-    {
-        if (PHP_VERSION_ID >= 70100) {
-            $this->markTestSkipped('session.entropy_length directive removed in PHP 7.1');
-        }
-
-        $this->config->setEntropyLength(0);
-        $this->assertEquals(0, $this->config->getEntropyLength());
-    }
-
-    public function testSettingInvalidEntropyLengthRaisesException()
-    {
-        if (PHP_VERSION_ID >= 70100) {
-            $this->markTestSkipped('session.entropy_length directive removed in PHP 7.1');
-        }
-
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
-        $this->expectExceptionMessage('Invalid entropy_length; must be numeric');
-        $this->config->setEntropyLength('foobar_bogus');
-    }
-
-    public function testSettingInvalidEntropyLengthRaisesException2()
-    {
-        if (PHP_VERSION_ID >= 70100) {
-            $this->markTestSkipped('session.entropy_length directive removed in PHP 7.1');
-        }
-
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
-        $this->expectExceptionMessage('Invalid entropy_length; must be a positive integer or zero');
-        $this->config->setEntropyLength(-1);
-    }
-
-    /**
-     * @requires PHP 7.1
-     */
-    public function testGetEntropyLengthError()
+    public function testGetEntropyLengthError(): void
     {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->getEntropyLength();
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSetEntropyLengthError()
+    public function testSetEntropyLengthError(): void
     {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->setEntropyLength(0);
     }
 
     // session.cache_limiter
 
-    public function cacheLimiters()
+    public function cacheLimiters(): array
     {
         return [
             ['nocache'],
@@ -393,28 +315,28 @@ public function cacheLimiters()
     /**
      * @dataProvider cacheLimiters
      */
-    public function testCacheLimiterIsMutable($cacheLimiter)
+    public function testCacheLimiterIsMutable($cacheLimiter): void
     {
         $this->config->setCacheLimiter($cacheLimiter);
-        $this->assertEquals($cacheLimiter, $this->config->getCacheLimiter());
+        self::assertEquals($cacheLimiter, $this->config->getCacheLimiter());
     }
 
     // session.cache_expire
 
-    public function testCacheExpireIsMutable()
+    public function testCacheExpireIsMutable(): void
     {
         $this->config->setCacheExpire(20);
-        $this->assertEquals(20, $this->config->getCacheExpire());
+        self::assertEquals(20, $this->config->getCacheExpire());
     }
 
-    public function testSettingInvalidCacheExpireRaisesException()
+    public function testSettingInvalidCacheExpireRaisesException(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid cache_expire; must be numeric');
         $this->config->setCacheExpire('foobar_bogus');
     }
 
-    public function testSettingInvalidCacheExpireRaisesException2()
+    public function testSettingInvalidCacheExpireRaisesException2(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid cache_expire; must be a positive integer');
@@ -423,133 +345,52 @@ public function testSettingInvalidCacheExpireRaisesException2()
 
     // session.use_trans_sid
 
-    public function testUseTransSidIsMutable()
+    public function testUseTransSidIsMutable(): void
     {
         $this->config->setUseTransSid(true);
-        $this->assertEquals(true, (bool) $this->config->getUseTransSid());
-    }
-
-    // session.hash_function
-
-    public function hashFunctions()
-    {
-        $hashFunctions = array_merge([0, 1], hash_algos());
-        $provider      = [];
-        foreach ($hashFunctions as $function) {
-            $provider[] = [$function];
-        }
-        return $provider;
+        self::assertEquals(true, (bool)$this->config->getUseTransSid());
     }
 
-    /**
-     * @dataProvider hashFunctions
-     */
-    public function testHashFunctionIsMutable($hashFunction)
+    public function testGetHashFunctionError(): void
     {
-        if (PHP_VERSION_ID >= 70100) {
-            $this->markTestSkipped('session.hash_function directive removed in PHP 7.1');
-        }
-
-        $this->config->setHashFunction($hashFunction);
-        $this->assertEquals($hashFunction, $this->config->getHashFunction());
-    }
-
-    /**
-     * @requires PHP 7.1
-     */
-    public function testGetHashFunctionError()
-    {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->getHashFunction();
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSetHashFunctionError()
+    public function testSetHashFunctionError(): void
     {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->setHashFunction('foobar_bogus');
     }
 
-    // session.hash_bits_per_character
-
-    public function hashBitsPerCharacters()
+    public function testGetHashBitsPerCharacterError(): void
     {
-        return [
-            [4],
-            [5],
-            [6],
-        ];
-    }
-
-    /**
-     * @dataProvider hashBitsPerCharacters
-     */
-    public function testHashBitsPerCharacterIsMutable($hashBitsPerCharacter)
-    {
-        if (PHP_VERSION_ID >= 70100) {
-            $this->markTestSkipped('session.hash_bits_per_character directive removed in PHP 7.1');
-        }
-
-        $this->config->setHashBitsPerCharacter($hashBitsPerCharacter);
-        $this->assertEquals($hashBitsPerCharacter, $this->config->getHashBitsPerCharacter());
-    }
-
-    public function testSettingInvalidHashBitsPerCharacterRaisesException()
-    {
-        if (PHP_VERSION_ID >= 70100) {
-            $this->markTestSkipped('session.hash_bits_per_character directive removed in PHP 7.1');
-        }
-
-        $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
-        $this->expectExceptionMessage('Invalid hash bits per character provided');
-        $this->config->setHashBitsPerCharacter('foobar_bogus');
-    }
-
-    /**
-     * @requires PHP 7.1
-     */
-    public function testGetHashBitsPerCharacterError()
-    {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->getHashBitsPerCharacter();
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSetHashBitsPerCharacterError()
+    public function testSetHashBitsPerCharacterError(): void
     {
-        $this->expectException('PHPUnit\Framework\Error\Deprecated');
+        $this->expectDeprecation();
         $this->config->setHashBitsPerCharacter(5);
     }
 
     // session.sid_length
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSidLengthIsMutable()
+    public function testSidLengthIsMutable(): void
     {
         $this->config->setSidLength(40);
-        $this->assertEquals(40, $this->config->getSidLength());
+        self::assertEquals(40, $this->config->getSidLength());
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSettingInvalidSidLengthRaisesException()
+    public function testSettingInvalidSidLengthRaisesException(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid length provided');
         $this->config->setSidLength('foobar_bogus');
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSettingOutOfRangeSidLengthRaisesException()
+    public function testSettingOutOfRangeSidLengthRaisesException(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid length provided');
@@ -558,7 +399,7 @@ public function testSettingOutOfRangeSidLengthRaisesException()
 
     // session.sid_bits_per_character
 
-    public function sidBitsPerCharacters()
+    public function sidBitsPerCharacters(): array
     {
         return [
             [4],
@@ -568,19 +409,15 @@ public function sidBitsPerCharacters()
     }
 
     /**
-     * @requires PHP 7.1
      * @dataProvider sidBitsPerCharacters
      */
-    public function testSidBitsPerCharacterIsMutable($sidBitsPerCharacter)
+    public function testSidBitsPerCharacterIsMutable($sidBitsPerCharacter): void
     {
         $this->config->setSidBitsPerCharacter($sidBitsPerCharacter);
-        $this->assertEquals($sidBitsPerCharacter, $this->config->getSidBitsPerCharacter());
+        self::assertEquals($sidBitsPerCharacter, $this->config->getSidBitsPerCharacter());
     }
 
-    /**
-     * @requires PHP 7.1
-     */
-    public function testSettingInvalidSidBitsPerCharacterRaisesException()
+    public function testSettingInvalidSidBitsPerCharacterRaisesException(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid sid bits per character provided');
@@ -589,28 +426,28 @@ public function testSettingInvalidSidBitsPerCharacterRaisesException()
 
     // url_rewriter.tags
 
-    public function testUrlRewriterTagsIsMutable()
+    public function testUrlRewriterTagsIsMutable(): void
     {
         $this->config->setUrlRewriterTags('a=href,form=action');
-        $this->assertEquals('a=href,form=action', $this->config->getUrlRewriterTags());
+        self::assertEquals('a=href,form=action', $this->config->getUrlRewriterTags());
     }
 
     // remember_me_seconds
 
-    public function testRememberMeSecondsIsMutable()
+    public function testRememberMeSecondsIsMutable(): void
     {
         $this->config->setRememberMeSeconds(20);
-        $this->assertEquals(20, $this->config->getRememberMeSeconds());
+        self::assertEquals(20, $this->config->getRememberMeSeconds());
     }
 
-    public function testSettingInvalidRememberMeSecondsRaisesException()
+    public function testSettingInvalidRememberMeSecondsRaisesException(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid remember_me_seconds; must be numeric');
         $this->config->setRememberMeSeconds('foobar_bogus');
     }
 
-    public function testSettingInvalidRememberMeSecondsRaisesException2()
+    public function testSettingInvalidRememberMeSecondsRaisesException2(): void
     {
         $this->expectException('Laminas\Session\Exception\InvalidArgumentException');
         $this->expectExceptionMessage('Invalid remember_me_seconds; must be a positive integer');
@@ -622,14 +459,14 @@ public function testSettingInvalidRememberMeSecondsRaisesException2()
     /**
      * @dataProvider optionsProvider
      */
-    public function testSetOptionsTranslatesUnderscoreSeparatedKeys($option, $getter, $value)
+    public function testSetOptionsTranslatesUnderscoreSeparatedKeys($option, $getter, $value): void
     {
         $options = [$option => $value];
         $this->config->setOptions($options);
-        $this->assertSame($value, $this->config->$getter());
+        self::assertSame($value, $this->config->$getter());
     }
 
-    public function optionsProvider()
+    public function optionsProvider(): array
     {
         $commonOptions = [
             [
@@ -727,62 +564,18 @@ public function optionsProvider()
                 'getUrlRewriterTags',
                 'a=href',
             ],
-        ];
-
-        if (PHP_VERSION_ID < 70100) {
-            $commonOptions[] = [
-                'entropy_file',
-                'getEntropyFile',
-                __FILE__,
-            ];
-            $commonOptions[] = [
-                'entropy_length',
-                'getEntropyLength',
-                42,
-            ];
-            $commonOptions[] = [
-                'hash_function',
-                'getHashFunction',
-                'md5',
-            ];
-            $commonOptions[] = [
-                'hash_bits_per_character',
-                'getHashBitsPerCharacter',
-                5,
-            ];
-        } else {
-            $commonOptions[] = [
+            [
                 'sid_length',
                 'getSidLength',
                 40,
-            ];
-            $commonOptions[] = [
+            ],
+            [
                 'sid_bits_per_character',
                 'getSidBitsPerCharacter',
                 5,
-            ];
-        }
+            ],
+        ];
 
         return $commonOptions;
     }
-
-    /**
-     * Set entropy file /dev/urandom, see issue #3046
-     *
-     * @link https://github.com/zendframework/zf2/issues/3046
-     */
-    public function testSetEntropyDevUrandom()
-    {
-        if (PHP_VERSION_ID >= 70100) {
-            $this->markTestSkipped('session.entropy_file directive removed in PHP 7.1');
-        }
-
-        if (! file_exists('/dev/urandom')) {
-            $this->markTestSkipped(
-                "This test doesn't work because /dev/urandom file doesn't exist."
-            );
-        }
-        $result = $this->config->setEntropyFile('/dev/urandom');
-        $this->assertInstanceOf('Laminas\Session\Config\StandardConfig', $result);
-    }
 }
diff --git a/test/ConfigProviderTest.php b/test/ConfigProviderTest.php
new file mode 100644
index 00000000..4fb97600
--- /dev/null
+++ b/test/ConfigProviderTest.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaminasTest\Session;
+
+use Laminas\Session\Config\ConfigInterface;
+use Laminas\Session\ConfigProvider;
+use Laminas\Session\ManagerInterface;
+use Laminas\Session\Service\ContainerAbstractServiceFactory;
+use Laminas\Session\Service\SessionConfigFactory;
+use Laminas\Session\Service\SessionManagerFactory;
+use Laminas\Session\Service\StorageFactory;
+use Laminas\Session\SessionManager;
+use Laminas\Session\Storage\StorageInterface;
+use PHPUnit\Framework\TestCase;
+
+class ConfigProviderTest extends TestCase
+{
+    /** @var array<string, mixed> */
+    private $config;
+
+    protected function setUp(): void
+    {
+        $this->config = (new ConfigProvider())();
+    }
+
+    public function testProvidesDependencyConfig(): void
+    {
+        self::assertArrayHasKey('dependencies', $this->config);
+    }
+
+    public function testProvidesCorrectDependencyConfig(): void
+    {
+        $config = $this->config['dependencies'];
+
+        $abstractFactories = $config['abstract_factories'];
+        $aliases           = $config['aliases'];
+        $factories         = $config['factories'];
+
+        self::assertContains(ContainerAbstractServiceFactory::class, $abstractFactories);
+        self::assertSame($aliases[SessionManager::class], ManagerInterface::class);
+        self::assertSame($factories[ConfigInterface::class], SessionConfigFactory::class);
+        self::assertSame($factories[ManagerInterface::class], SessionManagerFactory::class);
+        self::assertSame($factories[StorageInterface::class], StorageFactory::class);
+    }
+
+    public function testProvidesAliasesForLegacyZendFrameworkClasses(): void
+    {
+        $config = $this->config['dependencies']['aliases'];
+
+        self::assertSame($config['Zend\Session\SessionManager'], SessionManager::class);
+        self::assertSame($config['Zend\Session\Config\ConfigInterface'], ConfigInterface::class);
+        self::assertSame($config['Zend\Session\ManagerInterface'], ManagerInterface::class);
+        self::assertSame($config['Zend\Session\Storage\StorageInterface'], StorageInterface::class);
+    }
+}
diff --git a/test/ContainerTest.php b/test/ContainerTest.php
index 78fab222..2b8097e1 100644
--- a/test/ContainerTest.php
+++ b/test/ContainerTest.php
@@ -8,13 +8,16 @@
 
 namespace LaminasTest\Session;
 
+use ArrayObject;
 use Laminas\Session\Config\StandardConfig;
 use Laminas\Session\Container;
+use Laminas\Session\Exception\InvalidArgumentException;
 use Laminas\Session\ManagerInterface as Manager;
 use PHPUnit\Framework\TestCase;
 
 /**
  * @covers \Laminas\Session\Container
+ * @covers \Laminas\Session\AbstractContainer
  */
 class ContainerTest extends TestCase
 {
@@ -35,62 +38,60 @@ class ContainerTest extends TestCase
      */
     protected $container;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $_SESSION = [];
         Container::setDefaultManager(null);
 
-        $config = new StandardConfig([
-            'storage' => 'Laminas\\Session\\Storage\\ArrayStorage',
-        ]);
+        $config = new StandardConfig();
 
-        $this->manager = $manager = new TestAsset\TestManager($config);
+        $this->manager   = $manager = new TestAsset\TestManager($config);
         $this->container = new Container('Default', $manager);
     }
 
-    protected function tearDown()
+    protected function tearDown(): void
     {
         $_SESSION = [];
         Container::setDefaultManager(null);
     }
 
-    public function testInstantiationStartsSession()
+    public function testInstantiationStartsSession(): void
     {
         $this->manager->destroy();
         $container = new Container('Default', $this->manager);
-        $this->assertTrue($this->manager->started);
+        self::assertTrue($this->manager->started);
     }
 
-    public function testInstantiatingContainerWithoutNameUsesDefaultAsName()
+    public function testInstantiatingContainerWithoutNameUsesDefaultAsName(): void
     {
-        $this->assertEquals('Default', $this->container->getName());
+        self::assertEquals('Default', $this->container->getName());
     }
 
-    public function testPassingNameToConstructorInstantiatesContainerWithThatName()
+    public function testPassingNameToConstructorInstantiatesContainerWithThatName(): void
     {
         $container = new Container('foo', $this->manager);
-        $this->assertEquals('foo', $container->getName());
+        self::assertEquals('foo', $container->getName());
     }
 
-    public function testPassingNameStartingWithDigitToConstructorInstantiatesContainerWithThatName()
+    public function testPassingNameStartingWithDigitToConstructorInstantiatesContainerWithThatName(): void
     {
         $container = new Container('0foo', $this->manager);
-        $this->assertEquals('0foo', $container->getName());
+        self::assertEquals('0foo', $container->getName());
     }
 
-    public function testUsingOldLaminas1NameIsStillValid()
+    public function testUsingOldLaminas1NameIsStillValid(): void
     {
         $container = new Container('Laminas_Foo', $this->manager);
-        $this->assertEquals('Laminas_Foo', $container->getName());
+        self::assertEquals('Laminas_Foo', $container->getName());
     }
 
-    public function testUsingNewLaminasNamespaceIsValid()
+    public function testUsingNewLaminasNamespaceIsValid(): void
     {
         $container = new Container('Laminas\Foo', $this->manager);
-        $this->assertEquals('Laminas\Foo', $container->getName());
+        self::assertEquals('Laminas\Foo', $container->getName());
     }
 
-    public function testPassingInvalidNameToConstructorRaisesException()
+    public function testPassingInvalidNameToConstructorRaisesException(): void
     {
         $tries = [
             'f!',
@@ -98,120 +99,118 @@ public function testPassingInvalidNameToConstructorRaisesException()
             '_foo',
             '__foo',
             '\foo',
-            '\\foo'
+            '\\foo',
         ];
         foreach ($tries as $try) {
             try {
                 $container = new Container($try);
-                $this->fail('Invalid container name should raise exception');
-            } catch (\Laminas\Session\Exception\InvalidArgumentException $e) {
-                $this->assertContains('invalid', $e->getMessage());
+                self::fail('Invalid container name should raise exception');
+            } catch (InvalidArgumentException $e) {
+                self::assertStringContainsString('invalid', $e->getMessage());
             }
         }
     }
 
-    public function testContainerActsAsArray()
+    public function testContainerActsAsArray(): void
     {
         $this->container['foo'] = 'bar';
-        $this->assertTrue(isset($this->container['foo']));
-        $this->assertEquals('bar', $this->container['foo']);
+        self::assertTrue(isset($this->container['foo']));
+        self::assertEquals('bar', $this->container['foo']);
         unset($this->container['foo']);
-        $this->assertFalse(isset($this->container['foo']));
+        self::assertFalse(isset($this->container['foo']));
     }
 
-    public function testContainerActsAsObject()
+    public function testContainerActsAsObject(): void
     {
         $this->container->foo = 'bar';
-        $this->assertTrue(isset($this->container->foo));
-        $this->assertEquals('bar', $this->container->foo);
+        self::assertTrue(isset($this->container->foo));
+        self::assertEquals('bar', $this->container->foo);
         unset($this->container->foo);
-        $this->assertFalse(isset($this->container->foo));
+        self::assertFalse(isset($this->container->foo));
     }
 
-    public function testDefaultManagerIsAlwaysPopulated()
+    public function testDefaultManagerIsAlwaysPopulated(): void
     {
         $manager = Container::getDefaultManager();
-        $this->assertInstanceOf('Laminas\Session\ManagerInterface', $manager);
+        self::assertInstanceOf('Laminas\Session\ManagerInterface', $manager);
     }
 
-    public function testCanSetDefaultManager()
+    public function testCanSetDefaultManager(): void
     {
-        $manager = new TestAsset\TestManager;
+        $manager = new TestAsset\TestManager();
         Container::setDefaultManager($manager);
-        $this->assertSame($manager, Container::getDefaultManager());
+        self::assertSame($manager, Container::getDefaultManager());
     }
 
-    public function testCanSetDefaultManagerToNull()
+    public function testCanSetDefaultManagerToNull(): void
     {
-        $manager = new TestAsset\TestManager;
+        $manager = new TestAsset\TestManager();
         Container::setDefaultManager($manager);
         Container::setDefaultManager(null);
-        $this->assertNotSame($manager, Container::getDefaultManager());
+        self::assertNotSame($manager, Container::getDefaultManager());
     }
 
-    public function testDefaultManagerUsedWhenNoManagerProvided()
+    public function testDefaultManagerUsedWhenNoManagerProvided(): void
     {
-        $manager = Container::getDefaultManager();
+        $manager   = Container::getDefaultManager();
         $container = new Container();
-        $this->assertSame($manager, $container->getManager());
+        self::assertSame($manager, $container->getManager());
     }
 
-    public function testContainerInstantiatesManagerWithDefaultsWhenNotInjected()
+    public function testContainerInstantiatesManagerWithDefaultsWhenNotInjected(): void
     {
         $container = new Container();
         $manager   = $container->getManager();
-        $this->assertInstanceOf('Laminas\Session\ManagerInterface', $manager);
-        $config  = $manager->getConfig();
-        $this->assertInstanceOf('Laminas\Session\Config\SessionConfig', $config);
+        self::assertInstanceOf('Laminas\Session\ManagerInterface', $manager);
+        $config = $manager->getConfig();
+        self::assertInstanceOf('Laminas\Session\Config\SessionConfig', $config);
         $storage = $manager->getStorage();
-        $this->assertInstanceOf('Laminas\Session\Storage\SessionArrayStorage', $storage);
+        self::assertInstanceOf('Laminas\Session\Storage\SessionArrayStorage', $storage);
     }
 
-    public function testContainerAllowsInjectingManagerViaConstructor()
+    public function testContainerAllowsInjectingManagerViaConstructor(): void
     {
-        $config = new StandardConfig([
-            'storage' => 'Laminas\\Session\\Storage\\ArrayStorage',
-        ]);
-        $manager = new TestAsset\TestManager($config);
+        $config    = new StandardConfig();
+        $manager   = new TestAsset\TestManager($config);
         $container = new Container('Foo', $manager);
-        $this->assertSame($manager, $container->getManager());
+        self::assertSame($manager, $container->getManager());
     }
 
-    public function testContainerWritesToStorage()
+    public function testContainerWritesToStorage(): void
     {
         $this->container->foo = 'bar';
-        $storage = $this->manager->getStorage();
-        $this->assertTrue(isset($storage['Default']));
-        $this->assertTrue(isset($storage['Default']['foo']));
-        $this->assertEquals('bar', $storage['Default']['foo']);
+        $storage              = $this->manager->getStorage();
+        self::assertTrue(isset($storage['Default']));
+        self::assertTrue(isset($storage['Default']['foo']));
+        self::assertEquals('bar', $storage['Default']['foo']);
 
         unset($this->container->foo);
-        $this->assertFalse(isset($storage['Default']['foo']));
+        self::assertFalse(isset($storage['Default']['foo']));
     }
 
-    public function testSettingExpirationSecondsUpdatesStorageMetadataForFullContainer()
+    public function testSettingExpirationSecondsUpdatesStorageMetadataForFullContainer(): void
     {
         $currentTimestamp = time();
         $this->container->setExpirationSeconds(3600);
-        $storage = $this->manager->getStorage();
+        $storage  = $this->manager->getStorage();
         $metadata = $storage->getMetadata($this->container->getName());
-        $this->assertArrayHasKey('EXPIRE', $metadata);
-        $this->assertEquals($currentTimestamp + 3600, $metadata['EXPIRE']);
+        self::assertArrayHasKey('EXPIRE', $metadata);
+        self::assertEquals($currentTimestamp + 3600, $metadata['EXPIRE']);
     }
 
-    public function testSettingExpirationSecondsForIndividualKeyUpdatesStorageMetadataForThatKey()
+    public function testSettingExpirationSecondsForIndividualKeyUpdatesStorageMetadataForThatKey(): void
     {
         $this->container->foo = 'bar';
-        $currentTimestamp = time();
+        $currentTimestamp     = time();
         $this->container->setExpirationSeconds(3600, 'foo');
-        $storage = $this->manager->getStorage();
+        $storage  = $this->manager->getStorage();
         $metadata = $storage->getMetadata($this->container->getName());
-        $this->assertArrayHasKey('EXPIRE_KEYS', $metadata);
-        $this->assertArrayHasKey('foo', $metadata['EXPIRE_KEYS']);
-        $this->assertEquals($currentTimestamp + 3600, $metadata['EXPIRE_KEYS']['foo']);
+        self::assertArrayHasKey('EXPIRE_KEYS', $metadata);
+        self::assertArrayHasKey('foo', $metadata['EXPIRE_KEYS']);
+        self::assertEquals($currentTimestamp + 3600, $metadata['EXPIRE_KEYS']['foo']);
     }
 
-    public function testMultipleCallsToExpirationSecondsAggregates()
+    public function testMultipleCallsToExpirationSecondsAggregates(): void
     {
         $this->container->foo = 'bar';
         $this->container->bar = 'baz';
@@ -221,15 +220,15 @@ public function testMultipleCallsToExpirationSecondsAggregates()
         $this->container->setExpirationSeconds(3600);
         $this->container->setExpirationSeconds(1800, 'foo');
         $this->container->setExpirationSeconds(900, ['baz', 'bat']);
-        $storage = $this->manager->getStorage();
+        $storage  = $this->manager->getStorage();
         $metadata = $storage->getMetadata($this->container->getName());
-        $this->assertEquals($currentTimestamp + 1800, $metadata['EXPIRE_KEYS']['foo']);
-        $this->assertEquals($currentTimestamp + 900, $metadata['EXPIRE_KEYS']['baz']);
-        $this->assertEquals($currentTimestamp + 900, $metadata['EXPIRE_KEYS']['bat']);
-        $this->assertEquals($currentTimestamp + 3600, $metadata['EXPIRE']);
+        self::assertEquals($currentTimestamp + 1800, $metadata['EXPIRE_KEYS']['foo']);
+        self::assertEquals($currentTimestamp + 900, $metadata['EXPIRE_KEYS']['baz']);
+        self::assertEquals($currentTimestamp + 900, $metadata['EXPIRE_KEYS']['bat']);
+        self::assertEquals($currentTimestamp + 3600, $metadata['EXPIRE']);
     }
 
-    public function testSettingExpirationSecondsUsesCurrentTime()
+    public function testSettingExpirationSecondsUsesCurrentTime(): void
     {
         sleep(3);
         $this->container->setExpirationSeconds(2);
@@ -239,117 +238,117 @@ public function testSettingExpirationSecondsUsesCurrentTime()
         $_SERVER['REQUEST_TIME']       = time();
         $_SERVER['REQUEST_TIME_FLOAT'] = microtime(true);
 
-        $this->assertEquals('bar', $this->container->foo);
+        self::assertEquals('bar', $this->container->foo);
     }
 
-    public function testPassingUnsetKeyToSetExpirationSecondsDoesNothing()
+    public function testPassingUnsetKeyToSetExpirationSecondsDoesNothing(): void
     {
         $this->container->setExpirationSeconds(3600, 'foo');
-        $storage = $this->manager->getStorage();
+        $storage  = $this->manager->getStorage();
         $metadata = $storage->getMetadata($this->container->getName());
-        $this->assertFalse(isset($metadata['EXPIRE_KEYS']['foo']));
+        self::assertFalse(isset($metadata['EXPIRE_KEYS']['foo']));
     }
 
-    public function testPassingUnsetKeyInArrayToSetExpirationSecondsDoesNothing()
+    public function testPassingUnsetKeyInArrayToSetExpirationSecondsDoesNothing(): void
     {
         $this->container->setExpirationSeconds(3600, ['foo']);
-        $storage = $this->manager->getStorage();
+        $storage  = $this->manager->getStorage();
         $metadata = $storage->getMetadata($this->container->getName());
-        $this->assertFalse(isset($metadata['EXPIRE_KEYS']['foo']));
+        self::assertFalse(isset($metadata['EXPIRE_KEYS']['foo']));
     }
 
-    public function testGetKeyWithContainerExpirationInPastResetsToNull()
+    public function testGetKeyWithContainerExpirationInPastResetsToNull(): void
     {
         $this->container->foo = 'bar';
-        $storage = $this->manager->getStorage();
+        $storage              = $this->manager->getStorage();
         $storage->setMetadata('Default', ['EXPIRE' => $_SERVER['REQUEST_TIME'] - 18600]);
-        $this->assertNull($this->container->foo);
+        self::assertNull($this->container->foo);
     }
 
-    public function testGetKeyWithExpirationInPastResetsToNull()
+    public function testGetKeyWithExpirationInPastResetsToNull(): void
     {
         $this->container->foo = 'bar';
         $this->container->bar = 'baz';
-        $storage = $this->manager->getStorage();
+        $storage              = $this->manager->getStorage();
         $storage->setMetadata('Default', ['EXPIRE_KEYS' => ['foo' => $_SERVER['REQUEST_TIME'] - 18600]]);
-        $this->assertNull($this->container->foo);
-        $this->assertEquals('baz', $this->container->bar);
+        self::assertNull($this->container->foo);
+        self::assertEquals('baz', $this->container->bar);
     }
 
-    public function testKeyExistsWithContainerExpirationInPastReturnsFalse()
+    public function testKeyExistsWithContainerExpirationInPastReturnsFalse(): void
     {
         $this->container->foo = 'bar';
-        $storage = $this->manager->getStorage();
+        $storage              = $this->manager->getStorage();
         $storage->setMetadata('Default', ['EXPIRE' => $_SERVER['REQUEST_TIME'] - 18600]);
-        $this->assertFalse(isset($this->container->foo));
+        self::assertFalse(isset($this->container->foo));
     }
 
-    public function testKeyExistsWithExpirationInPastReturnsFalse()
+    public function testKeyExistsWithExpirationInPastReturnsFalse(): void
     {
         $this->container->foo = 'bar';
         $this->container->bar = 'baz';
-        $storage = $this->manager->getStorage();
+        $storage              = $this->manager->getStorage();
         $storage->setMetadata('Default', ['EXPIRE_KEYS' => ['foo' => $_SERVER['REQUEST_TIME'] - 18600]]);
-        $this->assertFalse(isset($this->container->foo));
-        $this->assertTrue(isset($this->container->bar));
+        self::assertFalse(isset($this->container->foo));
+        self::assertTrue(isset($this->container->bar));
     }
 
-    public function testKeyExistsWithContainerExpirationInPastWithSetExpirationSecondsReturnsFalse()
+    public function testKeyExistsWithContainerExpirationInPastWithSetExpirationSecondsReturnsFalse(): void
     {
         $this->container->foo = 'bar';
-        $storage = $this->manager->getStorage();
+        $storage              = $this->manager->getStorage();
         $storage->setMetadata('Default', ['EXPIRE' => $_SERVER['REQUEST_TIME'] - 18600]);
         $this->container->setExpirationSeconds(1);
-        $this->assertFalse(isset($this->container->foo));
+        self::assertFalse(isset($this->container->foo));
     }
 
-    public function testSettingExpiredKeyOverwritesExpiryMetadataForThatKey()
+    public function testSettingExpiredKeyOverwritesExpiryMetadataForThatKey(): void
     {
         $this->container->foo = 'bar';
-        $storage = $this->manager->getStorage();
+        $storage              = $this->manager->getStorage();
         $storage->setMetadata('Default', ['EXPIRE' => $_SERVER['REQUEST_TIME'] - 18600]);
         $this->container->foo = 'baz';
-        $this->assertTrue(isset($this->container->foo));
-        $this->assertEquals('baz', $this->container->foo);
+        self::assertTrue(isset($this->container->foo));
+        self::assertEquals('baz', $this->container->foo);
         $metadata = $storage->getMetadata('Default');
-        $this->assertFalse(isset($metadata['EXPIRE_KEYS']['foo']));
+        self::assertFalse(isset($metadata['EXPIRE_KEYS']['foo']));
     }
 
-    public function testSettingExpirationHopsWithNoVariablesMarksContainerByWritingToStorage()
+    public function testSettingExpirationHopsWithNoVariablesMarksContainerByWritingToStorage(): void
     {
         $this->container->setExpirationHops(2);
-        $storage = $this->manager->getStorage();
+        $storage  = $this->manager->getStorage();
         $metadata = $storage->getMetadata('Default');
-        $this->assertArrayHasKey('EXPIRE_HOPS', $metadata);
-        $this->assertEquals(
+        self::assertArrayHasKey('EXPIRE_HOPS', $metadata);
+        self::assertEquals(
             ['hops' => 2, 'ts' => $storage->getRequestAccessTime()],
             $metadata['EXPIRE_HOPS']
         );
     }
 
-    public function testSettingExpirationHopsWithSingleKeyMarksContainerByWritingToStorage()
+    public function testSettingExpirationHopsWithSingleKeyMarksContainerByWritingToStorage(): void
     {
         $this->container->foo = 'bar';
         $this->container->setExpirationHops(2, 'foo');
-        $storage = $this->manager->getStorage();
+        $storage  = $this->manager->getStorage();
         $metadata = $storage->getMetadata('Default');
-        $this->assertArrayHasKey('EXPIRE_HOPS_KEYS', $metadata);
-        $this->assertArrayHasKey('foo', $metadata['EXPIRE_HOPS_KEYS']);
-        $this->assertEquals(
+        self::assertArrayHasKey('EXPIRE_HOPS_KEYS', $metadata);
+        self::assertArrayHasKey('foo', $metadata['EXPIRE_HOPS_KEYS']);
+        self::assertEquals(
             ['hops' => 2, 'ts' => $storage->getRequestAccessTime()],
             $metadata['EXPIRE_HOPS_KEYS']['foo']
         );
     }
 
-    public function testSettingExpirationHopsWithMultipleKeysMarksContainerByWritingToStorage()
+    public function testSettingExpirationHopsWithMultipleKeysMarksContainerByWritingToStorage(): void
     {
         $this->container->foo = 'bar';
         $this->container->bar = 'baz';
         $this->container->baz = 'bat';
         $this->container->setExpirationHops(2, ['foo', 'baz']);
-        $storage = $this->manager->getStorage();
+        $storage  = $this->manager->getStorage();
         $metadata = $storage->getMetadata('Default');
-        $this->assertArrayHasKey('EXPIRE_HOPS_KEYS', $metadata);
+        self::assertArrayHasKey('EXPIRE_HOPS_KEYS', $metadata);
 
         $hops     = $metadata['EXPIRE_HOPS_KEYS'];
         $ts       = $storage->getRequestAccessTime();
@@ -363,66 +362,66 @@ public function testSettingExpirationHopsWithMultipleKeysMarksContainerByWriting
                 'ts'   => $ts,
             ],
         ];
-        $this->assertEquals($expected, $hops);
+        self::assertEquals($expected, $hops);
     }
 
-    public function testContainerExpiresAfterSpecifiedHops()
+    public function testContainerExpiresAfterSpecifiedHops(): void
     {
         $this->container->foo = 'bar';
         $this->container->setExpirationHops(1);
 
         $storage = $this->manager->getStorage();
-        $ts = $storage->getRequestAccessTime();
+        $ts      = $storage->getRequestAccessTime();
 
         $storage->setMetadata('_REQUEST_ACCESS_TIME', $ts + 60);
-        $this->assertEquals('bar', $this->container->foo);
+        self::assertEquals('bar', $this->container->foo);
 
         $storage->setMetadata('_REQUEST_ACCESS_TIME', $ts + 120);
-        $this->assertNull($this->container->foo);
+        self::assertNull($this->container->foo);
     }
 
-    public function testInstantiatingMultipleContainersInSameRequestDoesNotCreateExtraHops()
+    public function testInstantiatingMultipleContainersInSameRequestDoesNotCreateExtraHops(): void
     {
         $this->container->foo = 'bar';
         $this->container->setExpirationHops(1);
 
         $container = new Container('Default', $this->manager);
-        $this->assertEquals('bar', $container->foo);
-        $this->assertEquals('bar', $this->container->foo);
+        self::assertEquals('bar', $container->foo);
+        self::assertEquals('bar', $this->container->foo);
     }
 
-    public function testKeyExpiresAfterSpecifiedHops()
+    public function testKeyExpiresAfterSpecifiedHops(): void
     {
         $this->container->foo = 'bar';
         $this->container->bar = 'baz';
         $this->container->setExpirationHops(1, 'foo');
 
         $storage = $this->manager->getStorage();
-        $ts = $storage->getRequestAccessTime();
+        $ts      = $storage->getRequestAccessTime();
 
         $storage->setMetadata('_REQUEST_ACCESS_TIME', $ts + 60);
-        $this->assertEquals('bar', $this->container->foo);
-        $this->assertEquals('baz', $this->container->bar);
+        self::assertEquals('bar', $this->container->foo);
+        self::assertEquals('baz', $this->container->bar);
 
         $storage->setMetadata('_REQUEST_ACCESS_TIME', $ts + 120);
-        $this->assertNull($this->container->foo);
-        $this->assertEquals('baz', $this->container->bar);
+        self::assertNull($this->container->foo);
+        self::assertEquals('baz', $this->container->bar);
     }
 
-    public function testInstantiatingMultipleContainersInSameRequestDoesNotCreateExtraKeyHops()
+    public function testInstantiatingMultipleContainersInSameRequestDoesNotCreateExtraKeyHops(): void
     {
         $this->container->foo = 'bar';
         $this->container->bar = 'baz';
         $this->container->setExpirationHops(1, 'foo');
 
         $container = new Container('Default', $this->manager);
-        $this->assertEquals('bar', $container->foo);
-        $this->assertEquals('bar', $this->container->foo);
-        $this->assertEquals('baz', $container->bar);
-        $this->assertEquals('baz', $this->container->bar);
+        self::assertEquals('bar', $container->foo);
+        self::assertEquals('bar', $this->container->foo);
+        self::assertEquals('baz', $container->bar);
+        self::assertEquals('baz', $this->container->bar);
     }
 
-    public function testKeysExpireAfterSpecifiedHops()
+    public function testKeysExpireAfterSpecifiedHops(): void
     {
         $this->container->foo = 'bar';
         $this->container->bar = 'baz';
@@ -430,37 +429,37 @@ public function testKeysExpireAfterSpecifiedHops()
         $this->container->setExpirationHops(1, ['foo', 'baz']);
 
         $storage = $this->manager->getStorage();
-        $ts = $storage->getRequestAccessTime();
+        $ts      = $storage->getRequestAccessTime();
 
         $storage->setMetadata('_REQUEST_ACCESS_TIME', $ts + 60);
-        $this->assertEquals('bar', $this->container->foo);
-        $this->assertEquals('baz', $this->container->bar);
-        $this->assertEquals('bat', $this->container->baz);
+        self::assertEquals('bar', $this->container->foo);
+        self::assertEquals('baz', $this->container->bar);
+        self::assertEquals('bat', $this->container->baz);
 
         $storage->setMetadata('_REQUEST_ACCESS_TIME', $ts + 120);
-        $this->assertNull($this->container->foo);
-        $this->assertEquals('baz', $this->container->bar);
-        $this->assertNull($this->container->baz);
+        self::assertNull($this->container->foo);
+        self::assertEquals('baz', $this->container->bar);
+        self::assertNull($this->container->baz);
     }
 
-    public function testCanIterateOverContainer()
+    public function testCanIterateOverContainer(): void
     {
         $this->container->foo = 'bar';
         $this->container->bar = 'baz';
         $this->container->baz = 'bat';
-        $expected = [
+        $expected             = [
             'foo' => 'bar',
             'bar' => 'baz',
             'baz' => 'bat',
         ];
-        $test = [];
+        $test                 = [];
         foreach ($this->container as $key => $value) {
             $test[$key] = $value;
         }
-        $this->assertSame($expected, $test);
+        self::assertSame($expected, $test);
     }
 
-    public function testIterationHonorsExpirationHops()
+    public function testIterationHonorsExpirationHops(): void
     {
         $this->container->foo = 'bar';
         $this->container->bar = 'baz';
@@ -468,7 +467,7 @@ public function testIterationHonorsExpirationHops()
         $this->container->setExpirationHops(1, ['foo', 'baz']);
 
         $storage = $this->manager->getStorage();
-        $ts = $storage->getRequestAccessTime();
+        $ts      = $storage->getRequestAccessTime();
 
         // First hop
         $storage->setMetadata('_REQUEST_ACCESS_TIME', $ts + 60);
@@ -477,90 +476,90 @@ public function testIterationHonorsExpirationHops()
             'bar' => 'baz',
             'baz' => 'bat',
         ];
-        $test = [];
+        $test     = [];
         foreach ($this->container as $key => $value) {
             $test[$key] = $value;
         }
-        $this->assertSame($expected, $test);
+        self::assertSame($expected, $test);
 
         // Second hop
         $storage->setMetadata('_REQUEST_ACCESS_TIME', $ts + 120);
         $expected = ['bar' => 'baz'];
-        $test = [];
+        $test     = [];
         foreach ($this->container as $key => $value) {
             $test[$key] = $value;
         }
-        $this->assertSame($expected, $test);
+        self::assertSame($expected, $test);
     }
 
-    public function testIterationHonorsExpirationTimestamps()
+    public function testIterationHonorsExpirationTimestamps(): void
     {
         $this->container->foo = 'bar';
         $this->container->bar = 'baz';
-        $storage = $this->manager->getStorage();
+        $storage              = $this->manager->getStorage();
         $storage->setMetadata('Default', ['EXPIRE_KEYS' => ['foo' => $_SERVER['REQUEST_TIME'] - 18600]]);
         $expected = ['bar' => 'baz'];
         $test     = [];
         foreach ($this->container as $key => $value) {
             $test[$key] = $value;
         }
-        $this->assertSame($expected, $test);
+        self::assertSame($expected, $test);
     }
 
-    public function testValidationShouldNotRaiseErrorForMissingResponseObject()
+    public function testValidationShouldNotRaiseErrorForMissingResponseObject(): void
     {
-        $session = new Container('test');
+        $session       = new Container('test');
         $session->test = 42;
-        $this->assertEquals(42, $session->test);
+        self::assertEquals(42, $session->test);
     }
 
-    public function testExchangeArray()
+    public function testExchangeArray(): void
     {
         $this->container->offsetSet('old', 'old');
-        $this->assertTrue($this->container->offsetExists('old'));
+        self::assertTrue($this->container->offsetExists('old'));
 
         $old = $this->container->exchangeArray(['new' => 'new']);
-        $this->assertArrayHasKey('old', $old, "'exchangeArray' doesn't return an array of old items");
-        $this->assertFalse($this->container->offsetExists('old'), "'exchangeArray' doesn't remove old items");
-        $this->assertTrue($this->container->offsetExists('new'), "'exchangeArray' doesn't add the new array items");
+        self::assertArrayHasKey('old', $old, "'exchangeArray' doesn't return an array of old items");
+        self::assertFalse($this->container->offsetExists('old'), "'exchangeArray' doesn't remove old items");
+        self::assertTrue($this->container->offsetExists('new'), "'exchangeArray' doesn't add the new array items");
     }
 
-    public function testExchangeArrayObject()
+    public function testExchangeArrayObject(): void
     {
         $this->container->offsetSet('old', 'old');
-        $this->assertTrue($this->container->offsetExists('old'));
+        self::assertTrue($this->container->offsetExists('old'));
 
         $old = $this->container->exchangeArray(new \Laminas\Stdlib\ArrayObject(['new' => 'new']));
-        $this->assertArrayHasKey('old', $old, "'exchangeArray' doesn't return an array of old items");
-        $this->assertFalse($this->container->offsetExists('old'), "'exchangeArray' doesn't remove old items");
-        $this->assertTrue($this->container->offsetExists('new'), "'exchangeArray' doesn't add the new array items");
+        self::assertArrayHasKey('old', $old, "'exchangeArray' doesn't return an array of old items");
+        self::assertFalse($this->container->offsetExists('old'), "'exchangeArray' doesn't remove old items");
+        self::assertTrue($this->container->offsetExists('new'), "'exchangeArray' doesn't add the new array items");
     }
 
-    public function testMultiDimensionalUnset()
+    public function testMultiDimensionalUnset(): void
     {
         $this->container->foo = ['bar' => 'baz'];
         unset($this->container['foo']['bar']);
-        $this->assertSame([], $this->container->foo);
+        self::assertSame([], $this->container->foo);
     }
 
-    public function testUpgradeBehaviors()
+    public function testUpgradeBehaviors(): void
     {
-        $storage = $this->manager->getStorage();
-        $storage['foo'] = new \ArrayObject(['bar' => 'baz']);
+        $storage        = $this->manager->getStorage();
+        $storage['foo'] = new ArrayObject(['bar' => 'baz']);
 
         $container = new Container('foo', $this->manager);
-        $this->assertEquals('baz', $container->bar);
+        self::assertEquals('baz', $container->bar);
         $container->baz = 'boo';
-        $this->assertEquals('boo', $storage['foo']['baz']);
+        self::assertEquals('boo', $storage['foo']['baz']);
     }
 
-    public function testGetArrayCopyAfterExchangeArray()
+    public function testGetArrayCopyAfterExchangeArray(): void
     {
         $this->container->exchangeArray(['foo' => 'bar']);
 
         $contents = $this->container->getArrayCopy();
 
-        $this->assertInternalType('array', $contents);
-        $this->assertArrayHasKey('foo', $contents, "'getArrayCopy' doesn't return exchanged array");
+        self::assertIsArray($contents);
+        self::assertArrayHasKey('foo', $contents, "'getArrayCopy' doesn't return exchanged array");
     }
 }
diff --git a/test/ModuleTest.php b/test/ModuleTest.php
new file mode 100644
index 00000000..f4a5d978
--- /dev/null
+++ b/test/ModuleTest.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaminasTest\Session;
+
+use Laminas\Session\Module;
+use PHPUnit\Framework\TestCase;
+
+class ModuleTest extends TestCase
+{
+    public function testConfigProvidesServiceManagerConfiguration(): void
+    {
+        $config = (new Module())->getConfig();
+
+        self::assertArrayHasKey('service_manager', $config);
+    }
+}
diff --git a/test/ReflectionPropertyTrait.php b/test/ReflectionPropertyTrait.php
new file mode 100644
index 00000000..5621e801
--- /dev/null
+++ b/test/ReflectionPropertyTrait.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaminasTest\Session;
+
+use ReflectionObject;
+
+trait ReflectionPropertyTrait
+{
+    /**
+     * @return mixed
+     */
+    private function getReflectionProperty(object $object, string $property)
+    {
+        $reflectionObject   = new ReflectionObject($object);
+        $reflectionProperty = $reflectionObject->getProperty($property);
+        $reflectionProperty->setAccessible(true);
+        return $reflectionProperty->getValue($object);
+    }
+}
diff --git a/test/SaveHandler/CacheTest.php b/test/SaveHandler/CacheTest.php
index 7b4b30dc..6ebfe640 100644
--- a/test/SaveHandler/CacheTest.php
+++ b/test/SaveHandler/CacheTest.php
@@ -11,6 +11,7 @@
 use Laminas\Session\SaveHandler\Cache;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
+use Prophecy\PhpUnit\ProphecyTrait;
 
 /**
  * Unit testing for DbTable include all tests for
@@ -20,6 +21,8 @@
  */
 class CacheTest extends TestCase
 {
+    use ProphecyTrait;
+
     /**
      * @var CacheAdapter
      */
@@ -38,74 +41,80 @@ class CacheTest extends TestCase
      */
     protected $usedSaveHandlers = [];
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->testArray = ['foo' => 'bar', 'bar' => ['foo' => 'bar']];
     }
 
-    public function testReadWrite()
+    public function testReadWrite(): void
     {
         $cacheStorage = $this->prophesize('Laminas\Cache\Storage\StorageInterface');
         $cacheStorage->setItem('242', Argument::type('string'))
-            ->will(function ($args) {
-                $this->getItem('242')->willReturn($args[1]);
-                return true;
-            });
+            ->will(
+                function ($args) {
+                    $this->getItem('242')->willReturn($args[1]);
+                    return true;
+                }
+            );
         $this->usedSaveHandlers[] = $saveHandler = new Cache($cacheStorage->reveal());
 
         $id = '242';
 
-        $this->assertTrue($saveHandler->write($id, serialize($this->testArray)));
+        self::assertTrue($saveHandler->write($id, serialize($this->testArray)));
 
         $data = unserialize($saveHandler->read($id));
-        $this->assertEquals(
+        self::assertEquals(
             $this->testArray,
             $data,
             'Expected ' . var_export($this->testArray, 1) . "\nbut got: " . var_export($data, 1)
         );
     }
 
-    public function testReadWriteComplex()
+    public function testReadWriteComplex(): void
     {
         $cacheStorage = $this->prophesize('Laminas\Cache\Storage\StorageInterface');
         $cacheStorage->setItem('242', Argument::type('string'))
-            ->will(function ($args) {
-                $this->getItem('242')->willReturn($args[1]);
-                return true;
-            });
+            ->will(
+                function ($args) {
+                    $this->getItem('242')->willReturn($args[1]);
+                    return true;
+                }
+            );
         $this->usedSaveHandlers[] = $saveHandler = new Cache($cacheStorage->reveal());
         $saveHandler->open('savepath', 'sessionname');
 
         $id = '242';
 
-        $this->assertTrue($saveHandler->write($id, serialize($this->testArray)));
+        self::assertTrue($saveHandler->write($id, serialize($this->testArray)));
 
-        $this->assertEquals($this->testArray, unserialize($saveHandler->read($id)));
+        self::assertEquals($this->testArray, unserialize($saveHandler->read($id)));
     }
 
-    public function testReadWriteTwice()
+    public function testReadWriteTwice(): void
     {
         $cacheStorage = $this->prophesize('Laminas\Cache\Storage\StorageInterface');
         $cacheStorage->setItem('242', Argument::type('string'))
-            ->will(function ($args) {
-                $this->getItem('242')->willReturn($args[1])->shouldBeCalledTimes(2);
-                return true;
-            })
+            ->will(
+                function ($args) {
+                    $this->getItem('242')->willReturn($args[1])->shouldBeCalledTimes(2);
+                    return true;
+                }
+            )
             ->shouldBeCalledTimes(2);
         $this->usedSaveHandlers[] = $saveHandler = new Cache($cacheStorage->reveal());
 
         $id = '242';
 
-        $this->assertTrue($saveHandler->write($id, serialize($this->testArray)));
+        self::assertTrue($saveHandler->write($id, serialize($this->testArray)));
 
-        $this->assertEquals($this->testArray, unserialize($saveHandler->read($id)));
+        self::assertEquals($this->testArray, unserialize($saveHandler->read($id)));
 
-        $this->assertTrue($saveHandler->write($id, serialize($this->testArray)));
+        self::assertTrue($saveHandler->write($id, serialize($this->testArray)));
 
-        $this->assertEquals($this->testArray, unserialize($saveHandler->read($id)));
+        self::assertEquals($this->testArray, unserialize($saveHandler->read($id)));
     }
 
-    public function testReadShouldAlwaysReturnString()
+    public function testReadShouldAlwaysReturnString(): void
     {
         $cacheStorage = $this->prophesize('Laminas\Cache\Storage\StorageInterface');
         $cacheStorage->getItem('242')->willReturn(null);
@@ -115,41 +124,45 @@ public function testReadShouldAlwaysReturnString()
 
         $data = $saveHandler->read($id);
 
-        $this->assertTrue(is_string($data));
+        self::assertTrue(is_string($data));
     }
 
-    public function testDestroyReturnsTrueEvenWhenSessionDoesNotExist()
+    public function testDestroyReturnsTrueEvenWhenSessionDoesNotExist(): void
     {
-        $cacheStorage = $this->prophesize('Laminas\Cache\Storage\StorageInterface');
+        $cacheStorage             = $this->prophesize('Laminas\Cache\Storage\StorageInterface');
         $this->usedSaveHandlers[] = $saveHandler = new Cache($cacheStorage->reveal());
 
         $id = '242';
 
         $result = $saveHandler->destroy($id);
 
-        $this->assertTrue($result);
+        self::assertTrue($result);
     }
 
-    public function testDestroyReturnsTrueWhenSessionIsDeleted()
+    public function testDestroyReturnsTrueWhenSessionIsDeleted(): void
     {
         $cacheStorage = $this->prophesize('Laminas\Cache\Storage\StorageInterface');
         $cacheStorage->setItem('242', Argument::type('string'))
-            ->will(function ($args) {
-                $this->getItem('242', Argument::any())
-                    ->will(function ($args) {
-                        $return =& $args[1];
-                        return $return;
-                    });
-                return true;
-            });
+            ->will(
+                function ($args) {
+                    $this->getItem('242', Argument::any())
+                        ->will(
+                            function ($args) {
+                                $return =& $args[1];
+                                return $return;
+                            }
+                        );
+                    return true;
+                }
+            );
         $this->usedSaveHandlers[] = $saveHandler = new Cache($cacheStorage->reveal());
 
         $id = '242';
 
-        $this->assertTrue($saveHandler->write($id, serialize($this->testArray)));
+        self::assertTrue($saveHandler->write($id, serialize($this->testArray)));
 
         $result = $saveHandler->destroy($id);
 
-        $this->assertTrue($result);
+        self::assertTrue($result);
     }
 }
diff --git a/test/SaveHandler/DbTableGateway/MysqliAdapterTest.php b/test/SaveHandler/DbTableGateway/MysqliAdapterTest.php
index 45d6868a..f042693f 100644
--- a/test/SaveHandler/DbTableGateway/MysqliAdapterTest.php
+++ b/test/SaveHandler/DbTableGateway/MysqliAdapterTest.php
@@ -20,17 +20,21 @@ class MysqliAdapterTest extends DbTableGatewayTest
     protected function getAdapter()
     {
         if (! getenv('TESTS_LAMINAS_SESSION_ADAPTER_DRIVER_MYSQL')) {
-            $this->markTestSkipped(sprintf(
-                '%s tests with MySQL are disabled',
-                DbTableGateway::class
-            ));
+            self::markTestSkipped(
+                sprintf(
+                    '%s tests with MySQL are disabled',
+                    DbTableGateway::class
+                )
+            );
         }
 
         if (! extension_loaded('mysqli')) {
-            $this->markTestSkipped(sprintf(
-                '%s tests with Mysqli adapter are not enabled due to missing Mysqli extension',
-                DbTableGateway::class
-            ));
+            self::markTestSkipped(
+                sprintf(
+                    '%s tests with Mysqli adapter are not enabled due to missing Mysqli extension',
+                    DbTableGateway::class
+                )
+            );
         }
 
         return new Adapter([
diff --git a/test/SaveHandler/DbTableGateway/PdoMysqlAdapterTest.php b/test/SaveHandler/DbTableGateway/PdoMysqlAdapterTest.php
index 1bd2ec49..5ba673e3 100644
--- a/test/SaveHandler/DbTableGateway/PdoMysqlAdapterTest.php
+++ b/test/SaveHandler/DbTableGateway/PdoMysqlAdapterTest.php
@@ -20,17 +20,21 @@ class PdoMysqlAdapterTest extends DbTableGatewayTest
     protected function getAdapter()
     {
         if (! getenv('TESTS_LAMINAS_SESSION_ADAPTER_DRIVER_MYSQL')) {
-            $this->markTestSkipped(sprintf(
-                '%s tests with MySQL are disabled',
-                DbTableGateway::class
-            ));
+            self::markTestSkipped(
+                sprintf(
+                    '%s tests with MySQL are disabled',
+                    DbTableGateway::class
+                )
+            );
         }
 
         if (! extension_loaded('mysqli')) {
-            $this->markTestSkipped(sprintf(
-                '%s tests with PDO_Mysql adapter are not enabled due to missing PDO_Mysql extension',
-                DbTableGateway::class
-            ));
+            self::markTestSkipped(
+                sprintf(
+                    '%s tests with PDO_Mysql adapter are not enabled due to missing PDO_Mysql extension',
+                    DbTableGateway::class
+                )
+            );
         }
 
         return new Adapter([
diff --git a/test/SaveHandler/DbTableGateway/PdoSqliteAdapterTest.php b/test/SaveHandler/DbTableGateway/PdoSqliteAdapterTest.php
index b96f5ff1..296029b9 100644
--- a/test/SaveHandler/DbTableGateway/PdoSqliteAdapterTest.php
+++ b/test/SaveHandler/DbTableGateway/PdoSqliteAdapterTest.php
@@ -20,10 +20,12 @@ class PdoSqliteAdapterTest extends DbTableGatewayTest
     protected function getAdapter()
     {
         if (! extension_loaded('pdo_sqlite')) {
-            $this->markTestSkipped(sprintf(
-                '%s tests with PDO_Sqlite adapter are not enabled due to missing PDO_Sqlite extension',
-                DbTableGateway::class
-            ));
+            self::markTestSkipped(
+                sprintf(
+                    '%s tests with PDO_Sqlite adapter are not enabled due to missing PDO_Sqlite extension',
+                    DbTableGateway::class
+                )
+            );
         }
 
         return new Adapter([
diff --git a/test/SaveHandler/DbTableGateway/PgsqlAdapterTest.php b/test/SaveHandler/DbTableGateway/PgsqlAdapterTest.php
index 1dac4f1e..c65976be 100644
--- a/test/SaveHandler/DbTableGateway/PgsqlAdapterTest.php
+++ b/test/SaveHandler/DbTableGateway/PgsqlAdapterTest.php
@@ -20,17 +20,21 @@ class PgsqlAdapterTest extends DbTableGatewayTest
     protected function getAdapter()
     {
         if (! getenv('TESTS_LAMINAS_SESSION_ADAPTER_DRIVER_PGSQL')) {
-            $this->markTestSkipped(sprintf(
-                '%s tests with Pgsql adapter are disabled',
-                DbTableGateway::class
-            ));
+            self::markTestSkipped(
+                sprintf(
+                    '%s tests with Pgsql adapter are disabled',
+                    DbTableGateway::class
+                )
+            );
         }
 
         if (! extension_loaded('mysqli')) {
-            $this->markTestSkipped(sprintf(
-                '%s tests with Pgsql adapter are not enabled due to missing Pgsql extension',
-                DbTableGateway::class
-            ));
+            self::markTestSkipped(
+                sprintf(
+                    '%s tests with Pgsql adapter are not enabled due to missing Pgsql extension',
+                    DbTableGateway::class
+                )
+            );
         }
 
         return new Adapter([
diff --git a/test/SaveHandler/DbTableGatewayOptionsTest.php b/test/SaveHandler/DbTableGatewayOptionsTest.php
index 0ec9c3fc..f979567b 100644
--- a/test/SaveHandler/DbTableGatewayOptionsTest.php
+++ b/test/SaveHandler/DbTableGatewayOptionsTest.php
@@ -8,6 +8,7 @@
 
 namespace LaminasTest\Session\SaveHandler;
 
+use Laminas\Session\Exception\InvalidArgumentException;
 use Laminas\Session\SaveHandler\DbTableGatewayOptions;
 use PHPUnit\Framework\TestCase;
 
@@ -18,96 +19,98 @@
  */
 class DbTableGatewayOptionsTest extends TestCase
 {
-    public function testDefaults()
+    public function testDefaults(): void
     {
         $options = new DbTableGatewayOptions();
-        $this->assertEquals('id', $options->getIdColumn());
-        $this->assertEquals('name', $options->getNameColumn());
-        $this->assertEquals('modified', $options->getModifiedColumn());
-        $this->assertEquals('lifetime', $options->getLifetimeColumn());
-        $this->assertEquals('data', $options->getDataColumn());
+        self::assertEquals('id', $options->getIdColumn());
+        self::assertEquals('name', $options->getNameColumn());
+        self::assertEquals('modified', $options->getModifiedColumn());
+        self::assertEquals('lifetime', $options->getLifetimeColumn());
+        self::assertEquals('data', $options->getDataColumn());
     }
 
-    public function testSetConstructor()
+    public function testSetConstructor(): void
     {
-        $options = new DbTableGatewayOptions([
-            'idColumn' => 'testId',
-            'nameColumn' => 'testName',
-            'modifiedColumn' => 'testModified',
-            'lifetimeColumn' => 'testLifetime',
-            'dataColumn' => 'testData',
-        ]);
+        $options = new DbTableGatewayOptions(
+            [
+                'idColumn'       => 'testId',
+                'nameColumn'     => 'testName',
+                'modifiedColumn' => 'testModified',
+                'lifetimeColumn' => 'testLifetime',
+                'dataColumn'     => 'testData',
+            ]
+        );
 
-        $this->assertEquals('testId', $options->getIdColumn());
-        $this->assertEquals('testName', $options->getNameColumn());
-        $this->assertEquals('testModified', $options->getModifiedColumn());
-        $this->assertEquals('testLifetime', $options->getLifetimeColumn());
-        $this->assertEquals('testData', $options->getDataColumn());
+        self::assertEquals('testId', $options->getIdColumn());
+        self::assertEquals('testName', $options->getNameColumn());
+        self::assertEquals('testModified', $options->getModifiedColumn());
+        self::assertEquals('testLifetime', $options->getLifetimeColumn());
+        self::assertEquals('testData', $options->getDataColumn());
     }
 
-    public function testSetters()
+    public function testSetters(): void
     {
         $options = new DbTableGatewayOptions();
         $options->setIdColumn('testId')
-                ->setNameColumn('testName')
-                ->setModifiedColumn('testModified')
-                ->setLifetimeColumn('testLifetime')
-                ->setDataColumn('testData');
+            ->setNameColumn('testName')
+            ->setModifiedColumn('testModified')
+            ->setLifetimeColumn('testLifetime')
+            ->setDataColumn('testData');
 
-        $this->assertEquals('testId', $options->getIdColumn());
-        $this->assertEquals('testName', $options->getNameColumn());
-        $this->assertEquals('testModified', $options->getModifiedColumn());
-        $this->assertEquals('testLifetime', $options->getLifetimeColumn());
-        $this->assertEquals('testData', $options->getDataColumn());
+        self::assertEquals('testId', $options->getIdColumn());
+        self::assertEquals('testName', $options->getNameColumn());
+        self::assertEquals('testModified', $options->getModifiedColumn());
+        self::assertEquals('testLifetime', $options->getLifetimeColumn());
+        self::assertEquals('testData', $options->getDataColumn());
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidIdColumn()
+    public function testInvalidIdColumn(): void
     {
-        $options = new DbTableGatewayOptions([
-            'idColumn' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new DbTableGatewayOptions(
+            [
+                'idColumn' => null,
+            ]
+        );
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidNameColumn()
+    public function testInvalidNameColumn(): void
     {
-        $options = new DbTableGatewayOptions([
-            'nameColumn' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new DbTableGatewayOptions(
+            [
+                'nameColumn' => null,
+            ]
+        );
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidModifiedColumn()
+    public function testInvalidModifiedColumn(): void
     {
-        $options = new DbTableGatewayOptions([
-            'modifiedColumn' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new DbTableGatewayOptions(
+            [
+                'modifiedColumn' => null,
+            ]
+        );
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidLifetimeColumn()
+    public function testInvalidLifetimeColumn(): void
     {
-        $options = new DbTableGatewayOptions([
-            'lifetimeColumn' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new DbTableGatewayOptions(
+            [
+                'lifetimeColumn' => null,
+            ]
+        );
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidDataColumn()
+    public function testInvalidDataColumn(): void
     {
-        $options = new DbTableGatewayOptions([
-            'dataColumn' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new DbTableGatewayOptions(
+            [
+                'dataColumn' => null,
+            ]
+        );
     }
 }
diff --git a/test/SaveHandler/DbTableGatewayTest.php b/test/SaveHandler/DbTableGatewayTest.php
index 9c8ca70a..f84a759a 100644
--- a/test/SaveHandler/DbTableGatewayTest.php
+++ b/test/SaveHandler/DbTableGatewayTest.php
@@ -63,17 +63,19 @@ abstract protected function getAdapter();
      *
      * @return void
      */
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->adapter = $this->getAdapter();
 
-        $this->options = new DbTableGatewayOptions([
-            'nameColumn' => 'name',
-            'idColumn'   => 'id',
-            'dataColumn' => 'data',
-            'modifiedColumn' => 'modified',
-            'lifetimeColumn' => 'lifetime',
-        ]);
+        $this->options = new DbTableGatewayOptions(
+            [
+                'nameColumn'     => 'name',
+                'idColumn'       => 'id',
+                'dataColumn'     => 'data',
+                'modifiedColumn' => 'modified',
+                'lifetimeColumn' => 'lifetime',
+            ]
+        );
 
         $this->setupDb($this->options);
         $this->testArray = ['foo' => 'bar', 'bar' => ['foo' => 'bar']];
@@ -84,60 +86,60 @@ protected function setUp()
      *
      * @return void
      */
-    protected function tearDown()
+    protected function tearDown(): void
     {
         if ($this->adapter) {
             $this->dropTable();
         }
     }
 
-    public function testReadWrite()
+    public function testReadWrite(): void
     {
         $this->usedSaveHandlers[] = $saveHandler = new DbTableGateway($this->tableGateway, $this->options);
         $saveHandler->open('savepath', 'sessionname');
 
         $id = '242';
 
-        $this->assertTrue($saveHandler->write($id, serialize($this->testArray)));
+        self::assertTrue($saveHandler->write($id, serialize($this->testArray)));
 
         $data = unserialize($saveHandler->read($id));
-        $this->assertEquals(
+        self::assertEquals(
             $this->testArray,
             $data,
             'Expected ' . var_export($this->testArray, 1) . "\nbut got: " . var_export($data, 1)
         );
     }
 
-    public function testReadWriteComplex()
+    public function testReadWriteComplex(): void
     {
         $this->usedSaveHandlers[] = $saveHandler = new DbTableGateway($this->tableGateway, $this->options);
         $saveHandler->open('savepath', 'sessionname');
 
         $id = '242';
 
-        $this->assertTrue($saveHandler->write($id, serialize($this->testArray)));
+        self::assertTrue($saveHandler->write($id, serialize($this->testArray)));
 
-        $this->assertEquals($this->testArray, unserialize($saveHandler->read($id)));
+        self::assertEquals($this->testArray, unserialize($saveHandler->read($id)));
     }
 
-    public function testReadWriteTwice()
+    public function testReadWriteTwice(): void
     {
         $this->usedSaveHandlers[] = $saveHandler = new DbTableGateway($this->tableGateway, $this->options);
         $saveHandler->open('savepath', 'sessionname');
 
         $id = '242';
 
-        $this->assertTrue($saveHandler->write($id, serialize($this->testArray)));
+        self::assertTrue($saveHandler->write($id, serialize($this->testArray)));
 
-        $this->assertEquals($this->testArray, unserialize($saveHandler->read($id)));
+        self::assertEquals($this->testArray, unserialize($saveHandler->read($id)));
 
         $updateData = $this->testArray + ['time' => microtime(true)];
-        $this->assertTrue($saveHandler->write($id, serialize($updateData)));
+        self::assertTrue($saveHandler->write($id, serialize($updateData)));
 
-        $this->assertEquals($updateData, unserialize($saveHandler->read($id)));
+        self::assertEquals($updateData, unserialize($saveHandler->read($id)));
     }
 
-    public function testReadShouldAlwaysReturnString()
+    public function testReadShouldAlwaysReturnString(): void
     {
         $this->usedSaveHandlers[] = $saveHandler = new DbTableGateway($this->tableGateway, $this->options);
         $saveHandler->open('savepath', 'sessionname');
@@ -146,10 +148,10 @@ public function testReadShouldAlwaysReturnString()
 
         $data = $saveHandler->read($id);
 
-        $this->assertTrue(is_string($data));
+        self::assertTrue(is_string($data));
     }
 
-    public function testDestroyReturnsTrueEvenWhenSessionDoesNotExist()
+    public function testDestroyReturnsTrueEvenWhenSessionDoesNotExist(): void
     {
         $this->usedSaveHandlers[] = $saveHandler = new DbTableGateway($this->tableGateway, $this->options);
         $saveHandler->open('savepath', 'sessionname');
@@ -158,31 +160,31 @@ public function testDestroyReturnsTrueEvenWhenSessionDoesNotExist()
 
         $result = $saveHandler->destroy($id);
 
-        $this->assertTrue($result);
+        self::assertTrue($result);
     }
 
-    public function testDestroyReturnsTrueWhenSessionIsDeleted()
+    public function testDestroyReturnsTrueWhenSessionIsDeleted(): void
     {
         $this->usedSaveHandlers[] = $saveHandler = new DbTableGateway($this->tableGateway, $this->options);
         $saveHandler->open('savepath', 'sessionname');
 
         $id = '242';
 
-        $this->assertTrue($saveHandler->write($id, serialize($this->testArray)));
+        self::assertTrue($saveHandler->write($id, serialize($this->testArray)));
 
         $result = $saveHandler->destroy($id);
 
-        $this->assertTrue($result);
+        self::assertTrue($result);
     }
 
-    public function testReadDestroysExpiredSession()
+    public function testReadDestroysExpiredSession(): void
     {
         $this->usedSaveHandlers[] = $saveHandler = new DbTableGateway($this->tableGateway, $this->options);
         $saveHandler->open('savepath', 'sessionname');
 
         $id = '345';
 
-        $this->assertTrue($saveHandler->write($id, serialize($this->testArray)));
+        self::assertTrue($saveHandler->write($id, serialize($this->testArray)));
 
         // set lifetime to 0
         $query = <<<EOD
@@ -196,7 +198,7 @@ public function testReadDestroysExpiredSession()
 
         // check destroy session
         $result = $saveHandler->read($id);
-        $this->assertEquals($result, '');
+        self::assertEquals($result, '');
 
         // check if the record really has been deleted
         $result = $this->adapter->query(
@@ -208,7 +210,7 @@ public function testReadDestroysExpiredSession()
             Adapter::QUERY_MODE_EXECUTE
         );
 
-        $this->assertEquals(0, $result->count());
+        self::assertEquals(0, $result->count());
 
         // cleans the test record from the db
         $this->adapter->query(
@@ -220,10 +222,10 @@ public function testReadDestroysExpiredSession()
     /**
      * Sets up the database connection and creates the table for session data
      *
-     * @param  \Laminas\Session\SaveHandler\DbTableGatewayOptions $options
+     * @param DbTableGatewayOptions $options
      * @return void
      */
-    protected function setupDb(DbTableGatewayOptions $options)
+    protected function setupDb(DbTableGatewayOptions $options): void
     {
         $query = <<<EOD
 CREATE TABLE sessions (
@@ -244,7 +246,7 @@ protected function setupDb(DbTableGatewayOptions $options)
      *
      * @return void
      */
-    protected function dropTable()
+    protected function dropTable(): void
     {
         if (! $this->adapter) {
             return;
diff --git a/test/SaveHandler/MongoDBOptionsTest.php b/test/SaveHandler/MongoDBOptionsTest.php
index 5dc00086..2b829a01 100644
--- a/test/SaveHandler/MongoDBOptionsTest.php
+++ b/test/SaveHandler/MongoDBOptionsTest.php
@@ -8,6 +8,7 @@
 
 namespace LaminasTest\Session\SaveHandler;
 
+use Laminas\Session\Exception\InvalidArgumentException;
 use Laminas\Session\SaveHandler\MongoDBOptions;
 use PHPUnit\Framework\TestCase;
 
@@ -16,128 +17,130 @@
  */
 class MongoDBOptionsTest extends TestCase
 {
-    public function testDefaults()
+    public function testDefaults(): void
     {
         $options = new MongoDBOptions();
-        $this->assertNull($options->getDatabase());
-        $this->assertNull($options->getCollection());
-        $mongoVersion = phpversion('mongo') ?: '0.0.0';
+        self::assertNull($options->getDatabase());
+        self::assertNull($options->getCollection());
+        $mongoVersion       = phpversion('mongo') ?: '0.0.0';
         $defaultSaveOptions = version_compare($mongoVersion, '1.3.0', '<') ? ['safe' => true] : ['w' => 1];
-        $this->assertEquals($defaultSaveOptions, $options->getSaveOptions());
-        $this->assertEquals('name', $options->getNameField());
-        $this->assertEquals('data', $options->getDataField());
-        $this->assertEquals('lifetime', $options->getLifetimeField());
-        $this->assertEquals('modified', $options->getModifiedField());
+        self::assertEquals($defaultSaveOptions, $options->getSaveOptions());
+        self::assertEquals('name', $options->getNameField());
+        self::assertEquals('data', $options->getDataField());
+        self::assertEquals('lifetime', $options->getLifetimeField());
+        self::assertEquals('modified', $options->getModifiedField());
     }
 
-    public function testSetConstructor()
+    public function testSetConstructor(): void
     {
-        $options = new MongoDBOptions([
-            'database' => 'testDatabase',
-            'collection' => 'testCollection',
-            'saveOptions' => ['w' => 2],
-            'nameField' => 'testName',
-            'dataField' => 'testData',
-            'lifetimeField' => 'testLifetime',
-            'modifiedField' => 'testModified',
-        ]);
+        $options = new MongoDBOptions(
+            [
+                'database'      => 'testDatabase',
+                'collection'    => 'testCollection',
+                'saveOptions'   => ['w' => 2],
+                'nameField'     => 'testName',
+                'dataField'     => 'testData',
+                'lifetimeField' => 'testLifetime',
+                'modifiedField' => 'testModified',
+            ]
+        );
 
-        $this->assertEquals('testDatabase', $options->getDatabase());
-        $this->assertEquals('testCollection', $options->getCollection());
-        $this->assertEquals(['w' => 2], $options->getSaveOptions());
-        $this->assertEquals('testName', $options->getNameField());
-        $this->assertEquals('testData', $options->getDataField());
-        $this->assertEquals('testLifetime', $options->getLifetimeField());
-        $this->assertEquals('testModified', $options->getModifiedField());
+        self::assertEquals('testDatabase', $options->getDatabase());
+        self::assertEquals('testCollection', $options->getCollection());
+        self::assertEquals(['w' => 2], $options->getSaveOptions());
+        self::assertEquals('testName', $options->getNameField());
+        self::assertEquals('testData', $options->getDataField());
+        self::assertEquals('testLifetime', $options->getLifetimeField());
+        self::assertEquals('testModified', $options->getModifiedField());
     }
 
-    public function testSetters()
+    public function testSetters(): void
     {
         $options = new MongoDBOptions();
         $options->setDatabase('testDatabase')
-                ->setCollection('testCollection')
-                ->setSaveOptions(['w' => 2])
-                ->setNameField('testName')
-                ->setDataField('testData')
-                ->setLifetimeField('testLifetime')
-                ->setModifiedField('testModified');
+            ->setCollection('testCollection')
+            ->setSaveOptions(['w' => 2])
+            ->setNameField('testName')
+            ->setDataField('testData')
+            ->setLifetimeField('testLifetime')
+            ->setModifiedField('testModified');
 
-        $this->assertEquals('testDatabase', $options->getDatabase());
-        $this->assertEquals('testCollection', $options->getCollection());
-        $this->assertEquals(['w' => 2], $options->getSaveOptions());
-        $this->assertEquals('testName', $options->getNameField());
-        $this->assertEquals('testData', $options->getDataField());
-        $this->assertEquals('testLifetime', $options->getLifetimeField());
-        $this->assertEquals('testModified', $options->getModifiedField());
+        self::assertEquals('testDatabase', $options->getDatabase());
+        self::assertEquals('testCollection', $options->getCollection());
+        self::assertEquals(['w' => 2], $options->getSaveOptions());
+        self::assertEquals('testName', $options->getNameField());
+        self::assertEquals('testData', $options->getDataField());
+        self::assertEquals('testLifetime', $options->getLifetimeField());
+        self::assertEquals('testModified', $options->getModifiedField());
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidDatabase()
+    public function testInvalidDatabase(): void
     {
-        $options = new MongoDBOptions([
-            'database' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new MongoDBOptions(
+            [
+                'database' => null,
+            ]
+        );
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidCollection()
+    public function testInvalidCollection(): void
     {
-        $options = new MongoDBOptions([
-            'collection' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new MongoDBOptions(
+            [
+                'collection' => null,
+            ]
+        );
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidSaveOptions()
+    public function testInvalidSaveOptions(): void
     {
-        $options = new MongoDBOptions([
-            'saveOptions' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new MongoDBOptions(
+            [
+                'saveOptions' => null,
+            ]
+        );
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidNameField()
+    public function testInvalidNameField(): void
     {
-        $options = new MongoDBOptions([
-            'nameField' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new MongoDBOptions(
+            [
+                'nameField' => null,
+            ]
+        );
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidModifiedField()
+    public function testInvalidModifiedField(): void
     {
-        $options = new MongoDBOptions([
-            'modifiedField' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new MongoDBOptions(
+            [
+                'modifiedField' => null,
+            ]
+        );
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidLifetimeField()
+    public function testInvalidLifetimeField(): void
     {
-        $options = new MongoDBOptions([
-            'lifetimeField' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new MongoDBOptions(
+            [
+                'lifetimeField' => null,
+            ]
+        );
     }
 
-    /**
-     * @expectedException Laminas\Session\Exception\InvalidArgumentException
-     */
-    public function testInvalidDataField()
+    public function testInvalidDataField(): void
     {
-        $options = new MongoDBOptions([
-            'dataField' => null,
-        ]);
+        $this->expectException(InvalidArgumentException::class);
+        $options = new MongoDBOptions(
+            [
+                'dataField' => null,
+            ]
+        );
     }
 }
diff --git a/test/SaveHandler/MongoDBTest.php b/test/SaveHandler/MongoDBTest.php
index da1d7581..500df1ba 100644
--- a/test/SaveHandler/MongoDBTest.php
+++ b/test/SaveHandler/MongoDBTest.php
@@ -12,6 +12,7 @@
 use Laminas\Session\SaveHandler\MongoDBOptions;
 use MongoDB\Client as MongoClient;
 use MongoDB\Collection as MongoCollection;
+use MongoDB\Driver\Exception\RuntimeException;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -42,14 +43,16 @@ class MongoDBTest extends TestCase
      *
      * @return void
      */
-    protected function setUp()
+    protected function setUp(): void
     {
-        $this->options = new MongoDBOptions([
-            'database' => 'laminas_tests',
-            'collection' => 'sessions',
-        ]);
+        $this->options = new MongoDBOptions(
+            [
+                'database'   => 'laminas_tests',
+                'collection' => 'sessions',
+            ]
+        );
 
-        $this->mongoClient = new MongoClient();
+        $this->mongoClient     = new MongoClient();
         $this->mongoCollection = $this->mongoClient->selectCollection(
             $this->options->getDatabase(),
             $this->options->getCollection()
@@ -61,34 +64,34 @@ protected function setUp()
      *
      * @return void
      */
-    protected function tearDown()
+    protected function tearDown(): void
     {
         if ($this->mongoCollection) {
             $this->mongoCollection->drop();
         }
     }
 
-    public function testReadWrite()
+    public function testReadWrite(): void
     {
         $saveHandler = new MongoDB($this->mongoClient, $this->options);
-        $this->assertTrue($saveHandler->open('savepath', 'sessionname'));
+        self::assertTrue($saveHandler->open('savepath', 'sessionname'));
 
-        $id = '242';
+        $id   = '242';
         $data = ['foo' => 'bar', 'bar' => ['foo' => 'bar']];
 
-        $this->assertTrue($saveHandler->write($id, serialize($data)));
-        $this->assertEquals($data, unserialize($saveHandler->read($id)));
+        self::assertTrue($saveHandler->write($id, serialize($data)));
+        self::assertEquals($data, unserialize($saveHandler->read($id)));
 
         $data = ['foo' => [1, 2, 3]];
 
-        $this->assertTrue($saveHandler->write($id, serialize($data)));
-        $this->assertEquals($data, unserialize($saveHandler->read($id)));
+        self::assertTrue($saveHandler->write($id, serialize($data)));
+        self::assertEquals($data, unserialize($saveHandler->read($id)));
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testReadDestroysExpiredSession()
+    public function testReadDestroysExpiredSession(): void
     {
         /* Note: due to the session save handler's open() method reading the
          * "session.gc_maxlifetime" INI value directly, it's necessary to set
@@ -98,71 +101,69 @@ public function testReadDestroysExpiredSession()
         ini_set('session.gc_maxlifetime', 0);
 
         $saveHandler = new MongoDB($this->mongoClient, $this->options);
-        $this->assertTrue($saveHandler->open('savepath', 'sessionname'));
+        self::assertTrue($saveHandler->open('savepath', 'sessionname'));
 
-        $id = '242';
+        $id   = '242';
         $data = ['foo' => 'bar'];
 
-        $this->assertNull($this->mongoCollection->findOne(['_id' => $id]));
+        self::assertNull($this->mongoCollection->findOne(['_id' => $id]));
 
-        $this->assertTrue($saveHandler->write($id, serialize($data)));
-        $this->assertNotNull($this->mongoCollection->findOne(['_id' => $id]));
-        $this->assertEquals('', $saveHandler->read($id));
-        $this->assertNull($this->mongoCollection->findOne(['_id' => $id]));
+        self::assertTrue($saveHandler->write($id, serialize($data)));
+        self::assertNotNull($this->mongoCollection->findOne(['_id' => $id]));
+        self::assertEquals('', $saveHandler->read($id));
+        self::assertNull($this->mongoCollection->findOne(['_id' => $id]));
 
         ini_set('session.gc_maxlifetime', $oldMaxlifetime);
     }
 
-    public function testGarbageCollection()
+    public function testGarbageCollection(): void
     {
         $saveHandler = new MongoDB($this->mongoClient, $this->options);
-        $this->assertTrue($saveHandler->open('savepath', 'sessionname'));
+        self::assertTrue($saveHandler->open('savepath', 'sessionname'));
 
         $data = ['foo' => 'bar'];
 
-        $this->assertTrue($saveHandler->write(123, serialize($data)));
-        $this->assertTrue($saveHandler->write(456, serialize($data)));
-        $this->assertEquals(2, $this->mongoCollection->count());
+        self::assertTrue($saveHandler->write(123, serialize($data)));
+        self::assertTrue($saveHandler->write(456, serialize($data)));
+        self::assertEquals(2, $this->mongoCollection->count());
         $saveHandler->gc(5);
-        $this->assertEquals(2, $this->mongoCollection->count());
+        self::assertEquals(2, $this->mongoCollection->count());
 
         /* Note: MongoDate uses micro-second precision, so even a maximum
          * lifetime of zero would not match records that were just inserted.
          * Use a negative number instead.
          */
         $saveHandler->gc(-1);
-        $this->assertEquals(0, $this->mongoCollection->count());
+        self::assertEquals(0, $this->mongoCollection->count());
     }
 
-    public function testGarbageCollectionMaxlifetimeIsInSeconds()
+    public function testGarbageCollectionMaxlifetimeIsInSeconds(): void
     {
         $saveHandler = new MongoDB($this->mongoClient, $this->options);
-        $this->assertTrue($saveHandler->open('savepath', 'sessionname'));
+        self::assertTrue($saveHandler->open('savepath', 'sessionname'));
 
         $data = ['foo' => 'bar'];
 
-        $this->assertTrue($saveHandler->write(123, serialize($data)));
+        self::assertTrue($saveHandler->write(123, serialize($data)));
         sleep(1);
-        $this->assertTrue($saveHandler->write(456, serialize($data)));
-        $this->assertEquals(2, $this->mongoCollection->count());
+        self::assertTrue($saveHandler->write(456, serialize($data)));
+        self::assertEquals(2, $this->mongoCollection->count());
 
         // Clear everything what is at least 1 second old.
         $saveHandler->gc(1);
-        $this->assertEquals(1, $this->mongoCollection->count());
+        self::assertEquals(1, $this->mongoCollection->count());
 
-        $this->assertEmpty($saveHandler->read(123));
-        $this->assertNotEmpty($saveHandler->read(456));
+        self::assertEmpty($saveHandler->read(123));
+        self::assertNotEmpty($saveHandler->read(456));
     }
 
-    /**
-     * @expectedException \MongoDB\Driver\Exception\RuntimeException
-     */
-    public function testWriteExceptionEdgeCaseForChangedSessionName()
+    public function testWriteExceptionEdgeCaseForChangedSessionName(): void
     {
+        $this->expectException(RuntimeException::class);
         $saveHandler = new MongoDB($this->mongoClient, $this->options);
-        $this->assertTrue($saveHandler->open('savepath', 'sessionname'));
+        self::assertTrue($saveHandler->open('savepath', 'sessionname'));
 
-        $id = '242';
+        $id   = '242';
         $data = ['foo' => 'bar'];
 
         /* Note: a MongoCursorException will be thrown if a record with this ID
@@ -176,15 +177,15 @@ public function testWriteExceptionEdgeCaseForChangedSessionName()
         $saveHandler->write($id, serialize($data));
     }
 
-    public function testReadShouldAlwaysReturnString()
+    public function testReadShouldAlwaysReturnString(): void
     {
         $saveHandler = new MongoDB($this->mongoClient, $this->options);
-        $this->assertTrue($saveHandler->open('savepath', 'sessionname'));
+        self::assertTrue($saveHandler->open('savepath', 'sessionname'));
 
         $id = '242';
 
         $data = $saveHandler->read($id);
 
-        $this->assertTrue(is_string($data));
+        self::assertTrue(is_string($data));
     }
 }
diff --git a/test/Service/ContainerAbstractServiceFactoryTest.php b/test/Service/ContainerAbstractServiceFactoryTest.php
index 793a2b6b..9f824b53 100644
--- a/test/Service/ContainerAbstractServiceFactoryTest.php
+++ b/test/Service/ContainerAbstractServiceFactoryTest.php
@@ -33,25 +33,27 @@ class ContainerAbstractServiceFactoryTest extends TestCase
         ],
     ];
 
-    protected function setUp()
+    protected function setUp(): void
     {
-        $config = new Config([
-            'services' => [
-                'config' => $this->config,
-                StorageInterface::class => new ArrayStorage(),
-            ],
-            'factories' => [
-                ManagerInterface::class => SessionManagerFactory::class,
-            ],
-            'abstract_factories' => [
-                ContainerAbstractServiceFactory::class,
-            ],
-        ]);
+        $config         = new Config(
+            [
+                'services'           => [
+                    'config'                => $this->config,
+                    StorageInterface::class => new ArrayStorage(),
+                ],
+                'factories'          => [
+                    ManagerInterface::class => SessionManagerFactory::class,
+                ],
+                'abstract_factories' => [
+                    ContainerAbstractServiceFactory::class,
+                ],
+            ]
+        );
         $this->services = new ServiceManager();
         $config->configureServiceManager($this->services);
     }
 
-    public function validContainers()
+    public function validContainers(): array
     {
         $containers = [];
         $config     = $this->config;
@@ -65,28 +67,28 @@ public function validContainers()
     /**
      * @dataProvider validContainers
      */
-    public function testCanRetrieveNamedContainers($serviceName, $containerName)
+    public function testCanRetrieveNamedContainers($serviceName, $containerName): void
     {
-        $this->assertTrue($this->services->has($serviceName), "Container does not have service by name '$serviceName'");
+        self::assertTrue($this->services->has($serviceName), "Container does not have service by name '$serviceName'");
         $container = $this->services->get($serviceName);
-        $this->assertInstanceOf(Container::class, $container);
-        $this->assertEquals($containerName, $container->getName());
+        self::assertInstanceOf(Container::class, $container);
+        self::assertEquals($containerName, $container->getName());
     }
 
     /**
      * @dataProvider validContainers
      */
-    public function testContainersAreInjectedWithSessionManagerService($serviceName, $containerName)
+    public function testContainersAreInjectedWithSessionManagerService($serviceName, $containerName): void
     {
-        $this->assertTrue($this->services->has($serviceName), "Container does not have service by name '$serviceName'");
+        self::assertTrue($this->services->has($serviceName), "Container does not have service by name '$serviceName'");
         $container = $this->services->get($serviceName);
-        $this->assertSame($this->services->get(ManagerInterface::class), $container->getManager());
+        self::assertSame($this->services->get(ManagerInterface::class), $container->getManager());
     }
 
-    public function invalidContainers()
+    public function invalidContainers(): array
     {
         $containers = [];
-        $config = $this->config;
+        $config     = $this->config;
         foreach ($config['session_containers'] as $name) {
             $containers[] = ['SomePrefix\\' . $name];
         }
@@ -98,8 +100,8 @@ public function invalidContainers()
     /**
      * @dataProvider invalidContainers
      */
-    public function testInvalidContainerNamesAreNotMatchedByAbstractFactory($name)
+    public function testInvalidContainerNamesAreNotMatchedByAbstractFactory($name): void
     {
-        $this->assertFalse($this->services->has($name));
+        self::assertFalse($this->services->has($name));
     }
 }
diff --git a/test/Service/SessionConfigFactoryTest.php b/test/Service/SessionConfigFactoryTest.php
index 111f259a..c378e534 100644
--- a/test/Service/SessionConfigFactoryTest.php
+++ b/test/Service/SessionConfigFactoryTest.php
@@ -21,48 +21,62 @@
  */
 class SessionConfigFactoryTest extends TestCase
 {
-    protected function setUp()
+    /** @var ServiceManager */
+    private $services;
+
+    protected function setUp(): void
     {
-        $config = new Config([
-            'factories' => [
-                ConfigInterface::class => SessionConfigFactory::class,
-            ],
-        ]);
+        $config         = new Config(
+            [
+                'factories' => [
+                    ConfigInterface::class => SessionConfigFactory::class,
+                ],
+            ]
+        );
         $this->services = new ServiceManager();
         $config->configureServiceManager($this->services);
     }
 
-    public function testCreatesSessionConfigByDefault()
+    public function testCreatesSessionConfigByDefault(): void
     {
-        $this->services->setService('config', [
-            'session_config' => [],
-        ]);
+        $this->services->setService(
+            'config',
+            [
+                'session_config' => [],
+            ]
+        );
         $config = $this->services->get(ConfigInterface::class);
-        $this->assertInstanceOf(SessionConfig::class, $config);
+        self::assertInstanceOf(SessionConfig::class, $config);
     }
 
-    public function testCanCreateAlternateSessionConfigTypeViaConfigClassKey()
+    public function testCanCreateAlternateSessionConfigTypeViaConfigClassKey(): void
     {
-        $this->services->setService('config', [
-            'session_config' => [
-                'config_class' => StandardConfig::class,
-            ],
-        ]);
+        $this->services->setService(
+            'config',
+            [
+                'session_config' => [
+                    'config_class' => StandardConfig::class,
+                ],
+            ]
+        );
         $config = $this->services->get(ConfigInterface::class);
-        $this->assertInstanceOf(StandardConfig::class, $config);
+        self::assertInstanceOf(StandardConfig::class, $config);
         // Since SessionConfig extends StandardConfig, need to assert not SessionConfig
-        $this->assertNotInstanceOf(SessionConfig::class, $config);
+        self::assertNotInstanceOf(SessionConfig::class, $config);
     }
 
-    public function testServiceReceivesConfiguration()
+    public function testServiceReceivesConfiguration(): void
     {
-        $this->services->setService('config', [
-            'session_config' => [
-                'config_class' => StandardConfig::class,
-                'name'         => 'laminas',
-            ],
-        ]);
+        $this->services->setService(
+            'config',
+            [
+                'session_config' => [
+                    'config_class' => StandardConfig::class,
+                    'name'         => 'laminas',
+                ],
+            ]
+        );
         $config = $this->services->get(ConfigInterface::class);
-        $this->assertEquals('laminas', $config->getName());
+        self::assertEquals('laminas', $config->getName());
     }
 }
diff --git a/test/Service/SessionManagerFactoryTest.php b/test/Service/SessionManagerFactoryTest.php
index c9093fa7..185d9f8a 100644
--- a/test/Service/SessionManagerFactoryTest.php
+++ b/test/Service/SessionManagerFactoryTest.php
@@ -21,9 +21,11 @@
 use Laminas\Session\Storage\ArrayStorage;
 use Laminas\Session\Storage\StorageInterface;
 use Laminas\Session\Validator;
+use LaminasTest\Session\ReflectionPropertyTrait;
 use LaminasTest\Session\TestAsset\TestManager;
 use LaminasTest\Session\TestAsset\TestSaveHandler;
 use PHPUnit\Framework\TestCase;
+use RuntimeException;
 
 /**
  * @covers \Laminas\Session\Service\SessionManagerFactory
@@ -31,74 +33,80 @@
 class SessionManagerFactoryTest extends TestCase
 {
     use EventListenerIntrospectionTrait;
+    use ReflectionPropertyTrait;
 
-    protected function setUp()
+    /** @var ServiceManager */
+    private $services;
+
+    protected function setUp(): void
     {
-        $config = new Config([
-            'factories' => [
-                ManagerInterface::class => SessionManagerFactory::class,
-                TestManager::class => SessionManagerFactory::class,
-                TestSaveHandler::class => SessionManagerFactory::class,
-            ],
-        ]);
+        $config         = new Config(
+            [
+                'factories' => [
+                    ManagerInterface::class => SessionManagerFactory::class,
+                    TestManager::class      => SessionManagerFactory::class,
+                    TestSaveHandler::class  => SessionManagerFactory::class,
+                ],
+            ]
+        );
         $this->services = new ServiceManager();
         $config->configureServiceManager($this->services);
     }
 
-    public function testCreatesSessionManager()
+    public function testCreatesSessionManager(): void
     {
         $manager = $this->services->get(ManagerInterface::class);
-        $this->assertInstanceOf(SessionManager::class, $manager);
+        self::assertInstanceOf(SessionManager::class, $manager);
     }
 
-    public function testConfigObjectIsInjectedIfPresentInServices()
+    public function testConfigObjectIsInjectedIfPresentInServices(): void
     {
         $config = $this->createMock(ConfigInterface::class);
         $this->services->setService(ConfigInterface::class, $config);
         $manager = $this->services->get(ManagerInterface::class);
-        $test = $manager->getConfig();
-        $this->assertSame($config, $test);
+        $test    = $manager->getConfig();
+        self::assertSame($config, $test);
     }
 
-    public function testFactoryWillInjectStorageIfPresentInServices()
+    public function testFactoryWillInjectStorageIfPresentInServices(): void
     {
         // Using concrete version here as mocking was too complex
         $storage = new ArrayStorage();
         $this->services->setService(StorageInterface::class, $storage);
         $manager = $this->services->get(ManagerInterface::class);
-        $test = $manager->getStorage();
-        $this->assertSame($storage, $test);
+        $test    = $manager->getStorage();
+        self::assertSame($storage, $test);
     }
 
-    public function testFactoryWillInjectSaveHandlerIfPresentInServices()
+    public function testFactoryWillInjectSaveHandlerIfPresentInServices(): void
     {
         $saveHandler = $this->createMock(SaveHandlerInterface::class);
         $this->services->setService(SaveHandlerInterface::class, $saveHandler);
         $manager = $this->services->get(ManagerInterface::class);
-        $test = $manager->getSaveHandler();
-        $this->assertSame($saveHandler, $test);
+        $test    = $manager->getSaveHandler();
+        self::assertSame($saveHandler, $test);
     }
 
-    public function testFactoryWillMarkManagerAsContainerDefaultByDefault()
+    public function testFactoryWillMarkManagerAsContainerDefaultByDefault(): void
     {
         $manager = $this->services->get(ManagerInterface::class);
-        $this->assertSame($manager, Container::getDefaultManager());
+        self::assertSame($manager, Container::getDefaultManager());
     }
 
-    public function testCanDisableContainerDefaultManagerInjectionViaConfiguration()
+    public function testCanDisableContainerDefaultManagerInjectionViaConfiguration(): void
     {
         $config = ['session_manager' => [
             'enable_default_container_manager' => false,
         ]];
         $this->services->setService('config', $config);
         $manager = $this->services->get(ManagerInterface::class);
-        $this->assertNotSame($manager, Container::getDefaultManager());
+        self::assertNotSame($manager, Container::getDefaultManager());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testFactoryWillAddValidatorViaConfiguration()
+    public function testFactoryWillAddValidatorViaConfiguration(): void
     {
         $config = ['session_manager' => [
             'validators' => [
@@ -110,15 +118,15 @@ public function testFactoryWillAddValidatorViaConfiguration()
 
         $manager->start();
 
-        $chain = $manager->getValidatorChain();
+        $chain     = $manager->getValidatorChain();
         $listeners = iterator_to_array($this->getListenersForEvent('session.validate', $chain));
-        $this->assertCount(2, $listeners);
+        self::assertCount(2, $listeners);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testStartingSessionManagerFromFactoryDoesNotTriggerUndefinedVariable()
+    public function testStartingSessionManagerFromFactoryDoesNotTriggerUndefinedVariable(): void
     {
         $storage = new ArrayStorage();
         $this->services->setService(StorageInterface::class, $storage);
@@ -126,65 +134,77 @@ public function testStartingSessionManagerFromFactoryDoesNotTriggerUndefinedVari
         $manager = $this->services->get(ManagerInterface::class);
         $manager->start();
 
-        $this->assertSame($storage, $manager->getStorage());
+        self::assertSame($storage, $manager->getStorage());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testFactoryDoesNotOverwriteValidatorStorageValues()
+    public function testFactoryDoesNotOverwriteValidatorStorageValues(): void
     {
         $storage = new ArrayStorage();
-        $storage->setMetadata('_VALID', [
-            Validator\HttpUserAgent::class => 'Foo',
-            Validator\RemoteAddr::class    => '1.2.3.4',
-        ]);
+        $storage->setMetadata(
+            '_VALID',
+            [
+                Validator\HttpUserAgent::class => 'Foo',
+                Validator\RemoteAddr::class    => '1.2.3.4',
+            ]
+        );
         $this->services->setService(StorageInterface::class, $storage);
-        $this->services->setService('config', [
-            'session_manager' => [
-                'validators' => [
-                    Validator\HttpUserAgent::class,
-                    Validator\RemoteAddr::class,
+        $this->services->setService(
+            'config',
+            [
+                'session_manager' => [
+                    'validators' => [
+                        Validator\HttpUserAgent::class,
+                        Validator\RemoteAddr::class,
+                    ],
                 ],
-            ],
-        ]);
+            ]
+        );
 
         // This call is needed to make sure session storage data is not overwritten by the factory
         $manager = $this->services->get(ManagerInterface::class);
 
         $validatorData = $storage->getMetaData('_VALID');
-        $this->assertSame('Foo', $validatorData[Validator\HttpUserAgent::class]);
-        $this->assertSame('1.2.3.4', $validatorData[Validator\RemoteAddr::class]);
+        self::assertSame('Foo', $validatorData[Validator\HttpUserAgent::class]);
+        self::assertSame('1.2.3.4', $validatorData[Validator\RemoteAddr::class]);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testFactoryDoesNotAttachValidatorTwoTimes()
+    public function testFactoryDoesNotAttachValidatorTwoTimes(): void
     {
         $storage = new ArrayStorage();
-        $storage->setMetadata('_VALID', [
-            Validator\RemoteAddr::class => '1.2.3.4',
-        ]);
+        $storage->setMetadata(
+            '_VALID',
+            [
+                Validator\RemoteAddr::class => '1.2.3.4',
+            ]
+        );
         $this->services->setService(StorageInterface::class, $storage);
-        $this->services->setService('config', [
-            'session_manager' => [
-                'validators' => [
-                    Validator\RemoteAddr::class,
+        $this->services->setService(
+            'config',
+            [
+                'session_manager' => [
+                    'validators' => [
+                        Validator\RemoteAddr::class,
+                    ],
                 ],
-            ],
-        ]);
+            ]
+        );
 
         $manager = $this->services->get(ManagerInterface::class);
         try {
             $manager->start();
-        } catch (\RuntimeException $e) {
+        } catch (RuntimeException $e) {
             // Ignore exception, because we are not interested whether session validation passes in this test
         }
 
-        $chain = $manager->getValidatorChain();
+        $chain     = $manager->getValidatorChain();
         $listeners = iterator_to_array($this->getListenersForEvent('session.validate', $chain));
-        $this->assertCount(2, $listeners);
+        self::assertCount(2, $listeners);
 
         $found = false;
         foreach ($listeners as $listener) {
@@ -194,32 +214,37 @@ public function testFactoryDoesNotAttachValidatorTwoTimes()
                 break;
             }
         }
-        $this->assertTrue($found, 'Did not find RemoteAddr validator in listeners');
+        self::assertTrue($found, 'Did not find RemoteAddr validator in listeners');
     }
 
-    public function testFactoryAllowsOverridingOptions()
+    public function testFactoryAllowsOverridingOptions(): void
     {
         $storage = new ArrayStorage();
         $this->services->setService(StorageInterface::class, $storage);
-        $this->services->setService('config', [
-            'session_manager' => [
-                'options' => [
-                    'attach_default_validators' => false,
+        $this->services->setService(
+            'config',
+            [
+                'session_manager' => [
+                    'options' => [
+                        'attach_default_validators' => false,
+                    ],
                 ],
-            ],
-        ]);
+            ]
+        );
 
         $manager = $this->services->get(ManagerInterface::class);
-        $this->assertAttributeSame([], 'validators', $manager);
+
+        $containedValidators = $this->getReflectionProperty($manager, 'validators');
+        self::assertSame([], $containedValidators);
     }
 
-    public function testFactoryWillUseRequestedNameAsSessionManagerIfItImplementsManagerInterface()
+    public function testFactoryWillUseRequestedNameAsSessionManagerIfItImplementsManagerInterface(): void
     {
         $manager = $this->services->get(TestManager::class);
-        $this->assertInstanceOf(TestManager::class, $manager);
+        self::assertInstanceOf(TestManager::class, $manager);
     }
 
-    public function testFactoryWillRaiseServiceNotCreatedExceptionIfRequestedNameIsNotAManagerInterfaceSubclass()
+    public function testFactoryWillRaiseServiceNotCreatedExceptionIfRequestedNameIsNotAManagerInterfaceSubclass(): void
     {
         $this->expectException(ServiceNotCreatedException::class);
         $manager = $this->services->get(TestSaveHandler::class);
diff --git a/test/Service/StorageFactoryTest.php b/test/Service/StorageFactoryTest.php
index 05d8fe6f..7bec7d9a 100644
--- a/test/Service/StorageFactoryTest.php
+++ b/test/Service/StorageFactoryTest.php
@@ -23,30 +23,35 @@
  */
 class StorageFactoryTest extends TestCase
 {
-    protected function setUp()
+    /** @var ServiceManager */
+    private $services;
+
+    protected function setUp(): void
     {
-        $config = new Config([
-            'factories' => [
-                StorageInterface::class => StorageFactory::class,
-            ],
-        ]);
+        $config         = new Config(
+            [
+                'factories' => [
+                    StorageInterface::class => StorageFactory::class,
+                ],
+            ]
+        );
         $this->services = new ServiceManager();
         $config->configureServiceManager($this->services);
     }
 
-    public function sessionStorageConfig()
+    public function sessionStorageConfig(): array
     {
         return [
             'array-storage-short' => [[
-                'session_storage' => [
-                    'type' => 'ArrayStorage',
-                    'options' => [
-                        'input' => [
-                            'foo' => 'bar',
-                        ],
-                    ],
-                ],
-            ], ArrayStorage::class],
+                                          'session_storage' => [
+                                              'type'    => 'ArrayStorage',
+                                              'options' => [
+                                                  'input' => [
+                                                      'foo' => 'bar',
+                                                  ],
+                                              ],
+                                          ],
+                                      ], ArrayStorage::class],
             'array-storage-fqcn' => [[
                 'session_storage' => [
                     'type' => ArrayStorage::class,
@@ -93,45 +98,48 @@ public function sessionStorageConfig()
     /**
      * @dataProvider sessionStorageConfig
      */
-    public function testUsesConfigurationToCreateStorage($config, $class)
+    public function testUsesConfigurationToCreateStorage($config, $class): void
     {
         $this->services->setService('config', $config);
         $storage = $this->services->get(StorageInterface::class);
-        $this->assertInstanceOf($class, $storage);
+        self::assertInstanceOf($class, $storage);
         $test = $storage->toArray();
-        $this->assertEquals($config['session_storage']['options']['input'], $test);
+        self::assertEquals($config['session_storage']['options']['input'], $test);
     }
 
-    public function testConfigurationWithoutInputIsValid()
+    public function testConfigurationWithoutInputIsValid(): void
     {
-        $this->services->setService('config', [
-            'session_storage' => [
-                'type' => ArrayStorage::class,
-                'options' => [],
-            ],
-        ]);
+        $this->services->setService(
+            'config',
+            [
+                'session_storage' => [
+                    'type'    => ArrayStorage::class,
+                    'options' => [],
+                ],
+            ]
+        );
 
         $storage = $this->services->get(StorageInterface::class);
 
-        $this->assertInstanceOf(ArrayStorage::class, $storage);
-        $this->assertSame([], $storage->toArray());
+        self::assertInstanceOf(ArrayStorage::class, $storage);
+        self::assertSame([], $storage->toArray());
     }
 
-    public function invalidSessionStorageConfig()
+    public function invalidSessionStorageConfig(): array
     {
         return [
             'unknown-class-short' => [[
-                'session_storage' => [
-                    'type' => 'FooStorage',
-                    'options' => [],
-                ],
-            ]],
-            'unknown-class-fqcn' => [[
-                'session_storage' => [
-                    'type' => 'Foo\Bar\Baz\Bat',
-                    'options' => [],
-                ],
-            ]],
+                                          'session_storage' => [
+                                              'type'    => 'FooStorage',
+                                              'options' => [],
+                                          ],
+                                      ]],
+            'unknown-class-fqcn'  => [[
+                                          'session_storage' => [
+                                              'type'    => 'Foo\Bar\Baz\Bat',
+                                              'options' => [],
+                                          ],
+                                      ]],
             'bad-class' => [[
                 'session_storage' => [
                     'type' => 'Laminas\Session\Config\StandardConfig',
@@ -152,7 +160,7 @@ public function invalidSessionStorageConfig()
     /**
      * @dataProvider invalidSessionStorageConfig
      */
-    public function testInvalidConfigurationRaisesServiceNotCreatedException($config)
+    public function testInvalidConfigurationRaisesServiceNotCreatedException($config): void
     {
         $this->services->setService('config', $config);
         $this->expectException(ServiceNotCreatedException::class);
diff --git a/test/SessionArrayStorageTest.php b/test/SessionArrayStorageTest.php
index 5182b11b..9a4f1914 100644
--- a/test/SessionArrayStorageTest.php
+++ b/test/SessionArrayStorageTest.php
@@ -18,116 +18,116 @@
  */
 class SessionArrayStorageTest extends TestCase
 {
-    protected function setUp()
+    protected function setUp(): void
     {
-        $_SESSION = [];
-        $this->storage = new SessionArrayStorage;
+        $_SESSION      = [];
+        $this->storage = new SessionArrayStorage();
     }
 
-    protected function tearDown()
+    protected function tearDown(): void
     {
         $_SESSION = [];
     }
 
-    public function testStorageWritesToSessionSuperglobal()
+    public function testStorageWritesToSessionSuperglobal(): void
     {
         $this->storage['foo'] = 'bar';
-        $this->assertSame($_SESSION['foo'], $this->storage->foo);
+        self::assertSame($_SESSION['foo'], $this->storage->foo);
         unset($this->storage['foo']);
-        $this->assertArrayNotHasKey('foo', $_SESSION);
+        self::assertArrayNotHasKey('foo', $_SESSION);
     }
 
-    public function testPassingArrayToConstructorOverwritesSessionSuperglobal()
+    public function testPassingArrayToConstructorOverwritesSessionSuperglobal(): void
     {
         $_SESSION['foo'] = 'bar';
-        $array   = ['foo' => 'FOO'];
-        $storage = new SessionArrayStorage($array);
-        $expected = [
-            'foo' => 'FOO',
+        $array           = ['foo' => 'FOO'];
+        $storage         = new SessionArrayStorage($array);
+        $expected        = [
+            'foo'       => 'FOO',
             '__Laminas' => [
                 '_REQUEST_ACCESS_TIME' => $storage->getRequestAccessTime(),
             ],
         ];
-        $this->assertSame($expected, $_SESSION);
+        self::assertSame($expected, $_SESSION);
     }
 
-    public function testModifyingSessionSuperglobalDirectlyUpdatesStorage()
+    public function testModifyingSessionSuperglobalDirectlyUpdatesStorage(): void
     {
         $_SESSION['foo'] = 'bar';
-        $this->assertTrue(isset($this->storage['foo']));
+        self::assertTrue(isset($this->storage['foo']));
     }
 
-    public function testDestructorSetsSessionToArray()
+    public function testDestructorSetsSessionToArray(): void
     {
         $this->storage->foo = 'bar';
-        $expected = [
+        $expected           = [
             '__Laminas' => [
                 '_REQUEST_ACCESS_TIME' => $this->storage->getRequestAccessTime(),
             ],
-            'foo' => 'bar',
+            'foo'       => 'bar',
         ];
         $this->storage->__destruct();
-        $this->assertSame($expected, $_SESSION);
+        self::assertSame($expected, $_SESSION);
     }
 
-    public function testModifyingOneSessionObjectModifiesTheOther()
+    public function testModifyingOneSessionObjectModifiesTheOther(): void
     {
         $this->storage->foo = 'bar';
-        $storage = new SessionArrayStorage();
-        $storage->bar = 'foo';
-        $this->assertEquals('foo', $this->storage->bar);
+        $storage            = new SessionArrayStorage();
+        $storage->bar       = 'foo';
+        self::assertEquals('foo', $this->storage->bar);
     }
 
-    public function testMarkingOneSessionObjectImmutableShouldMarkOtherInstancesImmutable()
+    public function testMarkingOneSessionObjectImmutableShouldMarkOtherInstancesImmutable(): void
     {
         $this->storage->foo = 'bar';
-        $storage = new SessionArrayStorage();
-        $this->assertEquals('bar', $storage['foo']);
+        $storage            = new SessionArrayStorage();
+        self::assertEquals('bar', $storage['foo']);
         $this->storage->markImmutable();
-        $this->assertTrue($storage->isImmutable(), var_export($_SESSION, 1));
+        self::assertTrue($storage->isImmutable(), var_export($_SESSION, 1));
     }
 
-    public function testAssignment()
+    public function testAssignment(): void
     {
         $_SESSION['foo'] = 'bar';
-        $this->assertEquals('bar', $this->storage['foo']);
+        self::assertEquals('bar', $this->storage['foo']);
     }
 
-    public function testMultiDimensionalAssignment()
+    public function testMultiDimensionalAssignment(): void
     {
         $_SESSION['foo']['bar'] = 'baz';
-        $this->assertEquals('baz', $this->storage['foo']['bar']);
+        self::assertEquals('baz', $this->storage['foo']['bar']);
     }
 
-    public function testUnset()
+    public function testUnset(): void
     {
         $_SESSION['foo'] = 'bar';
         unset($_SESSION['foo']);
-        $this->assertFalse(isset($this->storage['foo']));
+        self::assertFalse(isset($this->storage['foo']));
     }
 
-    public function testMultiDimensionalUnset()
+    public function testMultiDimensionalUnset(): void
     {
         $this->storage['foo'] = ['bar' => ['baz' => 'boo']];
         unset($this->storage['foo']['bar']['baz']);
-        $this->assertFalse(isset($this->storage['foo']['bar']['baz']));
+        self::assertFalse(isset($this->storage['foo']['bar']['baz']));
         unset($this->storage['foo']['bar']);
-        $this->assertFalse(isset($this->storage['foo']['bar']));
+        self::assertFalse(isset($this->storage['foo']['bar']));
     }
 
-    public function testSessionWorksWithContainer()
+    public function testSessionWorksWithContainer(): void
     {
         // Run without any validators; session ID is often invalid in CLI
-        $container = new Container(
+        $container      = new Container(
             'test',
             new SessionManager(null, null, null, [], ['attach_default_validators' => false])
         );
         $container->foo = 'bar';
 
-        $this->assertSame($container->foo, $_SESSION['test']['foo']);
+        self::assertSame($container->foo, $_SESSION['test']['foo']);
     }
 
-    public function testToArrayWithMetaData()
+    public function testToArrayWithMetaData(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->bar = 'baz';
@@ -135,35 +135,35 @@ public function testToArrayWithMetaData()
         $expected = [
             '__Laminas' => [
                 '_REQUEST_ACCESS_TIME' => $this->storage->getRequestAccessTime(),
-                'foo' => 'bar',
+                'foo'                  => 'bar',
             ],
-            'foo' => 'bar',
-            'bar' => 'baz',
+            'foo'       => 'bar',
+            'bar'       => 'baz',
         ];
-        $this->assertSame($expected, $this->storage->toArray(true));
+        self::assertSame($expected, $this->storage->toArray(true));
     }
 
-    public function testUndefinedSessionManipulation()
+    public function testUndefinedSessionManipulation(): void
     {
-        $this->storage['foo'] = 'bar';
-        $this->storage['bar'][] = 'bar';
+        $this->storage['foo']        = 'bar';
+        $this->storage['bar'][]      = 'bar';
         $this->storage['baz']['foo'] = 'bar';
 
         $expected = [
             '__Laminas' => [
                 '_REQUEST_ACCESS_TIME' => $this->storage->getRequestAccessTime(),
             ],
-            'foo' => 'bar',
-            'bar' => ['bar'],
-            'baz' => ['foo' => 'bar'],
+            'foo'       => 'bar',
+            'bar'       => ['bar'],
+            'baz'       => ['foo' => 'bar'],
         ];
-        $this->assertSame($expected, $this->storage->toArray(true));
+        self::assertSame($expected, $this->storage->toArray(true));
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testExpirationHops()
+    public function testExpirationHops(): void
     {
         // since we cannot explicitly test reinitializing the session
         // we will act in how session manager would in this case.
@@ -171,37 +171,37 @@ public function testExpirationHops()
         $manager = new SessionManager(null, $storage);
         $manager->start();
 
-        $container = new Container('test');
+        $container      = new Container('test');
         $container->foo = 'bar';
         $container->setExpirationHops(1);
 
         $copy = $_SESSION;
         $_SESSION = null;
         $storage->init($copy);
-        $this->assertEquals('bar', $container->foo);
+        self::assertEquals('bar', $container->foo);
 
         $copy = $_SESSION;
         $_SESSION = null;
         $storage->init($copy);
-        $this->assertNull($container->foo);
+        self::assertNull($container->foo);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testPreserveRequestAccessTimeAfterStart()
+    public function testPreserveRequestAccessTimeAfterStart(): void
     {
         $manager = new SessionManager(null, $this->storage);
-        $this->assertGreaterThan(0, $this->storage->getRequestAccessTime());
+        self::assertGreaterThan(0, $this->storage->getRequestAccessTime());
         $manager->start();
-        $this->assertGreaterThan(0, $this->storage->getRequestAccessTime());
+        self::assertGreaterThan(0, $this->storage->getRequestAccessTime());
     }
 
-    public function testGetArrayCopyFromContainer()
+    public function testGetArrayCopyFromContainer(): void
     {
-        $container = new Container('test');
+        $container      = new Container('test');
         $container->foo = 'bar';
         $container->baz = 'qux';
-        $this->assertSame(['foo' => 'bar', 'baz' => 'qux'], $container->getArrayCopy());
+        self::assertSame(['foo' => 'bar', 'baz' => 'qux'], $container->getArrayCopy());
     }
 }
diff --git a/test/SessionManagerTest.php b/test/SessionManagerTest.php
index 9c4a80db..f7417c35 100644
--- a/test/SessionManagerTest.php
+++ b/test/SessionManagerTest.php
@@ -22,6 +22,7 @@
 use Laminas\Session\Validator\Id;
 use Laminas\Session\Validator\RemoteAddr;
 use PHPUnit\Framework\TestCase;
+use Prophecy\PhpUnit\ProphecyTrait;
 
 /**
  * @preserveGlobalState disabled
@@ -29,6 +30,9 @@
  */
 class SessionManagerTest extends TestCase
 {
+    use ProphecyTrait;
+    use ReflectionPropertyTrait;
+
     public $error;
 
     public $cookieDateFormat = 'D, d-M-y H:i:s e';
@@ -38,12 +42,12 @@ class SessionManagerTest extends TestCase
      */
     protected $manager;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->error = false;
     }
 
-    public function handleErrors($errno, $errstr)
+    public function handleErrors($errno, $errstr): void
     {
         $this->error = $errstr;
     }
@@ -57,74 +61,74 @@ public function getTimestampFromCookie($cookie)
         return false;
     }
 
-    public function testManagerUsesSessionConfigByDefault()
+    public function testManagerUsesSessionConfigByDefault(): void
     {
         $this->manager = new SessionManager();
-        $config = $this->manager->getConfig();
-        $this->assertInstanceOf(SessionConfig::class, $config);
+        $config        = $this->manager->getConfig();
+        self::assertInstanceOf(SessionConfig::class, $config);
     }
 
-    public function testCanPassConfigurationToConstructor()
+    public function testCanPassConfigurationToConstructor(): void
     {
         $this->manager = new SessionManager();
-        $config = new StandardConfig();
-        $manager = new SessionManager($config);
-        $this->assertSame($config, $manager->getConfig());
+        $config        = new StandardConfig();
+        $manager       = new SessionManager($config);
+        self::assertSame($config, $manager->getConfig());
     }
 
-    public function testManagerUsesSessionStorageByDefault()
+    public function testManagerUsesSessionStorageByDefault(): void
     {
         $this->manager = new SessionManager();
-        $storage = $this->manager->getStorage();
-        $this->assertInstanceOf(SessionArrayStorage::class, $storage);
+        $storage       = $this->manager->getStorage();
+        self::assertInstanceOf(SessionArrayStorage::class, $storage);
     }
 
-    public function testCanPassStorageToConstructor()
+    public function testCanPassStorageToConstructor(): void
     {
         $storage = new ArrayStorage();
         $manager = new SessionManager(null, $storage);
-        $this->assertSame($storage, $manager->getStorage());
+        self::assertSame($storage, $manager->getStorage());
     }
 
-    public function testCanPassSaveHandlerToConstructor()
+    public function testCanPassSaveHandlerToConstructor(): void
     {
         $saveHandler = new TestAsset\TestSaveHandler();
-        $manager = new SessionManager(null, null, $saveHandler);
-        $this->assertSame($saveHandler, $manager->getSaveHandler());
+        $manager     = new SessionManager(null, null, $saveHandler);
+        self::assertSame($saveHandler, $manager->getSaveHandler());
     }
 
-    public function testCanPassValidatorsToConstructor()
+    public function testCanPassValidatorsToConstructor(): void
     {
         $validators = [
             'foo',
             'bar',
         ];
-        $manager = new SessionManager(null, null, null, $validators);
+        $manager    = new SessionManager(null, null, null, $validators);
         foreach ($validators as $validator) {
             $this->assertAttributeContains($validator, 'validators', $manager);
         }
     }
 
-    public function testAttachDefaultValidatorsByDefault()
+    public function testAttachDefaultValidatorsByDefault(): void
     {
         $manager = new SessionManager();
         $this->assertAttributeEquals([Id::class], 'validators', $manager);
     }
 
-    public function testCanMergeValidatorsWithDefault()
+    public function testCanMergeValidatorsWithDefault(): void
     {
         $defaultValidators = [
             Id::class,
         ];
-        $validators = [
+        $validators        = [
             'foo',
             'bar',
         ];
-        $manager = new SessionManager(null, null, null, $validators);
+        $manager           = new SessionManager(null, null, null, $validators);
         $this->assertAttributeEquals(array_merge($defaultValidators, $validators), 'validators', $manager);
     }
 
-    public function testCanDisableAttachDefaultValidators()
+    public function testCanDisableAttachDefaultValidators(): void
     {
         $options = [
             'attach_default_validators' => false,
@@ -138,59 +142,59 @@ public function testCanDisableAttachDefaultValidators()
     /**
      * @runInSeparateProcess
      */
-    public function testSessionExistsReturnsFalseWhenNoSessionStarted()
+    public function testSessionExistsReturnsFalseWhenNoSessionStarted(): void
     {
         $this->manager = new SessionManager();
-        $this->assertFalse($this->manager->sessionExists());
+        self::assertFalse($this->manager->sessionExists());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testSessionExistsReturnsTrueWhenSessionStarted()
+    public function testSessionExistsReturnsTrueWhenSessionStarted(): void
     {
         $this->manager = new SessionManager();
         session_start();
-        $this->assertTrue($this->manager->sessionExists());
+        self::assertTrue($this->manager->sessionExists());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testSessionExistsReturnsTrueWhenSessionStartedThenWritten()
+    public function testSessionExistsReturnsTrueWhenSessionStartedThenWritten(): void
     {
         $this->manager = new SessionManager();
         session_start();
         session_write_close();
-        $this->assertTrue($this->manager->sessionExists());
+        self::assertTrue($this->manager->sessionExists());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testSessionExistsReturnsFalseWhenSessionStartedThenDestroyed()
+    public function testSessionExistsReturnsFalseWhenSessionStartedThenDestroyed(): void
     {
         $this->manager = new SessionManager();
         session_start();
         session_destroy();
-        $this->assertFalse($this->manager->sessionExists());
+        self::assertFalse($this->manager->sessionExists());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testSessionIsStartedAfterCallingStart()
+    public function testSessionIsStartedAfterCallingStart(): void
     {
         $this->manager = new SessionManager();
-        $this->assertFalse($this->manager->sessionExists());
+        self::assertFalse($this->manager->sessionExists());
         $this->manager->start();
-        $this->assertTrue($this->manager->sessionExists());
+        self::assertTrue($this->manager->sessionExists());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testStartDoesNothingWhenCalledAfterWriteCloseOperation()
+    public function testStartDoesNothingWhenCalledAfterWriteCloseOperation(): void
     {
         $this->manager = new SessionManager();
         $this->manager->start();
@@ -198,47 +202,47 @@ public function testStartDoesNothingWhenCalledAfterWriteCloseOperation()
         session_write_close();
         $this->manager->start();
         $id2 = session_id();
-        $this->assertTrue($this->manager->sessionExists());
-        $this->assertEquals($id1, $id2);
+        self::assertTrue($this->manager->sessionExists());
+        self::assertEquals($id1, $id2);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testStartWithOldTraversableSessionData()
+    public function testStartWithOldTraversableSessionData(): void
     {
         // pre-populate session with data
         $_SESSION['key1'] = 'value1';
         $_SESSION['key2'] = 'value2';
-        $storage = new SessionStorage();
+        $storage          = new SessionStorage();
         // create session manager with SessionStorage that will populate object with existing session array
         $manager = new SessionManager(null, $storage);
-        $this->assertFalse($manager->sessionExists());
+        self::assertFalse($manager->sessionExists());
         $manager->start();
-        $this->assertTrue($manager->sessionExists());
-        $this->assertInstanceOf('\Traversable', $_SESSION);
-        $this->assertEquals('value1', $_SESSION->key1);
-        $this->assertEquals('value2', $_SESSION->key2);
+        self::assertTrue($manager->sessionExists());
+        self::assertInstanceOf('\Traversable', $_SESSION);
+        self::assertEquals('value1', $_SESSION->key1);
+        self::assertEquals('value2', $_SESSION->key2);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testStorageContentIsPreservedByWriteCloseOperation()
+    public function testStorageContentIsPreservedByWriteCloseOperation(): void
     {
         $this->manager = new SessionManager();
         $this->manager->start();
-        $storage = $this->manager->getStorage();
+        $storage        = $this->manager->getStorage();
         $storage['foo'] = 'bar';
         $this->manager->writeClose();
-        $this->assertArrayHasKey('foo', $storage);
-        $this->assertEquals('bar', $storage['foo']);
+        self::assertArrayHasKey('foo', $storage);
+        self::assertEquals('bar', $storage['foo']);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testStartCreatesNewSessionIfPreviousSessionHasBeenDestroyed()
+    public function testStartCreatesNewSessionIfPreviousSessionHasBeenDestroyed(): void
     {
         $this->manager = new SessionManager();
         $this->manager->start();
@@ -246,14 +250,14 @@ public function testStartCreatesNewSessionIfPreviousSessionHasBeenDestroyed()
         session_destroy();
         $this->manager->start();
         $id2 = session_id();
-        $this->assertTrue($this->manager->sessionExists());
-        $this->assertNotEquals($id1, $id2);
+        self::assertTrue($this->manager->sessionExists());
+        self::assertNotEquals($id1, $id2);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testStartConvertsSessionDataFromStorageInterfaceToArrayBeforeMerging()
+    public function testStartConvertsSessionDataFromStorageInterfaceToArrayBeforeMerging(): void
     {
         $this->manager = new SessionManager();
 
@@ -265,15 +269,15 @@ public function testStartConvertsSessionDataFromStorageInterfaceToArrayBeforeMer
 
         $this->manager->start();
 
-        $this->assertInternalType('array', $_SESSION);
-        $this->assertArrayHasKey($key, $_SESSION);
-        $this->assertSame($data[$key], $_SESSION[$key]);
+        self::assertIsArray($_SESSION);
+        self::assertArrayHasKey($key, $_SESSION);
+        self::assertSame($data[$key], $_SESSION[$key]);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testStartConvertsSessionDataFromTraversableToArrayBeforeMerging()
+    public function testStartConvertsSessionDataFromTraversableToArrayBeforeMerging(): void
     {
         $this->manager = new SessionManager();
 
@@ -283,43 +287,43 @@ public function testStartConvertsSessionDataFromTraversableToArrayBeforeMerging(
 
         $this->manager->start();
 
-        $this->assertInternalType('array', $_SESSION);
-        $this->assertArrayHasKey($key, $_SESSION);
-        $this->assertSame($data[$key], $_SESSION[$key]);
+        self::assertIsArray($_SESSION);
+        self::assertArrayHasKey($key, $_SESSION);
+        self::assertSame($data[$key], $_SESSION[$key]);
     }
 
     /**
      * @outputBuffering disabled
      */
-    public function testStartWillNotBlockHeaderSentNotices()
+    public function testStartWillNotBlockHeaderSentNotices(): void
     {
         $this->manager = new SessionManager();
         if ('cli' == PHP_SAPI) {
-            $this->markTestSkipped('session_start() will not raise headers_sent warnings in CLI');
+            self::markTestSkipped('session_start() will not raise headers_sent warnings in CLI');
         }
         set_error_handler([$this, 'handleErrors'], E_WARNING);
         echo ' ';
-        $this->assertTrue(headers_sent());
+        self::assertTrue(headers_sent());
         $this->manager->start();
         restore_error_handler();
-        $this->assertInternalType('string', $this->error);
-        $this->assertContains('already sent', $this->error);
+        self::assertIsString($this->error);
+        self::assertContains('already sent', $this->error);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testGetNameReturnsSessionName()
+    public function testGetNameReturnsSessionName(): void
     {
         $this->manager = new SessionManager();
-        $ini = ini_get('session.name');
-        $this->assertEquals($ini, $this->manager->getName());
+        $ini           = ini_get('session.name');
+        self::assertEquals($ini, $this->manager->getName());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testSetNameRaisesExceptionOnInvalidName()
+    public function testSetNameRaisesExceptionOnInvalidName(): void
     {
         $this->manager = new SessionManager();
         $this->expectException(InvalidArgumentException::class);
@@ -330,31 +334,31 @@ public function testSetNameRaisesExceptionOnInvalidName()
     /**
      * @runInSeparateProcess
      */
-    public function testSetNameSetsSessionNameOnSuccess()
+    public function testSetNameSetsSessionNameOnSuccess(): void
     {
         $this->manager = new SessionManager();
         $this->manager->setName('foobar');
-        $this->assertEquals('foobar', $this->manager->getName());
-        $this->assertEquals('foobar', session_name());
+        self::assertEquals('foobar', $this->manager->getName());
+        self::assertEquals('foobar', session_name());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testCanSetNewSessionNameAfterSessionDestroyed()
+    public function testCanSetNewSessionNameAfterSessionDestroyed(): void
     {
         $this->manager = new SessionManager();
         $this->manager->start();
         session_destroy();
         $this->manager->setName('foobar');
-        $this->assertEquals('foobar', $this->manager->getName());
-        $this->assertEquals('foobar', session_name());
+        self::assertEquals('foobar', $this->manager->getName());
+        self::assertEquals('foobar', session_name());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testSettingNameWhenAnActiveSessionExistsRaisesException()
+    public function testSettingNameWhenAnActiveSessionExistsRaisesException(): void
     {
         $this->manager = new SessionManager();
         $this->expectException(InvalidArgumentException::class);
@@ -366,14 +370,14 @@ public function testSettingNameWhenAnActiveSessionExistsRaisesException()
     /**
      * @runInSeparateProcess
      */
-    public function testDestroyByDefaultSendsAnExpireCookie()
+    public function testDestroyByDefaultSendsAnExpireCookie(): void
     {
         if (! extension_loaded('xdebug')) {
-            $this->markTestSkipped('Xdebug required for this test');
+            self::markTestSkipped('Xdebug required for this test');
         }
 
         $this->manager = new SessionManager();
-        $config = $this->manager->getConfig();
+        $config        = $this->manager->getConfig();
         $config->setUseCookies(true);
         $this->manager->start();
         $this->manager->destroy();
@@ -390,20 +394,20 @@ public function testDestroyByDefaultSendsAnExpireCookie()
             }
         }
 
-        $this->assertTrue($found, 'No session cookie found: ' . var_export($headers, true));
+        self::assertTrue($found, 'No session cookie found: ' . var_export($headers, true));
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testSendingFalseToSendExpireCookieWhenCallingDestroyShouldNotSendCookie()
+    public function testSendingFalseToSendExpireCookieWhenCallingDestroyShouldNotSendCookie(): void
     {
         if (! extension_loaded('xdebug')) {
-            $this->markTestSkipped('Xdebug required for this test');
+            self::markTestSkipped('Xdebug required for this test');
         }
 
         $this->manager = new SessionManager();
-        $config = $this->manager->getConfig();
+        $config        = $this->manager->getConfig();
         $config->setUseCookies(true);
         $this->manager->start();
         $this->manager->destroy(['send_expire_cookie' => false]);
@@ -421,91 +425,94 @@ public function testSendingFalseToSendExpireCookieWhenCallingDestroyShouldNotSen
         }
 
         if ($found) {
-            $this->assertNotContains('expires=', $header);
+            self::assertStringNotContainsString('expires=', $header);
         } else {
-            $this->assertFalse($found, 'Unexpected session cookie found: ' . var_export($headers, true));
+            self::assertFalse($found, 'Unexpected session cookie found: ' . var_export($headers, true));
         }
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testDestroyDoesNotClearSessionStorageByDefault()
+    public function testDestroyDoesNotClearSessionStorageByDefault(): void
     {
         $this->manager = new SessionManager();
         $this->manager->start();
-        $storage = $this->manager->getStorage();
+        $storage        = $this->manager->getStorage();
         $storage['foo'] = 'bar';
         $this->manager->destroy();
-        $this->assertTrue(isset($storage['foo']));
-        $this->assertEquals('bar', $storage['foo']);
+        self::assertTrue(isset($storage['foo']));
+        self::assertEquals('bar', $storage['foo']);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testPassingClearStorageOptionWhenCallingDestroyClearsStorage()
+    public function testPassingClearStorageOptionWhenCallingDestroyClearsStorage(): void
     {
         $this->manager = new SessionManager();
         $this->manager->start();
-        $storage = $this->manager->getStorage();
+        $storage        = $this->manager->getStorage();
         $storage['foo'] = 'bar';
         $this->manager->destroy(['clear_storage' => true]);
-        $this->assertFalse(isset($storage['foo']));
+        self::assertFalse(isset($storage['foo']));
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testCallingWriteCloseMarksStorageAsImmutable()
+    public function testCallingWriteCloseMarksStorageAsImmutable(): void
     {
         $this->manager = new SessionManager();
         $this->manager->start();
-        $storage = $this->manager->getStorage();
+        $storage        = $this->manager->getStorage();
         $storage['foo'] = 'bar';
         $this->manager->writeClose();
-        $this->assertTrue($storage->isImmutable());
+        self::assertTrue($storage->isImmutable());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testCallingWriteCloseShouldNotAlterSessionExistsStatus()
+    public function testCallingWriteCloseShouldNotAlterSessionExistsStatus(): void
     {
         $this->manager = new SessionManager();
         $this->manager->start();
         $this->manager->writeClose();
-        $this->assertTrue($this->manager->sessionExists());
+        self::assertTrue($this->manager->sessionExists());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testIdShouldBeEmptyPriorToCallingStart()
+    public function testIdShouldBeEmptyPriorToCallingStart(): void
     {
         $this->manager = new SessionManager();
-        $this->assertSame('', $this->manager->getId());
+        self::assertSame('', $this->manager->getId());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testIdShouldBeMutablePriorToCallingStart()
+    public function testIdShouldBeMutablePriorToCallingStart(): void
     {
         $this->manager = new SessionManager();
         $this->manager->setId(__CLASS__);
-        $this->assertSame(__CLASS__, $this->manager->getId());
-        $this->assertSame(__CLASS__, session_id());
+        self::assertSame(__CLASS__, $this->manager->getId());
+        self::assertSame(__CLASS__, session_id());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testIdShouldNotBeMutableAfterSessionStarted()
+    public function testIdShouldNotBeMutableAfterSessionStarted(): void
     {
         $this->manager = new SessionManager();
-        $this->expectException(RuntimeException::class, 'Session has already been started);
-        $this->expectExceptionMessage(to change the session ID call regenerateId()');
+        $this->expectException(
+            RuntimeException::class,
+            'Session has already been started);
+        $this->expectExceptionMessage(to change the session ID call regenerateId()'
+        );
         $this->manager->start();
         $origId = $this->manager->getId();
         $this->manager->setId(__METHOD__);
@@ -514,38 +521,38 @@ public function testIdShouldNotBeMutableAfterSessionStarted()
     /**
      * @runInSeparateProcess
      */
-    public function testRegenerateIdShouldWorkAfterSessionStarted()
+    public function testRegenerateIdShouldWorkAfterSessionStarted(): void
     {
         $this->manager = new SessionManager();
         $this->manager->start();
         $origId = $this->manager->getId();
         $this->manager->regenerateId();
-        $this->assertNotSame($origId, $this->manager->getId());
+        self::assertNotSame($origId, $this->manager->getId());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testRegenerateIdDoesNothingWhenSessioIsNotStarted()
+    public function testRegenerateIdDoesNothingWhenSessioIsNotStarted(): void
     {
         $this->manager = new SessionManager();
-        $origId = $this->manager->getId();
+        $origId        = $this->manager->getId();
         $this->manager->regenerateId();
-        $this->assertEquals($origId, $this->manager->getId());
-        $this->assertEquals('', $this->manager->getId());
+        self::assertEquals($origId, $this->manager->getId());
+        self::assertEquals('', $this->manager->getId());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testRegeneratingIdAfterSessionStartedShouldSendExpireCookie()
+    public function testRegeneratingIdAfterSessionStartedShouldSendExpireCookie(): void
     {
         if (! extension_loaded('xdebug')) {
-            $this->markTestSkipped('Xdebug required for this test');
+            self::markTestSkipped('Xdebug required for this test');
         }
 
         $this->manager = new SessionManager();
-        $config = $this->manager->getConfig();
+        $config        = $this->manager->getConfig();
         $config->setUseCookies(true);
         $this->manager->start();
         $origId = $this->manager->getId();
@@ -561,20 +568,20 @@ public function testRegeneratingIdAfterSessionStartedShouldSendExpireCookie()
             }
         }
 
-        $this->assertTrue($found, 'No session cookie found: ' . var_export($headers, true));
+        self::assertTrue($found, 'No session cookie found: ' . var_export($headers, true));
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testRememberMeShouldSendNewSessionCookieWithUpdatedTimestamp()
+    public function testRememberMeShouldSendNewSessionCookieWithUpdatedTimestamp(): void
     {
         if (! extension_loaded('xdebug')) {
-            $this->markTestSkipped('Xdebug required for this test');
+            self::markTestSkipped('Xdebug required for this test');
         }
 
         $this->manager = new SessionManager();
-        $config = $this->manager->getConfig();
+        $config        = $this->manager->getConfig();
         $config->setUseCookies(true);
         $this->manager->start();
         $this->manager->rememberMe(18600);
@@ -591,14 +598,14 @@ public function testRememberMeShouldSendNewSessionCookieWithUpdatedTimestamp()
             }
         }
 
-        $this->assertTrue($found, 'No session cookie found: ' . var_export($headers, true));
+        self::assertTrue($found, 'No session cookie found: ' . var_export($headers, true));
 
         $ts = $this->getTimestampFromCookie($cookie);
         if (! $ts) {
-            $this->fail('Cookie did not contain expiry? ' . var_export($headers, true));
+            self::fail('Cookie did not contain expiry? ' . var_export($headers, true));
         }
 
-        $this->assertGreaterThan(
+        self::assertGreaterThan(
             $_SERVER['REQUEST_TIME'],
             $ts->getTimestamp(),
             'Session cookie: ' . var_export($headers, 1)
@@ -608,14 +615,14 @@ public function testRememberMeShouldSendNewSessionCookieWithUpdatedTimestamp()
     /**
      * @runInSeparateProcess
      */
-    public function testRememberMeShouldSetTimestampBasedOnConfigurationByDefault()
+    public function testRememberMeShouldSetTimestampBasedOnConfigurationByDefault(): void
     {
         if (! extension_loaded('xdebug')) {
-            $this->markTestSkipped('Xdebug required for this test');
+            self::markTestSkipped('Xdebug required for this test');
         }
 
         $this->manager = new SessionManager();
-        $config = $this->manager->getConfig();
+        $config        = $this->manager->getConfig();
         $config->setUseCookies(true);
         $config->setRememberMeSeconds(3600);
         $ttl = $config->getRememberMeSeconds();
@@ -634,29 +641,29 @@ public function testRememberMeShouldSetTimestampBasedOnConfigurationByDefault()
             }
         }
 
-        $this->assertTrue($found, 'No session cookie found: ' . var_export($headers, true));
+        self::assertTrue($found, 'No session cookie found: ' . var_export($headers, true));
 
         $ts = $this->getTimestampFromCookie($cookie);
         if (! $ts) {
-            $this->fail('Cookie did not contain expiry? ' . var_export($headers, true));
+            self::fail('Cookie did not contain expiry? ' . var_export($headers, true));
         }
 
         $compare  = $_SERVER['REQUEST_TIME'] + $ttl;
         $cookieTs = $ts->getTimestamp();
-        $this->assertContains($cookieTs, range($compare, $compare + 10), 'Session cookie: ' . var_export($headers, 1));
+        self::assertContains($cookieTs, range($compare, $compare + 10), 'Session cookie: ' . var_export($headers, 1));
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testForgetMeShouldSendCookieWithZeroTimestamp()
+    public function testForgetMeShouldSendCookieWithZeroTimestamp(): void
     {
         if (! extension_loaded('xdebug')) {
-            $this->markTestSkipped('Xdebug required for this test');
+            self::markTestSkipped('Xdebug required for this test');
         }
 
         $this->manager = new SessionManager();
-        $config = $this->manager->getConfig();
+        $config        = $this->manager->getConfig();
         $config->setUseCookies(true);
         $this->manager->start();
         $this->manager->forgetMe();
@@ -671,17 +678,17 @@ public function testForgetMeShouldSendCookieWithZeroTimestamp()
             }
         }
 
-        $this->assertTrue($found, 'No session cookie found: ' . var_export($headers, true));
-        $this->assertNotContains('expires=', $header);
+        self::assertTrue($found, 'No session cookie found: ' . var_export($headers, true));
+        self::assertStringNotContainsString('expires=', $header);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testStartingSessionThatFailsAValidatorShouldRaiseException()
+    public function testStartingSessionThatFailsAValidatorShouldRaiseException(): void
     {
         $this->manager = new SessionManager();
-        $chain = $this->manager->getValidatorChain();
+        $chain         = $this->manager->getValidatorChain();
         $chain->attach('session.validate', [new TestAsset\TestFailingValidator(), 'isValid']);
         $this->expectException(RuntimeException::class);
         $this->expectExceptionMessage('failed');
@@ -691,10 +698,10 @@ public function testStartingSessionThatFailsAValidatorShouldRaiseException()
     /**
      * @runInSeparateProcess
      */
-    public function testResumeSessionThatFailsAValidatorShouldRaiseException()
+    public function testResumeSessionThatFailsAValidatorShouldRaiseException(): void
     {
         $this->manager = new SessionManager();
-        $this->manager->setSaveHandler(new TestAsset\TestSaveHandlerWithValidator);
+        $this->manager->setSaveHandler(new TestAsset\TestSaveHandlerWithValidator());
         $this->expectException(RuntimeException::class);
         $this->expectExceptionMessage('failed');
         $this->manager->start();
@@ -703,7 +710,7 @@ public function testResumeSessionThatFailsAValidatorShouldRaiseException()
     /**
      * @runInSeparateProcess
      */
-    public function testSessionWriteCloseStoresMetadata()
+    public function testSessionWriteCloseStoresMetadata(): void
     {
         $this->manager = new SessionManager();
         $this->manager->start();
@@ -711,62 +718,62 @@ public function testSessionWriteCloseStoresMetadata()
         $storage->setMetadata('foo', 'bar');
         $metaData = $storage->getMetadata();
         $this->manager->writeClose();
-        $this->assertSame($_SESSION['__Laminas'], $metaData);
+        self::assertSame($_SESSION['__Laminas'], $metaData);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testSessionValidationDoesNotHaltOnNoopListener()
+    public function testSessionValidationDoesNotHaltOnNoopListener(): void
     {
-        $this->manager = new SessionManager();
+        $this->manager   = new SessionManager();
         $validatorCalled = false;
-        $validator = function () use (& $validatorCalled) {
+        $validator       = function () use (& $validatorCalled) {
             $validatorCalled = true;
         };
 
         $this->manager->getValidatorChain()->attach('session.validate', $validator);
 
-        $this->assertTrue($this->manager->isValid());
-        $this->assertTrue($validatorCalled);
+        self::assertTrue($this->manager->isValid());
+        self::assertTrue($validatorCalled);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testProducedSessionManagerWillNotReplaceSessionSuperGlobalValues()
+    public function testProducedSessionManagerWillNotReplaceSessionSuperGlobalValues(): void
     {
-        $this->manager = new SessionManager();
+        $this->manager   = new SessionManager();
         $_SESSION['foo'] = 'bar';
 
         $this->manager->start();
 
-        $this->assertArrayHasKey('foo', $_SESSION);
-        $this->assertSame('bar', $_SESSION['foo']);
+        self::assertArrayHasKey('foo', $_SESSION);
+        self::assertSame('bar', $_SESSION['foo']);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testValidatorChainSessionMetadataIsPreserved()
+    public function testValidatorChainSessionMetadataIsPreserved(): void
     {
         $this->manager = new SessionManager();
         $this->manager->getValidatorChain()
             ->attach('session.validate', [new RemoteAddr(), 'isValid']);
 
-        $this->assertFalse($this->manager->sessionExists());
+        self::assertFalse($this->manager->sessionExists());
 
         $this->manager->start();
 
-        $this->assertInternalType('array', $_SESSION['__Laminas']['_VALID']);
-        $this->assertArrayHasKey(RemoteAddr::class, $_SESSION['__Laminas']['_VALID']);
-        $this->assertEquals('', $_SESSION['__Laminas']['_VALID'][RemoteAddr::class]);
+        self::assertIsArray($_SESSION['__Laminas']['_VALID']);
+        self::assertArrayHasKey(RemoteAddr::class, $_SESSION['__Laminas']['_VALID']);
+        self::assertEquals('', $_SESSION['__Laminas']['_VALID'][RemoteAddr::class]);
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testRemoteAddressValidationWillFailOnInvalidAddress()
+    public function testRemoteAddressValidationWillFailOnInvalidAddress(): void
     {
         $this->manager = new SessionManager();
         $this->manager->getValidatorChain()
@@ -780,10 +787,10 @@ public function testRemoteAddressValidationWillFailOnInvalidAddress()
     /**
      * @runInSeparateProcess
      */
-    public function testRemoteAddressValidationWillSucceedWithValidPreSetData()
+    public function testRemoteAddressValidationWillSucceedWithValidPreSetData(): void
     {
         $this->manager = new SessionManager();
-        $_SESSION = [
+        $_SESSION      = [
             '__Laminas' => [
                 '_VALID' => [
                     RemoteAddr::class => '',
@@ -793,16 +800,16 @@ public function testRemoteAddressValidationWillSucceedWithValidPreSetData()
 
         $this->manager->start();
 
-        $this->assertTrue($this->manager->isValid());
+        self::assertTrue($this->manager->isValid());
     }
 
     /**
      * @runInSeparateProcess
      */
-    public function testRemoteAddressValidationWillFailWithInvalidPreSetData()
+    public function testRemoteAddressValidationWillFailWithInvalidPreSetData(): void
     {
         $this->manager = new SessionManager();
-        $_SESSION = [
+        $_SESSION      = [
             '__Laminas' => [
                 '_VALID' => [
                     RemoteAddr::class => '123.123.123.123',
@@ -818,7 +825,7 @@ public function testRemoteAddressValidationWillFailWithInvalidPreSetData()
     /**
      * @runInSeparateProcess
      */
-    public function testIdValidationWillFailOnInvalidData()
+    public function testIdValidationWillFailOnInvalidData(): void
     {
         $this->manager = new SessionManager();
         $this->manager->getValidatorChain()
@@ -828,4 +835,22 @@ public function testIdValidationWillFailOnInvalidData()
         $this->expectExceptionMessage('Session validation failed');
         $this->manager->start();
     }
+
+    /**
+     * @param mixed $expected
+     */
+    private function assertAttributeEquals($expected, string $property, object $object): void
+    {
+        $value = $this->getReflectionProperty($object, $property);
+        self::assertEquals($expected, $value);
+    }
+
+    /**
+     * @param mixed $expected
+     */
+    private function assertAttributeContains($expected, string $property, object $object): void
+    {
+        $value = $this->getReflectionProperty($object, $property);
+        self::assertContains($expected, $value);
+    }
 }
diff --git a/test/SessionStorageTest.php b/test/SessionStorageTest.php
index 0bf5e45f..c2259ebe 100644
--- a/test/SessionStorageTest.php
+++ b/test/SessionStorageTest.php
@@ -16,87 +16,87 @@
  */
 class SessionStorageTest extends TestCase
 {
-    protected function setUp()
+    protected function setUp(): void
     {
-        $_SESSION = [];
-        $this->storage = new SessionStorage;
+        $_SESSION      = [];
+        $this->storage = new SessionStorage();
     }
 
-    protected function tearDown()
+    protected function tearDown(): void
     {
         $_SESSION = [];
     }
 
-    public function testSessionStorageInheritsFromArrayStorage()
+    public function testSessionStorageInheritsFromArrayStorage(): void
     {
-        $this->assertInstanceOf('Laminas\Session\Storage\SessionStorage', $this->storage);
-        $this->assertInstanceOf('Laminas\Session\Storage\ArrayStorage', $this->storage);
+        self::assertInstanceOf('Laminas\Session\Storage\SessionStorage', $this->storage);
+        self::assertInstanceOf('Laminas\Session\Storage\ArrayStorage', $this->storage);
     }
 
-    public function testStorageWritesToSessionSuperglobal()
+    public function testStorageWritesToSessionSuperglobal(): void
     {
         $this->storage['foo'] = 'bar';
-        $this->assertSame($_SESSION, $this->storage);
+        self::assertSame($_SESSION, $this->storage);
         unset($this->storage['foo']);
-        $this->assertArrayNotHasKey('foo', $_SESSION);
+        self::assertArrayNotHasKey('foo', $_SESSION);
     }
 
-    public function testPassingArrayToConstructorOverwritesSessionSuperglobal()
+    public function testPassingArrayToConstructorOverwritesSessionSuperglobal(): void
     {
         $_SESSION['foo'] = 'bar';
-        $array   = ['foo' => 'FOO'];
-        $storage = new SessionStorage($array);
-        $expected = [
-            'foo' => 'FOO',
+        $array           = ['foo' => 'FOO'];
+        $storage         = new SessionStorage($array);
+        $expected        = [
+            'foo'       => 'FOO',
             '__Laminas' => [
                 '_REQUEST_ACCESS_TIME' => $storage->getRequestAccessTime(),
             ],
         ];
-        $this->assertSame($expected, $_SESSION->getArrayCopy());
+        self::assertSame($expected, $_SESSION->getArrayCopy());
     }
 
-    public function testModifyingSessionSuperglobalDirectlyUpdatesStorage()
+    public function testModifyingSessionSuperglobalDirectlyUpdatesStorage(): void
     {
         $_SESSION['foo'] = 'bar';
-        $this->assertTrue(isset($this->storage['foo']));
+        self::assertTrue(isset($this->storage['foo']));
     }
 
-    public function testDestructorSetsSessionToArray()
+    public function testDestructorSetsSessionToArray(): void
     {
         $this->storage->foo = 'bar';
-        $expected = [
+        $expected           = [
             '__Laminas' => [
                 '_REQUEST_ACCESS_TIME' => $this->storage->getRequestAccessTime(),
             ],
-            'foo' => 'bar',
+            'foo'       => 'bar',
         ];
         $this->storage->__destruct();
-        $this->assertSame($expected, $_SESSION);
+        self::assertSame($expected, $_SESSION);
     }
 
-    public function testModifyingOneSessionObjectModifiesTheOther()
+    public function testModifyingOneSessionObjectModifiesTheOther(): void
     {
         $this->storage->foo = 'bar';
-        $storage = new SessionStorage();
-        $storage->bar = 'foo';
-        $this->assertEquals('foo', $this->storage->bar);
+        $storage            = new SessionStorage();
+        $storage->bar       = 'foo';
+        self::assertEquals('foo', $this->storage->bar);
     }
 
-    public function testMarkingOneSessionObjectImmutableShouldMarkOtherInstancesImmutable()
+    public function testMarkingOneSessionObjectImmutableShouldMarkOtherInstancesImmutable(): void
     {
         $this->storage->foo = 'bar';
-        $storage = new SessionStorage();
-        $this->assertEquals('bar', $storage['foo']);
+        $storage            = new SessionStorage();
+        self::assertEquals('bar', $storage['foo']);
         $this->storage->markImmutable();
-        $this->assertTrue($storage->isImmutable(), var_export($_SESSION, 1));
+        self::assertTrue($storage->isImmutable(), var_export($_SESSION, 1));
     }
 
-    public function testMultiDimensionalUnset()
+    public function testMultiDimensionalUnset(): void
     {
         $this->storage['foo'] = ['bar' => ['baz' => 'boo']];
         unset($this->storage['foo']['bar']['baz']);
-        $this->assertFalse(isset($this->storage['foo']['bar']['baz']));
+        self::assertFalse(isset($this->storage['foo']['bar']['baz']));
         unset($this->storage['foo']['bar']);
-        $this->assertFalse(isset($this->storage['foo']['bar']));
+        self::assertFalse(isset($this->storage['foo']['bar']));
     }
 }
diff --git a/test/StorageTest.php b/test/StorageTest.php
index 6d5cab4a..156c8364 100644
--- a/test/StorageTest.php
+++ b/test/StorageTest.php
@@ -21,52 +21,52 @@ class StorageTest extends TestCase
      */
     protected $storage;
 
-    protected function setUp()
+    protected function setUp(): void
     {
-        $this->storage = new ArrayStorage;
+        $this->storage = new ArrayStorage();
     }
 
-    public function testStorageAllowsArrayAccess()
+    public function testStorageAllowsArrayAccess(): void
     {
         $this->storage['foo'] = 'bar';
-        $this->assertTrue(isset($this->storage['foo']));
-        $this->assertEquals('bar', $this->storage['foo']);
+        self::assertTrue(isset($this->storage['foo']));
+        self::assertEquals('bar', $this->storage['foo']);
         unset($this->storage['foo']);
-        $this->assertFalse(isset($this->storage['foo']));
+        self::assertFalse(isset($this->storage['foo']));
     }
 
-    public function testStorageAllowsPropertyAccess()
+    public function testStorageAllowsPropertyAccess(): void
     {
         $this->storage->foo = 'bar';
-        $this->assertTrue(isset($this->storage->foo));
-        $this->assertEquals('bar', $this->storage->foo);
+        self::assertTrue(isset($this->storage->foo));
+        self::assertEquals('bar', $this->storage->foo);
         unset($this->storage->foo);
-        $this->assertFalse(isset($this->storage->foo));
+        self::assertFalse(isset($this->storage->foo));
     }
 
-    public function testStorageAllowsSettingMetadata()
+    public function testStorageAllowsSettingMetadata(): void
     {
         $this->storage->setMetadata('TEST', 'foo');
-        $this->assertEquals('foo', $this->storage->getMetadata('TEST'));
+        self::assertEquals('foo', $this->storage->getMetadata('TEST'));
     }
 
-    public function testSettingArrayMetadataMergesOnSubsequentRequests()
+    public function testSettingArrayMetadataMergesOnSubsequentRequests(): void
     {
         $this->storage->setMetadata('TEST', ['foo' => 'bar', 'bar' => 'baz']);
         $this->storage->setMetadata('TEST', ['foo' => 'baz', 'baz' => 'bat', 'lonesome']);
         $expected = ['foo' => 'baz', 'bar' => 'baz', 'baz' => 'bat', 'lonesome'];
-        $this->assertEquals($expected, $this->storage->getMetadata('TEST'));
+        self::assertEquals($expected, $this->storage->getMetadata('TEST'));
     }
 
-    public function testSettingArrayMetadataWithOverwriteFlagOverwritesExistingData()
+    public function testSettingArrayMetadataWithOverwriteFlagOverwritesExistingData(): void
     {
         $this->storage->setMetadata('TEST', ['foo' => 'bar', 'bar' => 'baz']);
         $this->storage->setMetadata('TEST', ['foo' => 'baz', 'baz' => 'bat', 'lonesome'], true);
         $expected = ['foo' => 'baz', 'baz' => 'bat', 'lonesome'];
-        $this->assertEquals($expected, $this->storage->getMetadata('TEST'));
+        self::assertEquals($expected, $this->storage->getMetadata('TEST'));
     }
 
-    public function testLockWithNoKeyMakesStorageReadOnly()
+    public function testLockWithNoKeyMakesStorageReadOnly(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->lock();
@@ -75,125 +75,125 @@ public function testLockWithNoKeyMakesStorageReadOnly()
         $this->storage->foo = 'baz';
     }
 
-    public function testLockWithNoKeyMarksEntireStorageLocked()
+    public function testLockWithNoKeyMarksEntireStorageLocked(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->bar = 'baz';
         $this->storage->lock();
-        $this->assertTrue($this->storage->isLocked());
-        $this->assertTrue($this->storage->isLocked('foo'));
-        $this->assertTrue($this->storage->isLocked('bar'));
+        self::assertTrue($this->storage->isLocked());
+        self::assertTrue($this->storage->isLocked('foo'));
+        self::assertTrue($this->storage->isLocked('bar'));
     }
 
-    public function testLockWithKeyMakesOnlyThatKeyReadOnly()
+    public function testLockWithKeyMakesOnlyThatKeyReadOnly(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->lock('foo');
 
         $this->storage->bar = 'baz';
-        $this->assertEquals('baz', $this->storage->bar);
+        self::assertEquals('baz', $this->storage->bar);
 
         $this->expectException('Laminas\Session\Exception\RuntimeException');
         $this->expectExceptionMessage('Cannot set key "foo" due to locking');
         $this->storage->foo = 'baz';
     }
 
-    public function testLockWithKeyMarksOnlyThatKeyLocked()
+    public function testLockWithKeyMarksOnlyThatKeyLocked(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->bar = 'baz';
         $this->storage->lock('foo');
-        $this->assertTrue($this->storage->isLocked('foo'));
-        $this->assertFalse($this->storage->isLocked('bar'));
+        self::assertTrue($this->storage->isLocked('foo'));
+        self::assertFalse($this->storage->isLocked('bar'));
     }
 
-    public function testLockWithNoKeyShouldWriteToMetadata()
+    public function testLockWithNoKeyShouldWriteToMetadata(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->lock();
         $locked = $this->storage->getMetadata('_READONLY');
-        $this->assertTrue($locked);
+        self::assertTrue($locked);
     }
 
-    public function testLockWithKeyShouldWriteToMetadata()
+    public function testLockWithKeyShouldWriteToMetadata(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->lock('foo');
         $locks = $this->storage->getMetadata('_LOCKS');
-        $this->assertInternalType('array', $locks);
-        $this->assertArrayHasKey('foo', $locks);
+        self::assertIsArray($locks);
+        self::assertArrayHasKey('foo', $locks);
     }
 
-    public function testUnlockShouldUnlockEntireObject()
+    public function testUnlockShouldUnlockEntireObject(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->bar = 'baz';
         $this->storage->lock();
         $this->storage->unlock();
-        $this->assertFalse($this->storage->isLocked('foo'));
-        $this->assertFalse($this->storage->isLocked('bar'));
+        self::assertFalse($this->storage->isLocked('foo'));
+        self::assertFalse($this->storage->isLocked('bar'));
     }
 
-    public function testUnlockShouldUnlockSelectivelyLockedKeys()
+    public function testUnlockShouldUnlockSelectivelyLockedKeys(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->bar = 'baz';
         $this->storage->lock('foo');
         $this->storage->unlock();
-        $this->assertFalse($this->storage->isLocked('foo'));
-        $this->assertFalse($this->storage->isLocked('bar'));
+        self::assertFalse($this->storage->isLocked('foo'));
+        self::assertFalse($this->storage->isLocked('bar'));
     }
 
-    public function testUnlockWithKeyShouldUnlockOnlyThatKey()
+    public function testUnlockWithKeyShouldUnlockOnlyThatKey(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->bar = 'baz';
         $this->storage->lock();
         $this->storage->unlock('foo');
-        $this->assertFalse($this->storage->isLocked('foo'));
-        $this->assertTrue($this->storage->isLocked('bar'));
+        self::assertFalse($this->storage->isLocked('foo'));
+        self::assertTrue($this->storage->isLocked('bar'));
     }
 
-    public function testUnlockWithKeyOfSelectiveLockShouldUnlockThatKey()
+    public function testUnlockWithKeyOfSelectiveLockShouldUnlockThatKey(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->lock('foo');
         $this->storage->unlock('foo');
-        $this->assertFalse($this->storage->isLocked('foo'));
+        self::assertFalse($this->storage->isLocked('foo'));
     }
 
-    public function testClearWithNoArgumentsRemovesExistingData()
+    public function testClearWithNoArgumentsRemovesExistingData(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->bar = 'baz';
 
         $this->storage->clear();
         $data = $this->storage->toArray();
-        $this->assertSame([], $data);
+        self::assertSame([], $data);
     }
 
-    public function testClearWithNoArgumentsRemovesExistingMetadata()
+    public function testClearWithNoArgumentsRemovesExistingMetadata(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->lock('foo');
         $this->storage->setMetadata('FOO', 'bar');
         $this->storage->clear();
 
-        $this->assertFalse($this->storage->isLocked('foo'));
-        $this->assertFalse($this->storage->getMetadata('FOO'));
+        self::assertFalse($this->storage->isLocked('foo'));
+        self::assertFalse($this->storage->getMetadata('FOO'));
     }
 
-    public function testClearWithArgumentRemovesExistingDataForThatKeyOnly()
+    public function testClearWithArgumentRemovesExistingDataForThatKeyOnly(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->bar = 'baz';
 
         $this->storage->clear('foo');
         $data = $this->storage->toArray();
-        $this->assertSame(['bar' => 'baz'], $data);
+        self::assertSame(['bar' => 'baz'], $data);
     }
 
-    public function testClearWithArgumentRemovesExistingMetadataForThatKeyOnly()
+    public function testClearWithArgumentRemovesExistingMetadataForThatKeyOnly(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->bar = 'baz';
@@ -203,13 +203,13 @@ public function testClearWithArgumentRemovesExistingMetadataForThatKeyOnly()
         $this->storage->setMetadata('bar', 'baz');
         $this->storage->clear('foo');
 
-        $this->assertFalse($this->storage->isLocked('foo'));
-        $this->assertTrue($this->storage->isLocked('bar'));
-        $this->assertFalse($this->storage->getMetadata('foo'));
-        $this->assertEquals('baz', $this->storage->getMetadata('bar'));
+        self::assertFalse($this->storage->isLocked('foo'));
+        self::assertTrue($this->storage->isLocked('bar'));
+        self::assertFalse($this->storage->getMetadata('foo'));
+        self::assertEquals('baz', $this->storage->getMetadata('bar'));
     }
 
-    public function testClearWhenStorageMarkedImmutableRaisesException()
+    public function testClearWhenStorageMarkedImmutableRaisesException(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->bar = 'baz';
@@ -219,14 +219,14 @@ public function testClearWhenStorageMarkedImmutableRaisesException()
         $this->storage->clear();
     }
 
-    public function testRequestAccessTimeIsPreservedEvenInFactoryMethod()
+    public function testRequestAccessTimeIsPreservedEvenInFactoryMethod(): void
     {
-        $this->assertNotEmpty($this->storage->getRequestAccessTime());
+        self::assertNotEmpty($this->storage->getRequestAccessTime());
         $this->storage->fromArray([]);
-        $this->assertNotEmpty($this->storage->getRequestAccessTime());
+        self::assertNotEmpty($this->storage->getRequestAccessTime());
     }
 
-    public function testToArrayWithMetaData()
+    public function testToArrayWithMetaData(): void
     {
         $this->storage->foo = 'bar';
         $this->storage->bar = 'baz';
@@ -234,20 +234,20 @@ public function testToArrayWithMetaData()
         $expected = [
             '__Laminas' => [
                 '_REQUEST_ACCESS_TIME' => $this->storage->getRequestAccessTime(),
-                'foo' => 'bar',
+                'foo'                  => 'bar',
             ],
-            'foo' => 'bar',
-            'bar' => 'baz',
+            'foo'       => 'bar',
+            'bar'       => 'baz',
         ];
-        $this->assertSame($expected, $this->storage->toArray(true));
+        self::assertSame($expected, $this->storage->toArray(true));
     }
 
-    public function testUnsetMultidimensional()
+    public function testUnsetMultidimensional(): void
     {
         $this->storage['foo'] = ['bar' => ['baz' => 'boo']];
         unset($this->storage['foo']['bar']['baz']);
         unset($this->storage['foo']['bar']);
 
-        $this->assertFalse(isset($this->storage['foo']['bar']));
+        self::assertFalse(isset($this->storage['foo']['bar']));
     }
 }
diff --git a/test/TestAsset/TestDbTableGatewaySaveHandler.php b/test/TestAsset/TestDbTableGatewaySaveHandler.php
index 2524212e..4beccf7e 100644
--- a/test/TestAsset/TestDbTableGatewaySaveHandler.php
+++ b/test/TestAsset/TestDbTableGatewaySaveHandler.php
@@ -16,12 +16,12 @@ class TestDbTableGatewaySaveHandler extends DbTableGateway
 
     protected $numDestroyCalls = 0;
 
-    public function getNumReadCalls()
+    public function getNumReadCalls(): int
     {
         return $this->numReadCalls;
     }
 
-    public function getNumDestroyCalls()
+    public function getNumDestroyCalls(): int
     {
         return $this->numDestroyCalls;
     }
diff --git a/test/TestAsset/TestManager.php b/test/TestAsset/TestManager.php
index 1a7d90f9..26209dce 100644
--- a/test/TestAsset/TestManager.php
+++ b/test/TestAsset/TestManager.php
@@ -10,7 +10,7 @@
 
 use Laminas\EventManager\EventManagerInterface;
 use Laminas\Session\AbstractManager;
-use Laminas\Session\Configuration\StandardConfig;
+use Laminas\Session\Config\StandardConfig;
 use Laminas\Session\Storage\ArrayStorage;
 
 class TestManager extends AbstractManager
@@ -30,7 +30,7 @@ public function destroy()
         $this->started = false;
     }
 
-    public function stop()
+    public function stop(): void
     {
     }
 
diff --git a/test/Validator/HttpUserAgentTest.php b/test/Validator/HttpUserAgentTest.php
new file mode 100644
index 00000000..b2a9ac7b
--- /dev/null
+++ b/test/Validator/HttpUserAgentTest.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaminasTest\Session\Validator;
+
+use Laminas\Session\Validator\HttpUserAgent;
+use PHPUnit\Framework\TestCase;
+
+class HttpUserAgentTest extends TestCase
+{
+    public function testIsValid(): void
+    {
+        $_SERVER['HTTP_USER_AGENT'] = 'Test-User-Agent';
+
+        $validator = new HttpUserAgent();
+
+        self::assertNotNull($validator->getData());
+        self::assertTrue($validator->isValid());
+    }
+
+    public function testIsValidWhenNoUserAgentIsSet(): void
+    {
+        // technically not needed in CLI
+        unset($_SERVER['HTTP_USER_AGENT']);
+
+        $validator = new HttpUserAgent();
+
+        self::assertNull($validator->getData());
+        self::assertTrue($validator->isValid());
+    }
+
+    public function testGetNameReturnsClassName(): void
+    {
+        $validator = new HttpUserAgent();
+
+        self::assertSame(HttpUserAgent::class, $validator->getName());
+    }
+}
diff --git a/test/Validator/IdTest.php b/test/Validator/IdTest.php
index 93865ab2..8f13b7ad 100644
--- a/test/Validator/IdTest.php
+++ b/test/Validator/IdTest.php
@@ -17,7 +17,7 @@ class IdTest extends TestCase
     /**
      * @return Generator
      */
-    public function id()
+    public function id(): ?Generator
     {
         yield '4, valid' => [4, '0123456789abcdef', true];
         yield '4, invalid (out of the range)' => [4, '0123456789abcdefg', false];
@@ -32,7 +32,6 @@ public function id()
     }
 
     /**
-     * @requires PHP 7.1
      * @runInSeparateProcess
      *
      * @dataProvider id
@@ -41,7 +40,7 @@ public function id()
      * @param string $id
      * @param bool   $isValid
      */
-    public function testIsValidPhp71($bitsPerCharacter, $id, $isValid)
+    public function testIsValidPhp71($bitsPerCharacter, $id, $isValid): void
     {
         ini_set('session.sid_bits_per_character', $bitsPerCharacter);
 
@@ -49,25 +48,7 @@ public function testIsValidPhp71($bitsPerCharacter, $id, $isValid)
         self::assertSame($isValid, $validator->isValid());
     }
 
-    /**
-     * @requires PHP < 7.1
-     * @runInSeparateProcess
-     *
-     * @dataProvider id
-     *
-     * @param int    $bitsPerCharacter
-     * @param string $id
-     * @param bool   $isValid
-     */
-    public function testIsValidPhpPriorTo71($bitsPerCharacter, $id, $isValid)
-    {
-        ini_set('session.hash_bits_per_character', $bitsPerCharacter);
-
-        $validator = new Id($id);
-        self::assertSame($isValid, $validator->isValid());
-    }
-
-    public function testConstructorSetId()
+    public function testConstructorSetId(): void
     {
         $id = new Id('1234');
 
@@ -77,7 +58,7 @@ public function testConstructorSetId()
     /**
      * @runInSeparateProcess
      */
-    public function testInitializedWithSessionIdWhenIdIsNotPassed()
+    public function testInitializedWithSessionIdWhenIdIsNotPassed(): void
     {
         session_start();
         $sessionId = session_id();
@@ -87,7 +68,7 @@ public function testInitializedWithSessionIdWhenIdIsNotPassed()
         self::assertSame($sessionId, $id->getData());
     }
 
-    public function testValidatorName()
+    public function testValidatorName(): void
     {
         $id = new Id();
 
diff --git a/test/Validator/RemoteAddrTest.php b/test/Validator/RemoteAddrTest.php
index de0fae18..12350f91 100644
--- a/test/Validator/RemoteAddrTest.php
+++ b/test/Validator/RemoteAddrTest.php
@@ -18,7 +18,7 @@ class RemoteAddrTest extends TestCase
 {
     protected $backup;
 
-    protected function backup()
+    protected function backup(): void
     {
         $this->backup = $_SERVER;
         unset(
@@ -31,7 +31,7 @@ protected function backup()
         RemoteAddr::setProxyHeader();
     }
 
-    protected function restore()
+    protected function restore(): void
     {
         $_SERVER = $this->backup;
         RemoteAddr::setUseProxy(false);
@@ -39,117 +39,117 @@ protected function restore()
         RemoteAddr::setProxyHeader();
     }
 
-    public function testGetData()
+    public function testGetData(): void
     {
         $validator = new RemoteAddr('0.1.2.3');
-        $this->assertEquals('0.1.2.3', $validator->getData());
+        self::assertEquals('0.1.2.3', $validator->getData());
     }
 
-    public function testDefaultUseProxy()
+    public function testDefaultUseProxy(): void
     {
-        $this->assertFalse(RemoteAddr::getUseProxy());
+        self::assertFalse(RemoteAddr::getUseProxy());
     }
 
-    public function testRemoteAddrWithoutProxy()
+    public function testRemoteAddrWithoutProxy(): void
     {
         $this->backup();
         $_SERVER['REMOTE_ADDR'] = '0.1.2.3';
-        $validator = new RemoteAddr();
-        $this->assertEquals('0.1.2.3', $validator->getData());
+        $validator              = new RemoteAddr();
+        self::assertEquals('0.1.2.3', $validator->getData());
         $this->restore();
     }
 
-    public function testIsValid()
+    public function testIsValid(): void
     {
         $this->backup();
         $_SERVER['REMOTE_ADDR'] = '0.1.2.3';
-        $validator = new RemoteAddr();
+        $validator              = new RemoteAddr();
         $_SERVER['REMOTE_ADDR'] = '1.1.2.3';
-        $this->assertFalse($validator->isValid());
+        self::assertFalse($validator->isValid());
         $this->restore();
     }
 
-    public function testIgnoreProxyByDefault()
+    public function testIgnoreProxyByDefault(): void
     {
         $this->backup();
-        $_SERVER['REMOTE_ADDR'] = '0.1.2.3';
+        $_SERVER['REMOTE_ADDR']    = '0.1.2.3';
         $_SERVER['HTTP_CLIENT_IP'] = '1.1.2.3';
-        $validator = new RemoteAddr();
-        $this->assertEquals('0.1.2.3', $validator->getData());
+        $validator                 = new RemoteAddr();
+        self::assertEquals('0.1.2.3', $validator->getData());
         $this->restore();
     }
 
-    public function testHttpXForwardedFor()
+    public function testHttpXForwardedFor(): void
     {
         $this->backup();
-        $_SERVER['REMOTE_ADDR'] = '0.1.2.3';
+        $_SERVER['REMOTE_ADDR']          = '0.1.2.3';
         $_SERVER['HTTP_X_FORWARDED_FOR'] = '1.1.2.3';
         RemoteAddr::setUseProxy(true);
         RemoteAddr::setTrustedProxies(['0.1.2.3']);
         $validator = new RemoteAddr();
-        $this->assertEquals('1.1.2.3', $validator->getData());
+        self::assertEquals('1.1.2.3', $validator->getData());
         $this->restore();
     }
 
-    public function testHttpClientIp()
+    public function testHttpClientIp(): void
     {
         $this->backup();
-        $_SERVER['REMOTE_ADDR'] = '0.1.2.3';
+        $_SERVER['REMOTE_ADDR']          = '0.1.2.3';
         $_SERVER['HTTP_X_FORWARDED_FOR'] = '1.1.2.3';
         $_SERVER['HTTP_X_FORWARDED_FOR'] = '2.1.2.3';
         RemoteAddr::setUseProxy(true);
         RemoteAddr::setTrustedProxies(['0.1.2.3']);
         $validator = new RemoteAddr();
-        $this->assertEquals('2.1.2.3', $validator->getData());
+        self::assertEquals('2.1.2.3', $validator->getData());
         $this->restore();
     }
 
-    public function testUsesRightMostAddressWhenMultipleHttpXForwardedForAddressesPresent()
+    public function testUsesRightMostAddressWhenMultipleHttpXForwardedForAddressesPresent(): void
     {
         $this->backup();
-        $_SERVER['REMOTE_ADDR'] = '0.1.2.3';
+        $_SERVER['REMOTE_ADDR']          = '0.1.2.3';
         $_SERVER['HTTP_X_FORWARDED_FOR'] = '2.1.2.3, 1.1.2.3';
         RemoteAddr::setUseProxy(true);
         RemoteAddr::setTrustedProxies(['0.1.2.3']);
         $validator = new RemoteAddr();
-        $this->assertEquals('1.1.2.3', $validator->getData());
+        self::assertEquals('1.1.2.3', $validator->getData());
         $this->restore();
     }
 
-    public function testShouldNotUseClientIpHeaderToTestProxyCapabilitiesByDefault()
+    public function testShouldNotUseClientIpHeaderToTestProxyCapabilitiesByDefault(): void
     {
         $this->backup();
-        $_SERVER['REMOTE_ADDR'] = '0.1.2.3';
+        $_SERVER['REMOTE_ADDR']          = '0.1.2.3';
         $_SERVER['HTTP_X_FORWARDED_FOR'] = '2.1.2.3, 1.1.2.3';
-        $_SERVER['HTTP_CLIENT_IP'] = '0.1.2.4';
+        $_SERVER['HTTP_CLIENT_IP']       = '0.1.2.4';
         RemoteAddr::setUseProxy(true);
         $validator = new RemoteAddr();
-        $this->assertEquals('0.1.2.3', $validator->getData());
+        self::assertEquals('0.1.2.3', $validator->getData());
         $this->restore();
     }
 
-    public function testWillOmitTrustedProxyIpsFromXForwardedForMatching()
+    public function testWillOmitTrustedProxyIpsFromXForwardedForMatching(): void
     {
         $this->backup();
-        $_SERVER['REMOTE_ADDR'] = '1.1.2.3';
+        $_SERVER['REMOTE_ADDR']          = '1.1.2.3';
         $_SERVER['HTTP_X_FORWARDED_FOR'] = '2.1.2.3, 1.1.2.3';
         RemoteAddr::setUseProxy(true);
         RemoteAddr::setTrustedProxies(['1.1.2.3']);
         $validator = new RemoteAddr();
-        $this->assertEquals('2.1.2.3', $validator->getData());
+        self::assertEquals('2.1.2.3', $validator->getData());
         $this->restore();
     }
 
-    public function testCanSpecifyWhichHeaderToUseStatically()
+    public function testCanSpecifyWhichHeaderToUseStatically(): void
     {
         $this->backup();
-        $_SERVER['REMOTE_ADDR'] = '0.1.2.3';
+        $_SERVER['REMOTE_ADDR']          = '0.1.2.3';
         $_SERVER['HTTP_X_FORWARDED_FOR'] = '2.1.2.3, 1.1.2.3';
-        $_SERVER['HTTP_CLIENT_IP'] = '0.1.2.4';
+        $_SERVER['HTTP_CLIENT_IP']       = '0.1.2.4';
         RemoteAddr::setUseProxy(true);
         RemoteAddr::setProxyHeader('Client-Ip');
         $validator = new RemoteAddr();
-        $this->assertEquals('0.1.2.3', $validator->getData());
+        self::assertEquals('0.1.2.3', $validator->getData());
         $this->restore();
     }
 }
diff --git a/test/Validator/ValidatorChainTest.php b/test/Validator/ValidatorChainTest.php
new file mode 100644
index 00000000..8d946a7e
--- /dev/null
+++ b/test/Validator/ValidatorChainTest.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaminasTest\Session\Validator;
+
+use Laminas\Session\Storage\ArrayStorage;
+use Laminas\Session\Validator\ValidatorInterface;
+use Laminas\Session\ValidatorChain;
+use LaminasTest\Session\TestAsset\TestFailingValidator;
+use PHPUnit\Framework\TestCase;
+
+use function assert;
+use function get_class;
+use function property_exists;
+
+class ValidatorChainTest extends TestCase
+{
+    /** @var ValidatorChain */
+    private $validatorChain;
+
+    protected function setUp(): void
+    {
+        $storage              = new ArrayStorage();
+        $this->validatorChain = new ValidatorChain($storage);
+    }
+
+    public function testGetStorage(): void
+    {
+        self::assertInstanceOf(ArrayStorage::class, $this->validatorChain->getStorage());
+    }
+
+    public function testAttachValidator(): void
+    {
+        $validator = new TestFailingValidator();
+
+        $this->validatorChain->attach('test', [$validator, 'isValid']);
+
+        $validatorMetadata = $this->validatorChain->getStorage()->getMetadata('_VALID');
+        self::assertIsArray($validatorMetadata);
+        self::assertArrayHasKey($validator->getName(), $validatorMetadata);
+        self::assertSame($validatorMetadata[$validator->getName()], $validator->getData());
+    }
+
+    public function testExistingValidatorsAreAttached(): void
+    {
+        $validator = $this->createValidatorSpy();
+        $storage   = new ArrayStorage();
+        $storage->setMetadata('_VALID', [get_class($validator) => $validator->getData()]);
+
+        $this->validatorChain = new ValidatorChain($storage);
+
+        $this->validatorChain->trigger('session.validate');
+        assert(property_exists($validator, 'isValidCallCount'));
+        self::assertSame(1, $validator::$isValidCallCount);
+    }
+
+    private function createValidatorSpy(): ValidatorInterface
+    {
+        return new class implements ValidatorInterface {
+            public static $isValidCallCount = 0;
+
+            public function isValid(): bool
+            {
+                self::$isValidCallCount++;
+                return $this->getData();
+            }
+
+            public function getData(): bool
+            {
+                return false;
+            }
+
+            public function getName(): string
+            {
+                return __CLASS__;
+            }
+        };
+    }
+}
diff --git a/test/autoload.php b/test/autoload.php
deleted file mode 100644
index ed3bd7ae..00000000
--- a/test/autoload.php
+++ /dev/null
@@ -1,11 +0,0 @@
-<?php
-
-/**
- * @see       https://github.com/laminas/laminas-session for the canonical source repository
- * @copyright https://github.com/laminas/laminas-session/blob/master/COPYRIGHT.md
- * @license   https://github.com/laminas/laminas-session/blob/master/LICENSE.md New BSD License
- */
-
-if (! class_exists(PHPUnit\Framework\Error\Deprecated::class)) {
-    class_alias(PHPUnit_Framework_Error_Deprecated::class, PHPUnit\Framework\Error\Deprecated::class);
-}