ALPHA 3.0.2a

vendor/sebastian/comparator/ChangeLog.md

@@ -2,6 +2,12 @@
 
 All notable changes are documented in this file using the [Keep a CHANGELOG](http://keepachangelog.com/) principles.
 
+## [3.0.2] - 2018-07-12
+
+### Changed
+
+* By default, `MockObjectComparator` is now tried before all other (default) comparators
+
 ## [3.0.1] - 2018-06-14
 
 ### Fixed
@@ -44,6 +50,7 @@ All notable changes are documented in this file using the [Keep a CHANGELOG](htt
 * Added `SebastianBergmann\Comparator\Factory::reset()` to unregister all non-default comparators
 * Added support for `phpunit/phpunit-mock-objects` version `^5.0`
 
+[3.0.2]: https://github.com/sebastianbergmann/comparator/compare/3.0.1...3.0.2
 [3.0.1]: https://github.com/sebastianbergmann/comparator/compare/3.0.0...3.0.1
 [3.0.0]: https://github.com/sebastianbergmann/comparator/compare/2.1.3...3.0.0
 [2.1.3]: https://github.com/sebastianbergmann/comparator/compare/2.1.2...2.1.3

vendor/sebastian/comparator/src/Factory.php

@@ -115,23 +115,23 @@ class Factory
 
     private function registerDefaultComparators()
     {
-        $this->registerDefaultComparator(new TypeComparator);
-        $this->registerDefaultComparator(new ScalarComparator);
-        $this->registerDefaultComparator(new NumericComparator);
-        $this->registerDefaultComparator(new DoubleComparator);
-        $this->registerDefaultComparator(new ArrayComparator);
-        $this->registerDefaultComparator(new ResourceComparator);
-        $this->registerDefaultComparator(new ObjectComparator);
-        $this->registerDefaultComparator(new ExceptionComparator);
-        $this->registerDefaultComparator(new SplObjectStorageComparator);
-        $this->registerDefaultComparator(new DOMNodeComparator);
         $this->registerDefaultComparator(new MockObjectComparator);
         $this->registerDefaultComparator(new DateTimeComparator);
+        $this->registerDefaultComparator(new DOMNodeComparator);
+        $this->registerDefaultComparator(new SplObjectStorageComparator);
+        $this->registerDefaultComparator(new ExceptionComparator);
+        $this->registerDefaultComparator(new ObjectComparator);
+        $this->registerDefaultComparator(new ResourceComparator);
+        $this->registerDefaultComparator(new ArrayComparator);
+        $this->registerDefaultComparator(new DoubleComparator);
+        $this->registerDefaultComparator(new NumericComparator);
+        $this->registerDefaultComparator(new ScalarComparator);
+        $this->registerDefaultComparator(new TypeComparator);
     }
 
     private function registerDefaultComparator(Comparator $comparator)
     {
-        \array_unshift($this->defaultComparators, $comparator);
+        $this->defaultComparators[] = $comparator;
 
         $comparator->setFactory($this);
     }

vendor/sebastian/comparator/src/NumericComparator.php

@@ -45,7 +45,7 @@ class NumericComparator extends ScalarComparator
     public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
     {
         if (\is_infinite($actual) && \is_infinite($expected)) {
-            return;
+            return; // @codeCoverageIgnore
         }
 
         if ((\is_infinite($actual) xor \is_infinite($expected)) ||

vendor/sebastian/comparator/tests/ArrayComparatorTest.php

@@ -12,20 +12,20 @@ namespace SebastianBergmann\Comparator;
 use PHPUnit\Framework\TestCase;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\ArrayComparator
+ * @covers \SebastianBergmann\Comparator\ArrayComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class ArrayComparatorTest extends TestCase
+final class ArrayComparatorTest extends TestCase
 {
     /**
      * @var ArrayComparator
      */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new ArrayComparator;
         $this->comparator->setFactory(new Factory);
@@ -116,10 +116,7 @@ class ArrayComparatorTest extends TestCase
         ];
     }
 
-    /**
-     * @covers  ::accepts
-     */
-    public function testAcceptsSucceeds()
+    public function testAcceptsSucceeds(): void
     {
         $this->assertTrue(
           $this->comparator->accepts([], [])
@@ -127,10 +124,9 @@ class ArrayComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsFailsProvider
      */
-    public function testAcceptsFails($expected, $actual)
+    public function testAcceptsFails($expected, $actual): void
     {
         $this->assertFalse(
           $this->comparator->accepts($expected, $actual)
@@ -138,10 +134,9 @@ class ArrayComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
      */
-    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0, $canonicalize = false)
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0, $canonicalize = false): void
     {
         $exception = null;
 
@@ -154,10 +149,9 @@ class ArrayComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual, $delta = 0.0, $canonicalize = false)
+    public function testAssertEqualsFails($expected, $actual, $delta = 0.0, $canonicalize = false): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage('Failed asserting that two arrays are equal');

vendor/sebastian/comparator/tests/ComparisonFailureTest.php

@@ -12,11 +12,13 @@ namespace SebastianBergmann\Comparator;
 use PHPUnit\Framework\TestCase;
 
 /**
- * @covers SebastianBergmann\Comparator\ComparisonFailure
+ * @covers \SebastianBergmann\Comparator\ComparisonFailure
+ *
+ * @uses \SebastianBergmann\Comparator\Factory
  */
 final class ComparisonFailureTest extends TestCase
 {
-    public function testComparisonFailure()
+    public function testComparisonFailure(): void
     {
         $actual   = "\nB\n";
         $expected = "\nA\n";
@@ -48,7 +50,7 @@ final class ComparisonFailureTest extends TestCase
         $this->assertSame($message . $diff, $failure->toString());
     }
 
-    public function testDiffNotPossible()
+    public function testDiffNotPossible(): void
     {
         $failure = new ComparisonFailure('a', 'b', false, false, true, 'test');
         $this->assertSame('', $failure->getDiff());

vendor/sebastian/comparator/tests/DOMNodeComparatorTest.php

@@ -14,17 +14,20 @@ use DOMNode;
 use PHPUnit\Framework\TestCase;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\DOMNodeComparator
+ * @covers \SebastianBergmann\Comparator\DOMNodeComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class DOMNodeComparatorTest extends TestCase
+final class DOMNodeComparatorTest extends TestCase
 {
+    /**
+     * @var DOMNodeComparator
+     */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new DOMNodeComparator;
     }
@@ -119,10 +122,9 @@ class DOMNodeComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsSucceedsProvider
      */
-    public function testAcceptsSucceeds($expected, $actual)
+    public function testAcceptsSucceeds($expected, $actual): void
     {
         $this->assertTrue(
           $this->comparator->accepts($expected, $actual)
@@ -130,10 +132,9 @@ class DOMNodeComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsFailsProvider
      */
-    public function testAcceptsFails($expected, $actual)
+    public function testAcceptsFails($expected, $actual): void
     {
         $this->assertFalse(
           $this->comparator->accepts($expected, $actual)
@@ -141,12 +142,9 @@ class DOMNodeComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
-     *
-     * @param bool $ignoreCase
      */
-    public function testAssertEqualsSucceeds($expected, $actual, $ignoreCase = false)
+    public function testAssertEqualsSucceeds($expected, $actual, $ignoreCase = false): void
     {
         $exception = null;
 
@@ -161,10 +159,9 @@ class DOMNodeComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual)
+    public function testAssertEqualsFails($expected, $actual): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage('Failed asserting that two DOM');

vendor/sebastian/comparator/tests/DateTimeComparatorTest.php

@@ -15,20 +15,20 @@ use DateTimeZone;
 use PHPUnit\Framework\TestCase;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\DateTimeComparator
+ * @covers \SebastianBergmann\Comparator\DateTimeComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class DateTimeComparatorTest extends TestCase
+final class DateTimeComparatorTest extends TestCase
 {
     /**
      * @var DateTimeComparator
      */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new DateTimeComparator;
     }
@@ -150,10 +150,7 @@ class DateTimeComparatorTest extends TestCase
         ];
     }
 
-    /**
-     * @covers  ::accepts
-     */
-    public function testAcceptsSucceeds()
+    public function testAcceptsSucceeds(): void
     {
         $this->assertTrue(
             $this->comparator->accepts(
@@ -164,10 +161,9 @@ class DateTimeComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsFailsProvider
      */
-    public function testAcceptsFails($expected, $actual)
+    public function testAcceptsFails($expected, $actual): void
     {
         $this->assertFalse(
             $this->comparator->accepts($expected, $actual)
@@ -175,10 +171,9 @@ class DateTimeComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
      */
-    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0)
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void
     {
         $exception = null;
 
@@ -191,10 +186,9 @@ class DateTimeComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual, $delta = 0.0)
+    public function testAssertEqualsFails($expected, $actual, $delta = 0.0): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage('Failed asserting that two DateTime objects are equal.');
@@ -202,20 +196,12 @@ class DateTimeComparatorTest extends TestCase
         $this->comparator->assertEquals($expected, $actual, $delta);
     }
 
-    /**
-     * @requires PHP 5.5
-     * @covers   ::accepts
-     */
-    public function testAcceptsDateTimeInterface()
+    public function testAcceptsDateTimeInterface(): void
     {
         $this->assertTrue($this->comparator->accepts(new DateTime, new DateTimeImmutable));
     }
 
-    /**
-     * @requires PHP 5.5
-     * @covers   ::assertEquals
-     */
-    public function testSupportsDateTimeInterface()
+    public function testSupportsDateTimeInterface(): void
     {
         $this->assertNull(
             $this->comparator->assertEquals(

vendor/sebastian/comparator/tests/DoubleComparatorTest.php

@@ -12,17 +12,20 @@ namespace SebastianBergmann\Comparator;
 use PHPUnit\Framework\TestCase;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\DoubleComparator
+ * @covers \SebastianBergmann\Comparator\DoubleComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class DoubleComparatorTest extends TestCase
+final class DoubleComparatorTest extends TestCase
 {
+    /**
+     * @var DoubleComparator
+     */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new DoubleComparator;
     }
@@ -85,10 +88,9 @@ class DoubleComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsSucceedsProvider
      */
-    public function testAcceptsSucceeds($expected, $actual)
+    public function testAcceptsSucceeds($expected, $actual): void
     {
         $this->assertTrue(
           $this->comparator->accepts($expected, $actual)
@@ -96,10 +98,9 @@ class DoubleComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsFailsProvider
      */
-    public function testAcceptsFails($expected, $actual)
+    public function testAcceptsFails($expected, $actual): void
     {
         $this->assertFalse(
           $this->comparator->accepts($expected, $actual)
@@ -107,10 +108,9 @@ class DoubleComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
      */
-    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0)
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void
     {
         $exception = null;
 
@@ -123,10 +123,9 @@ class DoubleComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual, $delta = 0.0)
+    public function testAssertEqualsFails($expected, $actual, $delta = 0.0): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage('matches expected');

vendor/sebastian/comparator/tests/ExceptionComparatorTest.php

@@ -14,17 +14,20 @@ use PHPUnit\Framework\TestCase;
 use RuntimeException;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\ExceptionComparator
+ * @covers \SebastianBergmann\Comparator\ExceptionComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class ExceptionComparatorTest extends TestCase
+final class ExceptionComparatorTest extends TestCase
 {
+    /**
+     * @var ExceptionComparator
+     */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new ExceptionComparator;
         $this->comparator->setFactory(new Factory);
@@ -86,10 +89,9 @@ class ExceptionComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsSucceedsProvider
      */
-    public function testAcceptsSucceeds($expected, $actual)
+    public function testAcceptsSucceeds($expected, $actual): void
     {
         $this->assertTrue(
           $this->comparator->accepts($expected, $actual)
@@ -97,10 +99,9 @@ class ExceptionComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsFailsProvider
      */
-    public function testAcceptsFails($expected, $actual)
+    public function testAcceptsFails($expected, $actual): void
     {
         $this->assertFalse(
           $this->comparator->accepts($expected, $actual)
@@ -108,10 +109,9 @@ class ExceptionComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
      */
-    public function testAssertEqualsSucceeds($expected, $actual)
+    public function testAssertEqualsSucceeds($expected, $actual): void
     {
         $exception = null;
 
@@ -124,10 +124,9 @@ class ExceptionComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual, $message)
+    public function testAssertEqualsFails($expected, $actual, $message): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage($message);

vendor/sebastian/comparator/tests/FactoryTest.php

@@ -12,13 +12,13 @@ namespace SebastianBergmann\Comparator;
 use PHPUnit\Framework\TestCase;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\Factory
+ * @covers \SebastianBergmann\Comparator\Factory
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class FactoryTest extends TestCase
+final class FactoryTest extends TestCase
 {
     public function instanceProvider()
     {
@@ -69,20 +69,15 @@ class FactoryTest extends TestCase
 
     /**
      * @dataProvider instanceProvider
-     * @covers       ::getComparatorFor
-     * @covers       ::__construct
      */
-    public function testGetComparatorFor($a, $b, $expected)
+    public function testGetComparatorFor($a, $b, $expected): void
     {
         $factory = new Factory;
         $actual  = $factory->getComparatorFor($a, $b);
         $this->assertInstanceOf($expected, $actual);
     }
 
-    /**
-     * @covers ::register
-     */
-    public function testRegister()
+    public function testRegister(): void
     {
         $comparator = new TestClassComparator;
 
@@ -98,10 +93,7 @@ class FactoryTest extends TestCase
         $this->assertInstanceOf($expected, $actual);
     }
 
-    /**
-     * @covers ::unregister
-     */
-    public function testUnregister()
+    public function testUnregister(): void
     {
         $comparator = new TestClassComparator;
 
@@ -117,7 +109,7 @@ class FactoryTest extends TestCase
         $this->assertInstanceOf($expected, $actual);
     }
 
-    public function testIsSingleton()
+    public function testIsSingleton(): void
     {
         $f = Factory::getInstance();
         $this->assertSame($f, Factory::getInstance());

vendor/sebastian/comparator/tests/MockObjectComparatorTest.php

@@ -13,17 +13,20 @@ use PHPUnit\Framework\TestCase;
 use stdClass;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\MockObjectComparator
+ * @covers \SebastianBergmann\Comparator\MockObjectComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class MockObjectComparatorTest extends TestCase
+final class MockObjectComparatorTest extends TestCase
 {
+    /**
+     * @var MockObjectComparator
+     */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new MockObjectComparator;
         $this->comparator->setFactory(new Factory);
@@ -118,10 +121,9 @@ class MockObjectComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsSucceedsProvider
      */
-    public function testAcceptsSucceeds($expected, $actual)
+    public function testAcceptsSucceeds($expected, $actual): void
     {
         $this->assertTrue(
           $this->comparator->accepts($expected, $actual)
@@ -129,10 +131,9 @@ class MockObjectComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsFailsProvider
      */
-    public function testAcceptsFails($expected, $actual)
+    public function testAcceptsFails($expected, $actual): void
     {
         $this->assertFalse(
           $this->comparator->accepts($expected, $actual)
@@ -140,10 +141,9 @@ class MockObjectComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
      */
-    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0)
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void
     {
         $exception = null;
 
@@ -156,10 +156,9 @@ class MockObjectComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0)
+    public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage($message);

vendor/sebastian/comparator/tests/NumericComparatorTest.php

@@ -12,17 +12,20 @@ namespace SebastianBergmann\Comparator;
 use PHPUnit\Framework\TestCase;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\NumericComparator
+ * @covers \SebastianBergmann\Comparator\NumericComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class NumericComparatorTest extends TestCase
+final class NumericComparatorTest extends TestCase
 {
+    /**
+     * @var NumericComparator
+     */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new NumericComparator;
     }
@@ -73,10 +76,9 @@ class NumericComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsSucceedsProvider
      */
-    public function testAcceptsSucceeds($expected, $actual)
+    public function testAcceptsSucceeds($expected, $actual): void
     {
         $this->assertTrue(
           $this->comparator->accepts($expected, $actual)
@@ -84,10 +86,9 @@ class NumericComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsFailsProvider
      */
-    public function testAcceptsFails($expected, $actual)
+    public function testAcceptsFails($expected, $actual): void
     {
         $this->assertFalse(
           $this->comparator->accepts($expected, $actual)
@@ -95,10 +96,9 @@ class NumericComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
      */
-    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0)
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void
     {
         $exception = null;
 
@@ -111,10 +111,9 @@ class NumericComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual, $delta = 0.0)
+    public function testAssertEqualsFails($expected, $actual, $delta = 0.0): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage('matches expected');

vendor/sebastian/comparator/tests/ObjectComparatorTest.php

@@ -13,17 +13,20 @@ use PHPUnit\Framework\TestCase;
 use stdClass;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\ObjectComparator
+ * @covers \SebastianBergmann\Comparator\ObjectComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class ObjectComparatorTest extends TestCase
+final class ObjectComparatorTest extends TestCase
 {
+    /**
+     * @var ObjectComparator
+     */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new ObjectComparator;
         $this->comparator->setFactory(new Factory);
@@ -100,10 +103,9 @@ class ObjectComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsSucceedsProvider
      */
-    public function testAcceptsSucceeds($expected, $actual)
+    public function testAcceptsSucceeds($expected, $actual): void
     {
         $this->assertTrue(
           $this->comparator->accepts($expected, $actual)
@@ -111,10 +113,9 @@ class ObjectComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsFailsProvider
      */
-    public function testAcceptsFails($expected, $actual)
+    public function testAcceptsFails($expected, $actual): void
     {
         $this->assertFalse(
           $this->comparator->accepts($expected, $actual)
@@ -122,10 +123,9 @@ class ObjectComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
      */
-    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0)
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void
     {
         $exception = null;
 
@@ -138,10 +138,9 @@ class ObjectComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0)
+    public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage($message);

vendor/sebastian/comparator/tests/ResourceComparatorTest.php

@@ -12,17 +12,20 @@ namespace SebastianBergmann\Comparator;
 use PHPUnit\Framework\TestCase;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\ResourceComparator
+ * @covers \SebastianBergmann\Comparator\ResourceComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class ResourceComparatorTest extends TestCase
+final class ResourceComparatorTest extends TestCase
 {
+    /**
+     * @var ResourceComparator
+     */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new ResourceComparator;
     }
@@ -73,10 +76,9 @@ class ResourceComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsSucceedsProvider
      */
-    public function testAcceptsSucceeds($expected, $actual)
+    public function testAcceptsSucceeds($expected, $actual): void
     {
         $this->assertTrue(
           $this->comparator->accepts($expected, $actual)
@@ -84,10 +86,9 @@ class ResourceComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsFailsProvider
      */
-    public function testAcceptsFails($expected, $actual)
+    public function testAcceptsFails($expected, $actual): void
     {
         $this->assertFalse(
           $this->comparator->accepts($expected, $actual)
@@ -95,10 +96,9 @@ class ResourceComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
      */
-    public function testAssertEqualsSucceeds($expected, $actual)
+    public function testAssertEqualsSucceeds($expected, $actual): void
     {
         $exception = null;
 
@@ -111,10 +111,9 @@ class ResourceComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual)
+    public function testAssertEqualsFails($expected, $actual): void
     {
         $this->expectException(ComparisonFailure::class);
 

vendor/sebastian/comparator/tests/ScalarComparatorTest.php

@@ -12,17 +12,20 @@ namespace SebastianBergmann\Comparator;
 use PHPUnit\Framework\TestCase;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\ScalarComparator
+ * @covers \SebastianBergmann\Comparator\ScalarComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class ScalarComparatorTest extends TestCase
+final class ScalarComparatorTest extends TestCase
 {
+    /**
+     * @var ScalarComparator
+     */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new ScalarComparator;
     }
@@ -114,10 +117,9 @@ class ScalarComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsSucceedsProvider
      */
-    public function testAcceptsSucceeds($expected, $actual)
+    public function testAcceptsSucceeds($expected, $actual): void
     {
         $this->assertTrue(
           $this->comparator->accepts($expected, $actual)
@@ -125,10 +127,9 @@ class ScalarComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsFailsProvider
      */
-    public function testAcceptsFails($expected, $actual)
+    public function testAcceptsFails($expected, $actual): void
     {
         $this->assertFalse(
           $this->comparator->accepts($expected, $actual)
@@ -136,10 +137,9 @@ class ScalarComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
      */
-    public function testAssertEqualsSucceeds($expected, $actual, $ignoreCase = false)
+    public function testAssertEqualsSucceeds($expected, $actual, $ignoreCase = false): void
     {
         $exception = null;
 
@@ -152,10 +152,9 @@ class ScalarComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual, $message)
+    public function testAssertEqualsFails($expected, $actual, $message): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage($message);

vendor/sebastian/comparator/tests/SplObjectStorageComparatorTest.php

@@ -14,17 +14,20 @@ use SplObjectStorage;
 use stdClass;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\SplObjectStorageComparator
+ * @covers \SebastianBergmann\Comparator\SplObjectStorageComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class SplObjectStorageComparatorTest extends TestCase
+final class SplObjectStorageComparatorTest extends TestCase
 {
+    /**
+     * @var SplObjectStorageComparator
+     */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new SplObjectStorageComparator;
     }
@@ -83,10 +86,7 @@ class SplObjectStorageComparatorTest extends TestCase
         ];
     }
 
-    /**
-     * @covers  ::accepts
-     */
-    public function testAcceptsSucceeds()
+    public function testAcceptsSucceeds(): void
     {
         $this->assertTrue(
           $this->comparator->accepts(
@@ -97,10 +97,9 @@ class SplObjectStorageComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsFailsProvider
      */
-    public function testAcceptsFails($expected, $actual)
+    public function testAcceptsFails($expected, $actual): void
     {
         $this->assertFalse(
           $this->comparator->accepts($expected, $actual)
@@ -108,10 +107,9 @@ class SplObjectStorageComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
      */
-    public function testAssertEqualsSucceeds($expected, $actual)
+    public function testAssertEqualsSucceeds($expected, $actual): void
     {
         $exception = null;
 
@@ -124,10 +122,9 @@ class SplObjectStorageComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual)
+    public function testAssertEqualsFails($expected, $actual): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage('Failed asserting that two objects are equal.');
@@ -135,7 +132,7 @@ class SplObjectStorageComparatorTest extends TestCase
         $this->comparator->assertEquals($expected, $actual);
     }
 
-    public function testAssertEqualsFails2()
+    public function testAssertEqualsFails2(): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage('Failed asserting that two objects are equal.');

vendor/sebastian/comparator/tests/TypeComparatorTest.php

@@ -13,17 +13,20 @@ use PHPUnit\Framework\TestCase;
 use stdClass;
 
 /**
- * @coversDefaultClass SebastianBergmann\Comparator\TypeComparator
+ * @covers \SebastianBergmann\Comparator\TypeComparator<extended>
  *
- * @uses SebastianBergmann\Comparator\Comparator
- * @uses SebastianBergmann\Comparator\Factory
- * @uses SebastianBergmann\Comparator\ComparisonFailure
+ * @uses \SebastianBergmann\Comparator\Comparator
+ * @uses \SebastianBergmann\Comparator\Factory
+ * @uses \SebastianBergmann\Comparator\ComparisonFailure
  */
-class TypeComparatorTest extends TestCase
+final class TypeComparatorTest extends TestCase
 {
+    /**
+     * @var TypeComparator
+     */
     private $comparator;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->comparator = new TypeComparator;
     }
@@ -67,10 +70,9 @@ class TypeComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::accepts
      * @dataProvider acceptsSucceedsProvider
      */
-    public function testAcceptsSucceeds($expected, $actual)
+    public function testAcceptsSucceeds($expected, $actual): void
     {
         $this->assertTrue(
           $this->comparator->accepts($expected, $actual)
@@ -78,10 +80,9 @@ class TypeComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsSucceedsProvider
      */
-    public function testAssertEqualsSucceeds($expected, $actual)
+    public function testAssertEqualsSucceeds($expected, $actual): void
     {
         $exception = null;
 
@@ -94,10 +95,9 @@ class TypeComparatorTest extends TestCase
     }
 
     /**
-     * @covers       ::assertEquals
      * @dataProvider assertEqualsFailsProvider
      */
-    public function testAssertEqualsFails($expected, $actual)
+    public function testAssertEqualsFails($expected, $actual): void
     {
         $this->expectException(ComparisonFailure::class);
         $this->expectExceptionMessage('does not match expected type');