php 7.1 - 8.0 compatible version

issue #78
2025-10-10 04:44:28 +02:00 · 2021-05-16 12:18:23 +03:00
parent 7283fc3402
commit 584784c119
73 changed files with 1446 additions and 958 deletions
--- a/tests/Extra/Fields/AbstractUnicodeExtraFieldTest.php
+++ b/tests/Extra/Fields/AbstractUnicodeExtraFieldTest.php
@@ -76,8 +76,10 @@ abstract class AbstractUnicodeExtraFieldTest extends TestCase
     */
    public function testUnicodeErrorParse()
    {
-        $this->setExpectedException(
-            ZipException::class,
+        $this->expectException(
+            ZipException::class
+        );
+        $this->expectExceptionMessage(
            'Unicode path extra data must have at least 5 bytes.'
        );

@@ -90,8 +92,10 @@ abstract class AbstractUnicodeExtraFieldTest extends TestCase
     */
    public function testUnknownVersionParse()
    {
-        $this->setExpectedException(
-            ZipException::class,
+        $this->expectException(
+            ZipException::class
+        );
+        $this->expectExceptionMessage(
            'Unsupported version [2] for Unicode path extra data.'
        );

--- a/tests/Extra/Fields/ApkAlignmentExtraFieldTest.php
+++ b/tests/Extra/Fields/ApkAlignmentExtraFieldTest.php
@@ -96,8 +96,10 @@ final class ApkAlignmentExtraFieldTest extends TestCase
     */
    public function testInvalidParse()
    {
-        $this->setExpectedException(
-            ZipException::class,
+        $this->expectException(
+            ZipException::class
+        );
+        $this->expectExceptionMessage(
            'Minimum 6 bytes of the extensible data block/field used for alignment of uncompressed entries.'
        );

--- a/tests/Extra/Fields/AsiExtraFieldTest.php
+++ b/tests/Extra/Fields/AsiExtraFieldTest.php
@@ -91,8 +91,10 @@ final class AsiExtraFieldTest extends TestCase
     */
    public function testInvalidParse()
    {
-        $this->setExpectedException(
-            Crc32Exception::class,
+        $this->expectException(
+            Crc32Exception::class
+        );
+        $this->expectExceptionMessage(
            'Asi Unix Extra Filed Data (expected CRC32 value'
        );

--- a/tests/Extra/Fields/ExtendedTimestampExtraFieldTest.php
+++ b/tests/Extra/Fields/ExtendedTimestampExtraFieldTest.php
@@ -66,9 +66,9 @@ final class ExtendedTimestampExtraFieldTest extends TestCase
    {
        return [
            [
-                ExtendedTimestampExtraField::MODIFY_TIME_BIT |
-                ExtendedTimestampExtraField::ACCESS_TIME_BIT |
-                ExtendedTimestampExtraField::CREATE_TIME_BIT,
+                ExtendedTimestampExtraField::MODIFY_TIME_BIT
+                | ExtendedTimestampExtraField::ACCESS_TIME_BIT
+                | ExtendedTimestampExtraField::CREATE_TIME_BIT,
                911512006,
                911430000,
                893709400,
@@ -76,8 +76,8 @@ final class ExtendedTimestampExtraFieldTest extends TestCase
                "\x07\xC6\x91T6",
            ],
            [
-                ExtendedTimestampExtraField::MODIFY_TIME_BIT |
-                ExtendedTimestampExtraField::ACCESS_TIME_BIT,
+                ExtendedTimestampExtraField::MODIFY_TIME_BIT
+                | ExtendedTimestampExtraField::ACCESS_TIME_BIT,
                1492955702,
                1492955638,
                null,
@@ -115,8 +115,8 @@ final class ExtendedTimestampExtraFieldTest extends TestCase
        $field->setAccessTime($atime);
        self::assertSame(
            $field->getFlags(),
-            ExtendedTimestampExtraField::MODIFY_TIME_BIT |
-            ExtendedTimestampExtraField::ACCESS_TIME_BIT
+            ExtendedTimestampExtraField::MODIFY_TIME_BIT
+            | ExtendedTimestampExtraField::ACCESS_TIME_BIT
        );
        self::assertSame($field->getModifyTime(), $mtime);
        self::assertSame($field->getAccessTime(), $atime);
@@ -127,9 +127,9 @@ final class ExtendedTimestampExtraFieldTest extends TestCase
        $field->setCreateTime($ctime);
        self::assertSame(
            $field->getFlags(),
-            ExtendedTimestampExtraField::MODIFY_TIME_BIT |
-            ExtendedTimestampExtraField::ACCESS_TIME_BIT |
-            ExtendedTimestampExtraField::CREATE_TIME_BIT
+            ExtendedTimestampExtraField::MODIFY_TIME_BIT
+            | ExtendedTimestampExtraField::ACCESS_TIME_BIT
+            | ExtendedTimestampExtraField::CREATE_TIME_BIT
        );
        self::assertSame($field->getModifyTime(), $mtime);
        self::assertSame($field->getAccessTime(), $atime);
@@ -141,8 +141,8 @@ final class ExtendedTimestampExtraFieldTest extends TestCase
        self::assertNull($field->getCreateDateTime());
        self::assertSame(
            $field->getFlags(),
-            ExtendedTimestampExtraField::MODIFY_TIME_BIT |
-            ExtendedTimestampExtraField::ACCESS_TIME_BIT
+            ExtendedTimestampExtraField::MODIFY_TIME_BIT
+            | ExtendedTimestampExtraField::ACCESS_TIME_BIT
        );

        $field->setAccessTime(null);
--- a/tests/Extra/Fields/JarMarkerExtraFieldTest.php
+++ b/tests/Extra/Fields/JarMarkerExtraFieldTest.php
@@ -32,8 +32,10 @@ final class JarMarkerExtraFieldTest extends TestCase
     */
    public function testInvalidUnpackLocalData()
    {
-        $this->setExpectedException(
-            ZipException::class,
+        $this->expectException(
+            ZipException::class
+        );
+        $this->expectExceptionMessage(
            "JarMarker doesn't expect any data"
        );

@@ -45,8 +47,10 @@ final class JarMarkerExtraFieldTest extends TestCase
     */
    public function testInvalidUnpackCdData()
    {
-        $this->setExpectedException(
-            ZipException::class,
+        $this->expectException(
+            ZipException::class
+        );
+        $this->expectExceptionMessage(
            "JarMarker doesn't expect any data"
        );

--- a/tests/Extra/Fields/NtfsExtraFieldTest.php
+++ b/tests/Extra/Fields/NtfsExtraFieldTest.php
@@ -14,8 +14,10 @@ use PhpZip\Model\Extra\Fields\NtfsExtraField;
 */
 final class NtfsExtraFieldTest extends TestCase
 {
-    protected function setUp()
+    protected function setUp(): void
    {
+        parent::setUp();
+
        if (\PHP_INT_SIZE === 4) {
            self::markTestSkipped('only 64 bit test');
        }
@@ -156,9 +158,9 @@ final class NtfsExtraFieldTest extends TestCase
        $atimeTimestamp,
        $ctimeTimestamp
    ) {
-        self::assertEquals(NtfsExtraField::ntfsTimeToTimestamp($mtimeNtfs), $mtimeTimestamp, '', 0.00001);
-        self::assertEquals(NtfsExtraField::ntfsTimeToTimestamp($atimeNtfs), $atimeTimestamp, '', 0.00001);
-        self::assertEquals(NtfsExtraField::ntfsTimeToTimestamp($ctimeNtfs), $ctimeTimestamp, '', 0.00001);
+        self::assertEqualsWithDelta(NtfsExtraField::ntfsTimeToTimestamp($mtimeNtfs), $mtimeTimestamp, 0.00001);
+        self::assertEqualsWithDelta(NtfsExtraField::ntfsTimeToTimestamp($atimeNtfs), $atimeTimestamp, 0.00001);
+        self::assertEqualsWithDelta(NtfsExtraField::ntfsTimeToTimestamp($ctimeNtfs), $ctimeTimestamp, 0.00001);

        self::assertEqualsIntegerWithDelta(NtfsExtraField::timestampToNtfsTime($mtimeTimestamp), $mtimeNtfs, 10);
        self::assertEqualsIntegerWithDelta(NtfsExtraField::timestampToNtfsTime($atimeTimestamp), $atimeNtfs, 10);
--- a/tests/Extra/Fields/UnicodeCommentExtraFieldTest.php
+++ b/tests/Extra/Fields/UnicodeCommentExtraFieldTest.php
@@ -12,7 +12,7 @@ use PhpZip\Model\Extra\Fields\UnicodeCommentExtraField;
 final class UnicodeCommentExtraFieldTest extends AbstractUnicodeExtraFieldTest
 {
    /**
-     * {@inheritdoc}
+     * {@inheritDoc}
     */
    protected function getUnicodeExtraFieldClassName()
    {
--- a/tests/Extra/Fields/UnicodePathExtraFieldTest.php
+++ b/tests/Extra/Fields/UnicodePathExtraFieldTest.php
@@ -14,7 +14,7 @@ use PhpZip\Model\Extra\Fields\UnicodePathExtraField;
 final class UnicodePathExtraFieldTest extends AbstractUnicodeExtraFieldTest
 {
    /**
-     * {@inheritdoc}
+     * {@inheritDoc}
     */
    protected function getUnicodeExtraFieldClassName()
    {
--- a/tests/Extra/Fields/UnrecognizedExtraFieldTest.php
+++ b/tests/Extra/Fields/UnrecognizedExtraFieldTest.php
@@ -37,8 +37,10 @@ final class UnrecognizedExtraFieldTest extends TestCase

    public function testUnpackLocalData()
    {
-        $this->setExpectedException(
-            RuntimeException::class,
+        $this->expectException(
+            RuntimeException::class
+        );
+        $this->expectExceptionMessage(
            'Unsupport parse'
        );

@@ -47,8 +49,10 @@ final class UnrecognizedExtraFieldTest extends TestCase

    public function testUnpackCentralDirData()
    {
-        $this->setExpectedException(
-            RuntimeException::class,
+        $this->expectException(
+            RuntimeException::class
+        );
+        $this->expectExceptionMessage(
            'Unsupport parse'
        );

--- a/tests/Extra/Fields/WinZipAesExtraFieldTest.php
+++ b/tests/Extra/Fields/WinZipAesExtraFieldTest.php
@@ -157,7 +157,8 @@ final class WinZipAesExtraFieldTest extends TestCase
     */
    public function testConstructUnsupportVendorVersion()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Unsupport WinZip AES vendor version: 3');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Unsupport WinZip AES vendor version: 3');

        new WinZipAesExtraField(
            3,
@@ -171,7 +172,8 @@ final class WinZipAesExtraFieldTest extends TestCase
     */
    public function testSetterUnsupportVendorVersion()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Unsupport WinZip AES vendor version: 3');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Unsupport WinZip AES vendor version: 3');

        $extraField = new WinZipAesExtraField(
            WinZipAesExtraField::VERSION_AE1,
@@ -186,7 +188,8 @@ final class WinZipAesExtraFieldTest extends TestCase
     */
    public function testConstructUnsupportCompressionMethod()
    {
-        $this->setExpectedException(ZipUnsupportMethodException::class, 'Compression method 3 (Reduced compression factor 2) is not supported.');
+        $this->expectException(ZipUnsupportMethodException::class);
+        $this->expectExceptionMessage('Compression method 3 (Reduced compression factor 2) is not supported.');

        new WinZipAesExtraField(
            WinZipAesExtraField::VERSION_AE1,
@@ -200,7 +203,8 @@ final class WinZipAesExtraFieldTest extends TestCase
     */
    public function testSetterUnsupportCompressionMethod()
    {
-        $this->setExpectedException(ZipUnsupportMethodException::class, 'Compression method 3 (Reduced compression factor 2) is not supported.');
+        $this->expectException(ZipUnsupportMethodException::class);
+        $this->expectExceptionMessage('Compression method 3 (Reduced compression factor 2) is not supported.');

        $extraField = new WinZipAesExtraField(
            WinZipAesExtraField::VERSION_AE1,
@@ -215,7 +219,8 @@ final class WinZipAesExtraFieldTest extends TestCase
     */
    public function testConstructUnsupportKeyStrength()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Key strength 16 not support value. Allow values: 1, 2, 3');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Key strength 16 not support value. Allow values: 1, 2, 3');

        new WinZipAesExtraField(
            WinZipAesExtraField::VERSION_AE1,
@@ -229,7 +234,8 @@ final class WinZipAesExtraFieldTest extends TestCase
     */
    public function testSetterUnsupportKeyStrength()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Key strength 16 not support value. Allow values: 1, 2, 3');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Key strength 16 not support value. Allow values: 1, 2, 3');

        new WinZipAesExtraField(
            WinZipAesExtraField::VERSION_AE1,
--- a/tests/Extra/Fields/Zip64ExtraFieldTest.php
+++ b/tests/Extra/Fields/Zip64ExtraFieldTest.php
@@ -15,8 +15,10 @@ use PhpZip\Model\ZipEntry;
 */
 final class Zip64ExtraFieldTest extends TestCase
 {
-    protected function setUp()
+    protected function setUp(): void
    {
+        parent::setUp();
+
        if (\PHP_INT_SIZE === 4) {
            self::markTestSkipped('only 64 bit test');
        }
--- a/tests/Issue24Test.php
+++ b/tests/Issue24Test.php
@@ -21,7 +21,7 @@ class Issue24Test extends ZipTestCase
     *
     * @noinspection PhpMissingParentCallCommonInspection
     */
-    public static function setUpBeforeClass()
+    public static function setUpBeforeClass(): void
    {
        stream_wrapper_register(self::PROTO_DUMMYFS, DummyFileSystemStream::class);
    }
--- a/tests/PhpZipExtResourceTest.php
+++ b/tests/PhpZipExtResourceTest.php
@@ -87,7 +87,7 @@ class PhpZipExtResourceTest extends ZipTestCase
        $zipFile->extractTo($this->outputDirname);
        $zipFile->close();

-        static::assertTrue(is_dir($this->outputDirname . '/test/empty'));
+        static::assertDirectoryExists($this->outputDirname . '/test/empty');
    }

    /**
@@ -109,7 +109,8 @@ class PhpZipExtResourceTest extends ZipTestCase
     */
    public function testBug49072()
    {
-        $this->setExpectedException(Crc32Exception::class, 'file1');
+        $this->expectException(Crc32Exception::class);
+        $this->expectExceptionMessage('file1');

        $filename = __DIR__ . '/resources/pecl/bug49072.zip';

@@ -128,13 +129,17 @@ class PhpZipExtResourceTest extends ZipTestCase
    public function testBug70752()
    {
        if (\PHP_INT_SIZE === 4) { // php 32 bit
-            $this->setExpectedException(
-                RuntimeException::class,
+            $this->expectException(
+                RuntimeException::class
+            );
+            $this->expectExceptionMessage(
                'Traditional PKWARE Encryption is not supported in 32-bit PHP.'
            );
        } else { // php 64 bit
-            $this->setExpectedException(
-                ZipAuthenticationException::class,
+            $this->expectException(
+                ZipAuthenticationException::class
+            );
+            $this->expectExceptionMessage(
                'Invalid password'
            );
        }
@@ -151,7 +156,7 @@ class PhpZipExtResourceTest extends ZipTestCase
            $zipFile->extractTo($this->outputDirname);
            static::markTestIncomplete('failed test');
        } catch (ZipException $exception) {
-            static::assertFileNotExists($this->outputDirname . '/bug70752.txt');
+            static::assertFileDoesNotExist($this->outputDirname . '/bug70752.txt');

            throw $exception;
        } finally {
@@ -168,7 +173,8 @@ class PhpZipExtResourceTest extends ZipTestCase
     */
    public function testPecl12414()
    {
-        $this->setExpectedException(ZipException::class, 'Corrupt zip file. Cannot read zip entry.');
+        $this->expectException(ZipException::class);
+        $this->expectExceptionMessage('Corrupt zip file. Cannot read zip entry.');

        $filename = __DIR__ . '/resources/pecl/pecl12414.zip';

--- a/tests/Polyfill/LegacyTestCase.php
+++ b/tests/Polyfill/LegacyTestCase.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpZip\Tests\Polyfill;
+
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ *
+ * @small
+ */
+class LegacyTestCase extends TestCase
+{
+    use PhpUnit8CompatTrait;
+    use PhpUnit9CompatTrait;
+}
--- a/tests/Polyfill/PhpUnit8CompatTrait.php
+++ b/tests/Polyfill/PhpUnit8CompatTrait.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace PhpZip\Tests\Polyfill;
+
+use PHPUnit\Runner\Version;
+
+trait PhpUnit8CompatTrait
+{
+    /**
+     * @param string $regularExpression
+     */
+    public function expectExceptionMessageMatches(string $regularExpression): void
+    {
+        if (version_compare(Version::id(), '8.0.0', '<')) {
+            $this->expectExceptionMessageRegExp($regularExpression);
+
+            return;
+        }
+
+        parent::expectExceptionMessageMatches($regularExpression);
+    }
+}
--- a/tests/Polyfill/PhpUnit9CompatTrait.php
+++ b/tests/Polyfill/PhpUnit9CompatTrait.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpZip\Tests\Polyfill;
+
+use PHPUnit\Framework\ExpectationFailedException;
+use PHPUnit\Runner\Version;
+use SebastianBergmann\RecursionContext\InvalidArgumentException;
+
+trait PhpUnit9CompatTrait
+{
+    /**
+     * Asserts that a file does not exist.
+     *
+     * @param string $filename
+     * @param string $message
+     *
+     * @throws InvalidArgumentException
+     * @throws ExpectationFailedException
+     *
+     * @noinspection PhpDeprecationInspection
+     */
+    public static function assertFileDoesNotExist(string $filename, string $message = ''): void
+    {
+        if (version_compare(Version::id(), '9.1.0', '<')) {
+            static::assertFileNotExists($filename, $message);
+
+            return;
+        }
+
+        parent::assertFileDoesNotExist($filename, $message);
+    }
+
+    /**
+     * Asserts that a directory does not exist.
+     *
+     * @throws ExpectationFailedException
+     * @throws InvalidArgumentException
+     *
+     * @noinspection PhpDeprecationInspection
+     */
+    public static function assertDirectoryDoesNotExist(string $directory, string $message = ''): void
+    {
+        if (version_compare(Version::id(), '9.1.0', '<')) {
+            static::assertDirectoryNotExists($directory, $message);
+
+            return;
+        }
+
+        parent::assertDirectoryDoesNotExist($directory, $message);
+    }
+}
--- a/tests/SymlinkTest.php
+++ b/tests/SymlinkTest.php
@@ -47,7 +47,7 @@ final class SymlinkTest extends ZipTestCase
        self::assertCorrectZipArchive($this->outputFilename);

        FilesUtil::removeDir($this->outputDirname);
-        self::assertFalse(is_dir($this->outputDirname));
+        self::assertDirectoryDoesNotExist($this->outputDirname);
        self::assertTrue(mkdir($this->outputDirname, 0755, true));

        $zipFile->openFile($this->outputFilename);
--- a/tests/ZipAlignTest.php
+++ b/tests/ZipAlignTest.php
@@ -55,7 +55,7 @@ class ZipAlignTest extends ZipTestCase
        for ($i = 0; $i < 100; $i++) {
            $zipFile->addFromString(
                'entry' . $i . '.txt',
-                random_bytes(mt_rand(100, 4096)),
+                random_bytes(random_int(100, 4096)),
                ZipCompressionMethod::STORED
            );
        }
@@ -97,7 +97,7 @@ class ZipAlignTest extends ZipTestCase
        for ($i = 0; $i < 100; $i++) {
            $zipFile->addFromString(
                'entry' . $i . '.txt',
-                random_bytes(mt_rand(100, 4096)),
+                random_bytes(random_int(100, 4096)),
                ZipCompressionMethod::STORED
            );
        }
@@ -126,7 +126,7 @@ class ZipAlignTest extends ZipTestCase
        for ($i = 0; $i < 100; $i++) {
            $zipFile->addFromString(
                'entry' . $i . '.txt',
-                random_bytes(mt_rand(100, 4096)),
+                random_bytes(random_int(100, 4096)),
                ZipCompressionMethod::STORED
            );
        }
@@ -147,14 +147,14 @@ class ZipAlignTest extends ZipTestCase
        $zipFile->openFile($this->outputFilename);
        $zipFile->deleteFromRegex('~entry2[\\d]+\\.txt$~s');
        for ($i = 0; $i < 100; $i++) {
-            $isStored = (bool) mt_rand(0, 1);
+            $isStored = (bool) random_int(0, 1);

            $zipFile->addFromString(
                'entry_new_' . ($isStored ? 'stored' : 'deflated') . '_' . $i . '.txt',
-                random_bytes(mt_rand(100, 4096)),
-                $isStored ?
-                    ZipCompressionMethod::STORED :
-                    ZipCompressionMethod::DEFLATED
+                random_bytes(random_int(100, 4096)),
+                $isStored
+                    ? ZipCompressionMethod::STORED
+                    : ZipCompressionMethod::DEFLATED
            );
        }
        $zipFile->setZipAlign(4);
--- a/tests/ZipEntryTest.php
+++ b/tests/ZipEntryTest.php
@@ -89,7 +89,8 @@ class ZipEntryTest extends TestCase
     */
    public function testEmptyName($entryName, $exceptionMessage)
    {
-        $this->setExpectedException(InvalidArgumentException::class, $exceptionMessage);
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage($exceptionMessage);

        new ZipEntry($entryName);
    }
@@ -174,7 +175,8 @@ class ZipEntryTest extends TestCase
     */
    public function testOutOfRangeCompressionMethod($compressionMethod)
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'method out of range: ' . $compressionMethod);
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('method out of range: ' . $compressionMethod);

        $zipEntry = new ZipEntry('entry');
        $zipEntry->setCompressionMethod($compressionMethod);
@@ -201,7 +203,8 @@ class ZipEntryTest extends TestCase
     */
    public function testUnsupportCompressionMethod($compressionMethod, $exceptionMessage)
    {
-        $this->setExpectedException(ZipUnsupportMethodException::class, $exceptionMessage);
+        $this->expectException(ZipUnsupportMethodException::class);
+        $this->expectExceptionMessage($exceptionMessage);

        $zipEntry = new ZipEntry('entry');
        $zipEntry->setCompressionMethod($compressionMethod);
@@ -253,7 +256,8 @@ class ZipEntryTest extends TestCase

    public function testEmptyCharset()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Empty charset');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Empty charset');

        $zipEntry = new ZipEntry('entry');
        $zipEntry->setCharset('');
@@ -398,7 +402,8 @@ class ZipEntryTest extends TestCase
     */
    public function testInvalidCreatedOs($zipOS)
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Platform out of range');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Platform out of range');

        $zipEntry = new ZipEntry('entry');
        $zipEntry->setCreatedOS($zipOS);
@@ -422,7 +427,8 @@ class ZipEntryTest extends TestCase
     */
    public function testInvalidExtractedOs($zipOS)
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Platform out of range');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Platform out of range');

        $zipEntry = new ZipEntry('entry');
        $zipEntry->setExtractedOS($zipOS);
@@ -545,7 +551,8 @@ class ZipEntryTest extends TestCase

    public function testInvalidCompressedSize()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Compressed size < -1');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Compressed size < -1');

        $zipEntry = new ZipEntry('entry');
        $zipEntry->setCompressedSize(-2);
@@ -553,7 +560,8 @@ class ZipEntryTest extends TestCase

    public function testInvalidUncompressedSize()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Uncompressed size < -1');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Uncompressed size < -1');

        $zipEntry = new ZipEntry('entry');
        $zipEntry->setUncompressedSize(-2);
@@ -568,7 +576,8 @@ class ZipEntryTest extends TestCase
        $zipEntry->setLocalHeaderOffset($localHeaderOffset);
        static::assertSame($zipEntry->getLocalHeaderOffset(), $localHeaderOffset);

-        $this->setExpectedException(InvalidArgumentException::class, 'Negative $localHeaderOffset');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Negative $localHeaderOffset');
        $zipEntry->setLocalHeaderOffset(-1);
    }

@@ -652,7 +661,8 @@ class ZipEntryTest extends TestCase
     */
    public function testInvalidGPBF($gpbf)
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'general purpose bit flags out of range');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('general purpose bit flags out of range');

        $zipEntry = new ZipEntry('entry');
        $zipEntry->setGeneralPurposeBitFlags($gpbf);
@@ -683,8 +693,8 @@ class ZipEntryTest extends TestCase
        $zipEntry = new ZipEntry('entry');
        $zipEntry->setCompressionMethod(ZipCompressionMethod::DEFLATED);

-        $gpbf = ($bit1 ? GeneralPurposeBitFlag::COMPRESSION_FLAG1 : 0) |
-            ($bit2 ? GeneralPurposeBitFlag::COMPRESSION_FLAG2 : 0);
+        $gpbf = ($bit1 ? GeneralPurposeBitFlag::COMPRESSION_FLAG1 : 0)
+            | ($bit2 ? GeneralPurposeBitFlag::COMPRESSION_FLAG2 : 0);
        $zipEntry->setGeneralPurposeBitFlags($gpbf);
        static::assertSame($zipEntry->getCompressionLevel(), $compressionLevel);

@@ -791,10 +801,12 @@ class ZipEntryTest extends TestCase
     */
    public function testInvalidCompressionLevel($compressionLevel)
    {
-        $this->setExpectedException(
-            InvalidArgumentException::class,
-            'Invalid compression level. Minimum level ' . ZipCompressionLevel::LEVEL_MIN .
-            '. Maximum level ' . ZipCompressionLevel::LEVEL_MAX
+        $this->expectException(
+            InvalidArgumentException::class
+        );
+        $this->expectExceptionMessage(
+            'Invalid compression level. Minimum level ' . ZipCompressionLevel::LEVEL_MIN
+            . '. Maximum level ' . ZipCompressionLevel::LEVEL_MAX
        );

        $zipEntry = new ZipEntry('entry');
@@ -855,7 +867,8 @@ class ZipEntryTest extends TestCase
            return;
        }

-        $this->setExpectedException(InvalidArgumentException::class, 'DosTime out of range');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('DosTime out of range');

        $zipEntry = new ZipEntry('entry');
        $zipEntry->setDosTime($dosTime);
@@ -1012,7 +1025,8 @@ class ZipEntryTest extends TestCase
            return;
        }

-        $this->setExpectedException(InvalidArgumentException::class, 'external attributes out of range');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('external attributes out of range');

        $zipEntry = new ZipEntry('entry');
        $zipEntry->setExternalAttributes($externalAttributes);
@@ -1045,7 +1059,8 @@ class ZipEntryTest extends TestCase
     */
    public function testInvalidInternalAttributes($internalAttributes)
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'internal attributes out of range');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('internal attributes out of range');

        $zipEntry = new ZipEntry('entry');
        $zipEntry->setInternalAttributes($internalAttributes);
@@ -1140,7 +1155,8 @@ class ZipEntryTest extends TestCase
     */
    public function testLongComment()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Comment too long');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Comment too long');

        $longComment = random_bytes(0xffff + 1);
        $zipEntry = new ZipEntry('entry');
@@ -1305,8 +1321,10 @@ class ZipEntryTest extends TestCase
     */
    public function testInvalidEncryptionMethod($encryptionMethod)
    {
-        $this->setExpectedException(
-            InvalidArgumentException::class,
+        $this->expectException(
+            InvalidArgumentException::class
+        );
+        $this->expectExceptionMessage(
            'Encryption method ' . $encryptionMethod . ' is not supported.'
        );

@@ -1456,7 +1474,7 @@ class ZipEntryTest extends TestCase
     * @param \DateTimeInterface|null $atime
     * @param \DateTimeInterface|null $ctime
     */
-    public function testMTimeATimeCTime(ExtraFieldsCollection $extraFieldsCollection, $mtime, $atime, $ctime)
+    public function testMTimeATimeCTime(ExtraFieldsCollection $extraFieldsCollection, \DateTimeInterface $mtime, \DateTimeInterface $atime = null, \DateTimeInterface $ctime = null)
    {
        $unixTimestamp = time();

--- a/tests/ZipFileSetTestCase.php
+++ b/tests/ZipFileSetTestCase.php
@@ -30,7 +30,7 @@ abstract class ZipFileSetTestCase extends ZipTestCase
    /**
     * Before test.
     */
-    protected function setUp()
+    protected function setUp(): void
    {
        parent::setUp();
        $this->fillDirectory();
--- a/tests/ZipFileTest.php
+++ b/tests/ZipFileTest.php
@@ -31,7 +31,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFileCantExists()
    {
-        $this->setExpectedException(ZipException::class, 'does not exist');
+        $this->expectException(ZipException::class);
+        $this->expectExceptionMessage('does not exist');

        $zipFile = new ZipFile();
        $zipFile->openFile(uniqid('', false));
@@ -50,7 +51,8 @@ class ZipFileTest extends ZipTestCase
            return;
        }

-        $this->setExpectedException(ZipException::class, 'can\'t open');
+        $this->expectException(ZipException::class);
+        $this->expectExceptionMessage('can\'t open');

        static::assertNotFalse(file_put_contents($this->outputFilename, 'content'));
        static::assertTrue(chmod($this->outputFilename, 0222));
@@ -64,7 +66,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFileEmptyFile()
    {
-        $this->setExpectedException(ZipException::class, 'Corrupt zip file');
+        $this->expectException(ZipException::class);
+        $this->expectExceptionMessage('Corrupt zip file');

        static::assertNotFalse(touch($this->outputFilename));
        $zipFile = new ZipFile();
@@ -77,8 +80,10 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFileInvalidZip()
    {
-        $this->setExpectedException(
-            ZipException::class,
+        $this->expectException(
+            ZipException::class
+        );
+        $this->expectExceptionMessage(
            'Invalid zip file. The end of the central directory could not be found.'
        );

@@ -92,7 +97,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFromStringNullString()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Empty string passed');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Empty string passed');

        $zipFile = new ZipFile();
        $zipFile->openFromString(null);
@@ -103,7 +109,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFromStringEmptyString()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Empty string passed');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Empty string passed');

        $zipFile = new ZipFile();
        $zipFile->openFromString('');
@@ -115,8 +122,10 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFromStringInvalidZip()
    {
-        $this->setExpectedException(
-            ZipException::class,
+        $this->expectException(
+            ZipException::class
+        );
+        $this->expectExceptionMessage(
            'Invalid zip file. The end of the central directory could not be found.'
        );

@@ -149,7 +158,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFromStreamNullStream()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Stream must be a resource');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Stream must be a resource');

        $zipFile = new ZipFile();
        $zipFile->openFromStream(null);
@@ -160,7 +170,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFromStreamInvalidResourceType()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Stream must be a resource');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Stream must be a resource');

        $zipFile = new ZipFile();
        /** @noinspection PhpParamsInspection */
@@ -169,19 +180,22 @@ class ZipFileTest extends ZipTestCase

    /**
     * @throws ZipException
+     *
+     * @noinspection PhpComposerExtensionStubsInspection
     */
    public function testOpenFromStreamInvalidResourceType2()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Invalid resource type');
+        $this->expectException(InvalidArgumentException::class);
+        $exceptionMessage = PHP_VERSION_ID < 80000 ?
+            'Invalid resource type' :
+            'Stream must be a resource';
+        $this->expectExceptionMessage($exceptionMessage);

        $zipFile = new ZipFile();

        if (!\extension_loaded('gd')) {
            static::markTestSkipped('not extension gd');
-
-            return;
        }
-        /** @noinspection PhpComposerExtensionStubsInspection */
        $zipFile->openFromStream(imagecreate(1, 1));
    }

@@ -190,7 +204,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFromStreamInvalidResourceType3()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Directory stream not supported');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Directory stream not supported');

        $zipFile = new ZipFile();
        $zipFile->openFromStream(opendir(__DIR__));
@@ -203,7 +218,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFromStreamNoSeekable()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The stream wrapper type "http" is not supported');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The stream wrapper type "http" is not supported');

        if (!$fp = @fopen('http://localhost', 'rb')) {
            if (!$fp = @fopen('http://example.org', 'rb')) {
@@ -222,7 +238,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFromStreamEmptyContents()
    {
-        $this->setExpectedException(ZipException::class, 'Corrupt zip file');
+        $this->expectException(ZipException::class);
+        $this->expectExceptionMessage('Corrupt zip file');

        $fp = fopen($this->outputFilename, 'w+b');
        $zipFile = new ZipFile();
@@ -235,8 +252,10 @@ class ZipFileTest extends ZipTestCase
     */
    public function testOpenFromStreamInvalidZip()
    {
-        $this->setExpectedException(
-            ZipException::class,
+        $this->expectException(
+            ZipException::class
+        );
+        $this->expectExceptionMessage(
            'Invalid zip file. The end of the central directory could not be found.'
        );

@@ -508,7 +527,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testRenameEntryNull()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'name is null');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('name is null');

        $zipFile = new ZipFile();
        $zipFile->rename(null, 'new-file');
@@ -519,7 +539,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testRenameEntryNull2()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'name is null');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('name is null');

        $zipFile = new ZipFile();
        $zipFile->rename('old-file', null);
@@ -530,7 +551,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testRenameEntryToExistsNewEntry()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'is exists');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('is exists');

        $zipFile = new ZipFile();
        $zipFile['file'] = 'content';
@@ -548,7 +570,7 @@ class ZipFileTest extends ZipTestCase
     */
    public function testRenameEntryNotFound()
    {
-        $this->setExpectedException(ZipEntryNotFoundException::class);
+        $this->expectException(ZipEntryNotFoundException::class);

        $zipFile = new ZipFile();
        $zipFile['file'] = 'content';
@@ -615,7 +637,7 @@ class ZipFileTest extends ZipTestCase
     */
    public function testDeleteFromNameNotFoundEntry()
    {
-        $this->setExpectedException(ZipEntryNotFoundException::class);
+        $this->expectException(ZipEntryNotFoundException::class);

        $zipFile = new ZipFile();
        $zipFile->deleteFromName('entry');
@@ -674,7 +696,8 @@ class ZipFileTest extends ZipTestCase

    public function testDeleteFromGlobFailNull()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The glob pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The glob pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->deleteFromGlob(null);
@@ -682,7 +705,8 @@ class ZipFileTest extends ZipTestCase

    public function testDeleteFromGlobFailEmpty()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The glob pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The glob pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->deleteFromGlob('');
@@ -722,7 +746,8 @@ class ZipFileTest extends ZipTestCase

    public function testDeleteFromRegexFailNull()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The regex pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The regex pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->deleteFromRegex(null);
@@ -730,7 +755,8 @@ class ZipFileTest extends ZipTestCase

    public function testDeleteFromRegexFailEmpty()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The regex pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The regex pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->deleteFromRegex('');
@@ -806,10 +832,10 @@ class ZipFileTest extends ZipTestCase
     */
    public function testVeryLongArchiveComment()
    {
-        $this->setExpectedException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);

-        $comment = 'Very long comment' . \PHP_EOL .
-            'Очень длинный комментарий' . \PHP_EOL;
+        $comment = 'Very long comment' . \PHP_EOL
+            . 'Очень длинный комментарий' . \PHP_EOL;
        $comment = str_repeat($comment, ceil(0xffff / \strlen($comment)) + \strlen($comment) + 1);

        $zipFile = new ZipFile();
@@ -873,7 +899,7 @@ class ZipFileTest extends ZipTestCase
            static::assertSame($zipFile->getEntryComment($entryName), (string) $entriesItem['comment']);
        }
        // modify comment
-        $entries['file5.txt']['comment'] = mt_rand(1, 100000000);
+        $entries['file5.txt']['comment'] = random_int(1, 100000000);
        $zipFile->setEntryComment('file5.txt', $entries['file5.txt']['comment']);
        $zipFile->saveAsFile($this->outputFilename);
        $zipFile->close();
@@ -898,10 +924,11 @@ class ZipFileTest extends ZipTestCase
     */
    public function testVeryLongEntryComment()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Comment too long');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Comment too long');

-        $comment = 'Very long comment' . \PHP_EOL .
-            'Очень длинный комментарий' . \PHP_EOL;
+        $comment = 'Very long comment' . \PHP_EOL
+            . 'Очень длинный комментарий' . \PHP_EOL;
        $comment = str_repeat($comment, ceil(0xffff / \strlen($comment)) + \strlen($comment) + 1);

        $zipFile = new ZipFile();
@@ -914,7 +941,7 @@ class ZipFileTest extends ZipTestCase
     */
    public function testSetEntryCommentNotFoundEntry()
    {
-        $this->setExpectedException(ZipEntryNotFoundException::class);
+        $this->expectException(ZipEntryNotFoundException::class);

        $zipFile = new ZipFile();
        $zipFile->setEntryComment('test', 'comment');
@@ -979,8 +1006,10 @@ class ZipFileTest extends ZipTestCase
     */
    public function testSetInvalidCompressionLevel($compressionLevel)
    {
-        $this->setExpectedException(
-            InvalidArgumentException::class,
+        $this->expectException(
+            InvalidArgumentException::class
+        );
+        $this->expectExceptionMessage(
            'Invalid compression level. Minimum level 1. Maximum level 9'
        );

@@ -1048,7 +1077,7 @@ class ZipFileTest extends ZipTestCase
            );

            if ($contents === null) {
-                static::assertTrue(is_dir($fullExtractedFilename));
+                static::assertDirectoryExists($fullExtractedFilename);
                static::assertTrue(FilesUtil::isEmptyDir($fullExtractedFilename));
            } else {
                static::assertTrue(is_file($fullExtractedFilename));
@@ -1106,7 +1135,7 @@ class ZipFileTest extends ZipTestCase

            if (\in_array($entryName, $extractEntries, true)) {
                if ($value === null) {
-                    static::assertTrue(is_dir($fullExtractFilename));
+                    static::assertDirectoryExists($fullExtractFilename);
                    static::assertTrue(FilesUtil::isEmptyDir($fullExtractFilename));
                } else {
                    static::assertTrue(is_file($fullExtractFilename));
@@ -1114,7 +1143,7 @@ class ZipFileTest extends ZipTestCase
                    static::assertEquals($contents, $value);
                }
            } elseif ($value === null) {
-                static::assertFalse(is_dir($fullExtractFilename));
+                static::assertDirectoryDoesNotExist($fullExtractFilename);
            } else {
                static::assertFalse(is_file($fullExtractFilename));
            }
@@ -1131,7 +1160,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testExtractFail()
    {
-        $this->setExpectedException(ZipException::class, 'not found');
+        $this->expectException(ZipException::class);
+        $this->expectExceptionMessage('not found');

        $zipFile = new ZipFile();
        $zipFile['file'] = 'content';
@@ -1147,7 +1177,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testExtractFail2()
    {
-        $this->setExpectedException(ZipException::class, 'Destination is not directory');
+        $this->expectException(ZipException::class);
+        $this->expectExceptionMessage('Destination is not directory');

        $zipFile = new ZipFile();
        $zipFile['file'] = 'content';
@@ -1163,7 +1194,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testExtractFail3()
    {
-        $this->setExpectedException(ZipException::class, 'Destination is not writable directory');
+        $this->expectException(ZipException::class);
+        $this->expectExceptionMessage('Destination is not writable directory');

        if (static::skipTestForRootUser()) {
            return;
@@ -1186,8 +1218,10 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFromArrayAccessNullName()
    {
-        $this->setExpectedException(
-            InvalidArgumentException::class,
+        $this->expectException(
+            InvalidArgumentException::class
+        );
+        $this->expectExceptionMessage(
            'Key must not be null, but must contain the name of the zip entry.'
        );

@@ -1200,8 +1234,10 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFromArrayAccessEmptyName()
    {
-        $this->setExpectedException(
-            InvalidArgumentException::class,
+        $this->expectException(
+            InvalidArgumentException::class
+        );
+        $this->expectExceptionMessage(
            'Key is empty, but must contain the name of the zip entry.'
        );

@@ -1214,7 +1250,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFromStringNullContents()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Contents is null');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Contents is null');

        $zipFile = new ZipFile();
        $zipFile->addFromString('file', null);
@@ -1225,7 +1262,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFromStringNullEntryName()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Entry name is null');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Entry name is null');

        $zipFile = new ZipFile();
        $zipFile->addFromString(null, 'contents');
@@ -1236,8 +1274,10 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFromStringUnsupportedMethod()
    {
-        $this->setExpectedException(
-            ZipUnsupportMethodException::class,
+        $this->expectException(
+            ZipUnsupportMethodException::class
+        );
+        $this->expectExceptionMessage(
            'Compression method 99 (AES Encryption) is not supported.'
        );

@@ -1251,7 +1291,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFromStringEmptyEntryName()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Empty entry name');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Empty entry name');

        $zipFile = new ZipFile();
        $zipFile->addFromString('', 'contents');
@@ -1292,7 +1333,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFromStreamInvalidResource()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Stream is not resource');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Stream is not resource');

        $zipFile = new ZipFile();
        /** @noinspection PhpParamsInspection */
@@ -1304,7 +1346,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFromStreamEmptyEntryName()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Empty entry name');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Empty entry name');

        $handle = fopen(__FILE__, 'rb');

@@ -1317,8 +1360,10 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFromStreamUnsupportedMethod()
    {
-        $this->setExpectedException(
-            ZipUnsupportMethodException::class,
+        $this->expectException(
+            ZipUnsupportMethodException::class
+        );
+        $this->expectExceptionMessage(
            'Compression method 99 (AES Encryption) is not supported.'
        );

@@ -1367,7 +1412,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFileNullFileName()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Filename is null');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Filename is null');

        $zipFile = new ZipFile();
        $zipFile->addFile(null);
@@ -1378,7 +1424,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFileCantExists()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'File path/to/file is not readable');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('File path/to/file is not readable');

        $zipFile = new ZipFile();
        $zipFile->addFile('path/to/file');
@@ -1389,8 +1436,10 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFileUnsupportedMethod()
    {
-        $this->setExpectedException(
-            ZipUnsupportMethodException::class,
+        $this->expectException(
+            ZipUnsupportMethodException::class
+        );
+        $this->expectExceptionMessage(
            'Compression method 99 (AES Encryption) is not supported.'
        );

@@ -1412,7 +1461,8 @@ class ZipFileTest extends ZipTestCase
            return;
        }

-        $this->setExpectedException(InvalidArgumentException::class, 'is not readable');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('is not readable');

        static::assertNotFalse(file_put_contents($this->outputFilename, ''));
        static::assertTrue(chmod($this->outputFilename, 0244));
@@ -1426,7 +1476,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddDirNullDirname()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Input dir is null');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Input dir is null');

        $zipFile = new ZipFile();
        $zipFile->addDir(null);
@@ -1437,7 +1488,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddDirEmptyDirname()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The input directory is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The input directory is not specified');

        $zipFile = new ZipFile();
        $zipFile->addDir('');
@@ -1448,7 +1500,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddDirCantExists()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'does not exist');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('does not exist');

        $zipFile = new ZipFile();
        $zipFile->addDir(uniqid('', false));
@@ -1459,7 +1512,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddDirRecursiveNullDirname()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Input dir is null');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Input dir is null');

        $zipFile = new ZipFile();
        $zipFile->addDirRecursive(null);
@@ -1470,7 +1524,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddDirRecursiveEmptyDirname()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The input directory is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The input directory is not specified');

        $zipFile = new ZipFile();
        $zipFile->addDirRecursive('');
@@ -1481,7 +1536,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddDirRecursiveCantExists()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'does not exist');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('does not exist');

        $zipFile = new ZipFile();
        $zipFile->addDirRecursive(uniqid('', false));
@@ -1492,7 +1548,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromGlobNull()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Input dir is null');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Input dir is null');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromGlob(null, '*.png');
@@ -1503,7 +1560,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromGlobEmpty()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The input directory is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The input directory is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromGlob('', '*.png');
@@ -1514,7 +1572,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromGlobCantExists()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'does not exist');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('does not exist');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromGlob('path/to/path', '*.png');
@@ -1525,7 +1584,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromGlobNullPattern()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The glob pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The glob pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromGlob(__DIR__, null);
@@ -1536,7 +1596,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromGlobEmptyPattern()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The glob pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The glob pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromGlob(__DIR__, '');
@@ -1547,7 +1608,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromGlobRecursiveNull()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Input dir is null');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Input dir is null');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromGlobRecursive(null, '*.png');
@@ -1558,7 +1620,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromGlobRecursiveEmpty()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The input directory is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The input directory is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromGlobRecursive('', '*.png');
@@ -1569,7 +1632,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromGlobRecursiveCantExists()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'does not exist');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('does not exist');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromGlobRecursive('path/to/path', '*.png');
@@ -1580,7 +1644,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromGlobRecursiveNullPattern()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The glob pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The glob pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromGlobRecursive(__DIR__, null);
@@ -1591,7 +1656,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromGlobRecursiveEmptyPattern()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The glob pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The glob pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromGlobRecursive(__DIR__, '');
@@ -1602,7 +1668,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromRegexDirectoryNull()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The input directory is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The input directory is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromRegex(null, '~\.png$~i');
@@ -1613,7 +1680,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromRegexDirectoryEmpty()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The input directory is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The input directory is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromRegex('', '~\.png$~i');
@@ -1624,7 +1692,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromRegexCantExists()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'does not exist');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('does not exist');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromRegex('path/to/path', '~\.png$~i');
@@ -1635,7 +1704,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromRegexNullPattern()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The regex pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The regex pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromRegex(__DIR__, null);
@@ -1646,7 +1716,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromRegexEmptyPattern()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The regex pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The regex pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromRegex(__DIR__, '');
@@ -1657,7 +1728,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromRegexRecursiveDirectoryNull()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The input directory is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The input directory is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromRegexRecursive(null, '~\.png$~i');
@@ -1668,7 +1740,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromRegexRecursiveEmpty()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The input directory is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The input directory is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromRegexRecursive('', '~\.png$~i');
@@ -1679,7 +1752,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromRegexRecursiveCantExists()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'does not exist');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('does not exist');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromGlobRecursive('path/to/path', '~\.png$~i');
@@ -1690,7 +1764,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromRegexRecursiveNullPattern()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The regex pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The regex pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromRegexRecursive(__DIR__, null);
@@ -1701,7 +1776,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddFilesFromRegexRecursiveEmptyPattern()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'The regex pattern is not specified');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The regex pattern is not specified');

        $zipFile = new ZipFile();
        $zipFile->addFilesFromRegexRecursive(__DIR__, '');
@@ -1712,7 +1788,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testSaveAsStreamBadStream()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'handle is not resource');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('handle is not resource');

        $zipFile = new ZipFile();
        /** @noinspection PhpParamsInspection */
@@ -1737,7 +1814,8 @@ class ZipFileTest extends ZipTestCase

        $this->outputFilename = $this->outputDirname . \DIRECTORY_SEPARATOR . basename($this->outputFilename);

-        $this->setExpectedExceptionRegExp(InvalidArgumentException::class, '~Cannot open ".*?" for writing.~');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessageMatches('~Cannot open ".*?" for writing.~');

        $zipFile = new ZipFile();
        $zipFile->saveAsFile($this->outputFilename);
@@ -1752,7 +1830,7 @@ class ZipFileTest extends ZipTestCase
    public function testZipFileArrayAccessAndCountableAndIterator()
    {
        $files = [];
-        $numFiles = mt_rand(20, 100);
+        $numFiles = random_int(20, 100);
        for ($i = 0; $i < $numFiles; $i++) {
            $files['file' . $i . '.txt'] = random_bytes(255);
        }
@@ -1894,7 +1972,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddEmptyDirNullName()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Entry name is null');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Entry name is null');

        $zipFile = new ZipFile();
        $zipFile->addEmptyDir(null);
@@ -1905,7 +1984,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testAddEmptyDirEmptyName()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Empty entry name');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Empty entry name');

        $zipFile = new ZipFile();
        $zipFile->addEmptyDir('');
@@ -1913,7 +1993,8 @@ class ZipFileTest extends ZipTestCase

    public function testNotFoundEntry()
    {
-        $this->setExpectedException(ZipEntryNotFoundException::class, '"bad entry name"');
+        $this->expectException(ZipEntryNotFoundException::class);
+        $this->expectExceptionMessage('"bad entry name"');

        $zipFile = new ZipFile();
        $zipFile['bad entry name'];
@@ -1960,7 +2041,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testRewriteString()
    {
-        $this->setExpectedException(ZipException::class, 'Overwrite is only supported for open local files');
+        $this->expectException(ZipException::class);
+        $this->expectExceptionMessage('Overwrite is only supported for open local files');

        $zipFile = new ZipFile();
        $zipFile['file'] = 'content';
@@ -1986,7 +2068,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testRewriteNullStream()
    {
-        $this->setExpectedException(ZipException::class, 'input stream is null');
+        $this->expectException(ZipException::class);
+        $this->expectExceptionMessage('input stream is null');

        $zipFile = new ZipFile();
        $zipFile->rewrite();
@@ -2177,7 +2260,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testInvalidCompressionLevel()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Invalid compression level');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Invalid compression level');

        $zipFile = new ZipFile();
        $zipFile->addFromString('file', 'content');
@@ -2189,7 +2273,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testInvalidCompressionLevelEntry()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Invalid compression level');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Invalid compression level');

        $zipFile = new ZipFile();
        $zipFile->addFromString('file', 'content');
@@ -2249,8 +2334,10 @@ class ZipFileTest extends ZipTestCase
     */
    public function testInvalidCompressionMethodEntry()
    {
-        $this->setExpectedException(
-            ZipUnsupportMethodException::class,
+        $this->expectException(
+            ZipUnsupportMethodException::class
+        );
+        $this->expectExceptionMessage(
            'Compression method 99 (AES Encryption) is not supported.'
        );

@@ -2428,7 +2515,7 @@ class ZipFileTest extends ZipTestCase
    {
        for ($i = 0; $i < 2; $i++) {
            $fp = $zipFile->getEntryStream($entryName);
-            static::assertInternalType('resource', $fp);
+            static::assertIsResource($fp);
            static::assertSame(stream_get_contents($fp), $contents);
            fclose($fp);
        }
@@ -2566,7 +2653,8 @@ class ZipFileTest extends ZipTestCase
     */
    public function testNoData()
    {
-        $this->setExpectedException(ZipException::class, 'No data for zip entry file');
+        $this->expectException(ZipException::class);
+        $this->expectExceptionMessage('No data for zip entry file');

        $entryName = 'file';

--- a/tests/ZipInfoTest.php
+++ b/tests/ZipInfoTest.php
@@ -54,8 +54,10 @@ final class ZipInfoTest extends ZipTestCase
     */
    public function testZipInfoEntryNotFound()
    {
-        $this->setExpectedException(
-            ZipEntryNotFoundException::class,
+        $this->expectException(
+            ZipEntryNotFoundException::class
+        );
+        $this->expectExceptionMessage(
            'Zip Entry "unknown.name" was not found in the archive.'
        );

--- a/tests/ZipMatcherTest.php
+++ b/tests/ZipMatcherTest.php
@@ -24,7 +24,7 @@ class ZipMatcherTest extends TestCase
        $matcher = $zipFile->matcher();
        static::assertInstanceOf(ZipEntryMatcher::class, $matcher);

-        static::assertInternalType('array', $matcher->getMatches());
+        static::assertIsArray($matcher->getMatches());
        static::assertCount(0, $matcher);

        $matcher->add(1)->add(10)->add(20);
--- a/tests/ZipPasswordTest.php
+++ b/tests/ZipPasswordTest.php
@@ -31,10 +31,8 @@ class ZipPasswordTest extends ZipFileSetTestCase
    public function testSetPassword()
    {
        if (\PHP_INT_SIZE === 4) { // php 32 bit
-            $this->setExpectedException(
-                RuntimeException::class,
-                'Traditional PKWARE Encryption is not supported in 32-bit PHP.'
-            );
+            $this->expectException(RuntimeException::class);
+            $this->expectExceptionMessage('Traditional PKWARE Encryption is not supported in 32-bit PHP.');
        }

        $password = base64_encode(random_bytes(100));
@@ -66,10 +64,10 @@ class ZipPasswordTest extends ZipFileSetTestCase

        foreach ($zipFile->getAllInfo() as $info) {
            static::assertTrue($info->isEncrypted());
-            static::assertContains('Traditional PKWARE encryption', $info->getEncryptionMethodName());
+            static::assertStringContainsString('Traditional PKWARE encryption', $info->getEncryptionMethodName());
            $decryptContent = $zipFile[$info->getName()];
            static::assertNotEmpty($decryptContent);
-            static::assertContains('<?php', $decryptContent);
+            static::assertStringContainsString('<?php', $decryptContent);
        }

        // change encryption method to WinZip Aes and update file
@@ -100,11 +98,11 @@ class ZipPasswordTest extends ZipFileSetTestCase

        foreach ($zipFile->getAllInfo() as $info) {
            static::assertTrue($info->isEncrypted());
-            static::assertContains('Deflated', $info->getMethodName());
-            static::assertContains('WinZip AES-256', $info->getEncryptionMethodName());
+            static::assertStringContainsString('Deflated', $info->getMethodName());
+            static::assertStringContainsString('WinZip AES-256', $info->getEncryptionMethodName());
            $decryptContent = $zipFile[$info->getName()];
            static::assertNotEmpty($decryptContent);
-            static::assertContains('<?php', $decryptContent);
+            static::assertStringContainsString('<?php', $decryptContent);
        }

        // clear password
@@ -132,8 +130,10 @@ class ZipPasswordTest extends ZipFileSetTestCase
    public function testTraditionalEncryption()
    {
        if (\PHP_INT_SIZE === 4) { // php 32 bit
-            $this->setExpectedException(
-                RuntimeException::class,
+            $this->expectException(
+                RuntimeException::class
+            );
+            $this->expectExceptionMessage(
                'Traditional PKWARE Encryption is not supported in 32-bit PHP.'
            );
        }
@@ -155,7 +155,7 @@ class ZipPasswordTest extends ZipFileSetTestCase
        foreach ($zip->getAllInfo() as $info) {
            if (!$info->isFolder()) {
                static::assertTrue($info->isEncrypted());
-                static::assertContains('Traditional PKWARE encryption', $info->getEncryptionMethodName());
+                static::assertStringContainsString('Traditional PKWARE encryption', $info->getEncryptionMethodName());
            }
        }
        $zip->close();
@@ -190,7 +190,7 @@ class ZipPasswordTest extends ZipFileSetTestCase
            if (!$info->isFolder()) {
                static::assertTrue($info->isEncrypted());
                static::assertSame($info->getEncryptionMethod(), $encryptionMethod);
-                static::assertContains('WinZip AES-' . $bitSize, $info->getEncryptionMethodName());
+                static::assertStringContainsString('WinZip AES-' . $bitSize, $info->getEncryptionMethodName());
            }
        }
        $zip->close();
@@ -215,8 +215,10 @@ class ZipPasswordTest extends ZipFileSetTestCase
    public function testEncryptionEntries()
    {
        if (\PHP_INT_SIZE === 4) { // php 32 bit
-            $this->setExpectedException(
-                RuntimeException::class,
+            $this->expectException(
+                RuntimeException::class
+            );
+            $this->expectExceptionMessage(
                'Traditional PKWARE Encryption is not supported in 32-bit PHP.'
            );
        }
@@ -247,11 +249,11 @@ class ZipPasswordTest extends ZipFileSetTestCase

        $info = $zip->getEntryInfo('.hidden');
        static::assertTrue($info->isEncrypted());
-        static::assertContains('Traditional PKWARE encryption', $info->getEncryptionMethodName());
+        static::assertStringContainsString('Traditional PKWARE encryption', $info->getEncryptionMethodName());

        $info = $zip->getEntryInfo('text file.txt');
        static::assertTrue($info->isEncrypted());
-        static::assertContains('WinZip AES', $info->getEncryptionMethodName());
+        static::assertStringContainsString('WinZip AES', $info->getEncryptionMethodName());

        static::assertFalse($zip->getEntryInfo('Текстовый документ.txt')->isEncrypted());
        static::assertFalse($zip->getEntryInfo('empty dir/')->isEncrypted());
@@ -266,8 +268,10 @@ class ZipPasswordTest extends ZipFileSetTestCase
    public function testEncryptionEntriesWithDefaultPassword()
    {
        if (\PHP_INT_SIZE === 4) { // php 32 bit
-            $this->setExpectedException(
-                RuntimeException::class,
+            $this->expectException(
+                RuntimeException::class
+            );
+            $this->expectExceptionMessage(
                'Traditional PKWARE Encryption is not supported in 32-bit PHP.'
            );
        }
@@ -301,15 +305,15 @@ class ZipPasswordTest extends ZipFileSetTestCase

        $info = $zip->getEntryInfo('.hidden');
        static::assertTrue($info->isEncrypted());
-        static::assertContains('Traditional PKWARE encryption', $info->getEncryptionMethodName());
+        static::assertStringContainsString('Traditional PKWARE encryption', $info->getEncryptionMethodName());

        $info = $zip->getEntryInfo('text file.txt');
        static::assertTrue($info->isEncrypted());
-        static::assertContains('WinZip AES', $info->getEncryptionMethodName());
+        static::assertStringContainsString('WinZip AES', $info->getEncryptionMethodName());

        $info = $zip->getEntryInfo('Текстовый документ.txt');
        static::assertTrue($info->isEncrypted());
-        static::assertContains('WinZip AES', $info->getEncryptionMethodName());
+        static::assertStringContainsString('WinZip AES', $info->getEncryptionMethodName());

        static::assertFalse($zip->getEntryInfo('empty dir/')->isEncrypted());

@@ -321,7 +325,8 @@ class ZipPasswordTest extends ZipFileSetTestCase
     */
    public function testSetEncryptionMethodInvalid()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Encryption method 9999 is not supported.');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Encryption method 9999 is not supported.');

        $zipFile = new ZipFile();
        $encryptionMethod = 9999;
@@ -369,7 +374,8 @@ class ZipPasswordTest extends ZipFileSetTestCase
     */
    public function testInvalidEncryptionMethodEntry()
    {
-        $this->setExpectedException(InvalidArgumentException::class, 'Encryption method 99 is not supported.');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Encryption method 99 is not supported.');

        $zipFile = new ZipFile();
        $zipFile->addFromString('file', 'content', ZipCompressionMethod::STORED);
@@ -471,7 +477,7 @@ class ZipPasswordTest extends ZipFileSetTestCase
        foreach ($zipFile as $name => $contents) {
            static::assertNotEmpty($name);
            static::assertNotEmpty($contents);
-            static::assertContains('test contents', $contents);
+            static::assertStringContainsString('test contents', $contents);
            static::assertSame($zipFile2[$name], $contents);
        }
        $zipFile2->close();
--- a/tests/ZipStreamOpenTest.php
+++ b/tests/ZipStreamOpenTest.php
@@ -31,18 +31,18 @@ class ZipStreamOpenTest extends TestCase
    {
        if ($resource === null || $resource === false) {
            static::markTestSkipped('skip resource');
-
-            return;
        }

        if ($exceptionClass !== null) {
-            $this->setExpectedException(
-                $exceptionClass,
+            $this->expectException(
+                $exceptionClass
+            );
+            $this->expectExceptionMessage(
                $exceptionMessage
            );
        }

-        static::assertInternalType('resource', $resource);
+        static::assertIsResource($resource);

        $zipFile = new ZipFile();
        $zipFile->openFromStream($resource);
--- a/tests/ZipTestCase.php
+++ b/tests/ZipTestCase.php
@@ -2,14 +2,14 @@

 namespace PhpZip\Tests;

-use PHPUnit\Framework\TestCase;
 use PhpZip\Constants\ZipConstants;
+use PhpZip\Tests\Polyfill\LegacyTestCase;
 use PhpZip\Util\FilesUtil;

 /**
 * PHPUnit test case and helper methods.
 */
-abstract class ZipTestCase extends TestCase
+abstract class ZipTestCase extends LegacyTestCase
 {
    /** @var string */
    protected $outputFilename;
@@ -22,7 +22,7 @@ abstract class ZipTestCase extends TestCase
     *
     * @noinspection PhpMissingParentCallCommonInspection
     */
-    protected function setUp()
+    protected function setUp(): void
    {
        $id = uniqid('phpzip', false);
        $tempDir = sys_get_temp_dir() . \DIRECTORY_SEPARATOR . 'phpunit-phpzip';
@@ -37,10 +37,8 @@ abstract class ZipTestCase extends TestCase
    /**
     * After test.
     */
-    protected function tearDown()
+    protected function tearDown(): void
    {
-        parent::tearDown();
-
        if ($this->outputFilename !== null && file_exists($this->outputFilename)) {
            unlink($this->outputFilename);
        }
@@ -92,8 +90,8 @@ abstract class ZipTestCase extends TestCase
        $output = implode(\PHP_EOL, $output);

        static::assertSame($returnCode, 0);
-        static::assertNotContains(' Errors', $output);
-        static::assertContains(' Ok', $output);
+        static::assertStringNotContainsString(' Errors', $output);
+        static::assertStringContainsString(' Ok', $output);
    }

    /**
@@ -123,8 +121,8 @@ abstract class ZipTestCase extends TestCase

        static::assertSame($returnCode, 0, $output);
        static::assertNotContains('incorrect password', $output);
-        static::assertContains(' OK', $output);
-        static::assertContains('No errors', $output);
+        static::assertStringContainsString(' OK', $output);
+        static::assertStringContainsString('No errors', $output);
    }

    /**
@@ -135,9 +133,9 @@ abstract class ZipTestCase extends TestCase
     */
    protected static function existsProgram($program, array $successCodes = [0])
    {
-        $command = \DIRECTORY_SEPARATOR === '\\' ?
-            escapeshellarg($program) :
-            'which ' . escapeshellarg($program);
+        $command = \DIRECTORY_SEPARATOR === '\\'
+            ? escapeshellarg($program)
+            : 'which ' . escapeshellarg($program);
        $command .= ' 2>&1';

        exec($command, $output, $returnCode);
@@ -157,7 +155,7 @@ abstract class ZipTestCase extends TestCase

            $output = implode(\PHP_EOL, $output);

-            static::assertContains('Empty zipfile', $output);
+            static::assertStringContainsString('Empty zipfile', $output);
        }
        $actualEmptyZipData = pack('VVVVVv', ZipConstants::END_CD, 0, 0, 0, 0, 0);
        static::assertStringEqualsFile($filename, $actualEmptyZipData);
@@ -189,7 +187,7 @@ abstract class ZipTestCase extends TestCase
        fwrite(\STDERR, 'Install on Windows:' . \PHP_EOL);
        fwrite(\STDERR, ' 1. Install Android Studio' . \PHP_EOL);
        fwrite(\STDERR, ' 2. Install Android Sdk' . \PHP_EOL);
-        fwrite(\STDERR, ' 3. Add zipalign path to \$Path' . \PHP_EOL);
+        fwrite(\STDERR, ' 3. Add zipalign path to $Path' . \PHP_EOL);

        return null;
    }