diff --git a/tests/Knp/Menu/Tests/Factory/CoreExtensionTest.php b/tests/Knp/Menu/Tests/Factory/CoreExtensionTest.php
index df495f6e..a584f97f 100644
--- a/tests/Knp/Menu/Tests/Factory/CoreExtensionTest.php
+++ b/tests/Knp/Menu/Tests/Factory/CoreExtensionTest.php
@@ -7,71 +7,71 @@
 use Knp\Menu\MenuItem;
 use PHPUnit\Framework\TestCase;
 
-class CoreExtensionTest extends TestCase
+final class CoreExtensionTest extends TestCase
 {
     public function testBuildOptions(): void
     {
         $extension = $this->getExtension();
-        $item = $this->createItem( 'test' );
-
-        $options = $extension->buildOptions( [] );
-
-        $this->assertArrayHasKey( 'uri', $options );
-        $this->assertArrayHasKey( 'label', $options );
-        $this->assertArrayHasKey( 'attributes', $options );
-        $this->assertArrayHasKey( 'linkAttributes', $options );
-        $this->assertArrayHasKey( 'childrenAttributes', $options );
-        $this->assertArrayHasKey( 'labelAttributes', $options );
-        $this->assertArrayHasKey( 'extras', $options );
-        $this->assertArrayHasKey( 'current', $options );
-        $this->assertArrayHasKey( 'display', $options );
-        $this->assertArrayHasKey( 'displayChildren', $options );
+        $item = $this->createItem('test');
+
+        $options = $extension->buildOptions([]);
+
+        $this->assertArrayHasKey('uri', $options);
+        $this->assertArrayHasKey('label', $options);
+        $this->assertArrayHasKey('attributes', $options);
+        $this->assertArrayHasKey('linkAttributes', $options);
+        $this->assertArrayHasKey('childrenAttributes', $options);
+        $this->assertArrayHasKey('labelAttributes', $options);
+        $this->assertArrayHasKey('extras', $options);
+        $this->assertArrayHasKey('current', $options);
+        $this->assertArrayHasKey('display', $options);
+        $this->assertArrayHasKey('displayChildren', $options);
     }
 
     public function testBuildItemsSetsExtras(): void
     {
-        $item = $this->createItem( 'test' );
-        $item->setExtra( 'test1', 'original value' );
+        $item = $this->createItem('test');
+        $item->setExtra('test1', 'original value');
         $extension = $this->getExtension();
         $options = $extension->buildOptions(
             [
                 'extras' => [
                     'test1' => 'options value 1',
                     'test2' => 'options value 2',
-                ]
+                ],
             ]
         );
 
-        $extension->buildItem( $item, $options );
+        $extension->buildItem($item, $options);
 
         $extras = $item->getExtras();
 
-        $this->assertEquals( 2, count( $extras ) );
+        $this->assertCount(2, $extras);
 
-        $this->assertArrayHasKey( 'test1', $extras );
-        $this->assertEquals( 'options value 1', $item->getExtra( 'test1' ) );
+        $this->assertArrayHasKey('test1', $extras);
+        $this->assertEquals('options value 1', $item->getExtra('test1'));
 
-        $this->assertArrayHasKey( 'test2', $extras );
-        $this->assertEquals( 'options value 2', $item->getExtra( 'test2' ) );
+        $this->assertArrayHasKey('test2', $extras);
+        $this->assertEquals('options value 2', $item->getExtra('test2'));
     }
 
     public function testBuildItemDoesNotOverrideExistingExtras(): void
     {
-        $item = $this->createItem( 'test' );
-        $item->setExtra( 'test1', 'original value' );
+        $item = $this->createItem('test');
+        $item->setExtra('test1', 'original value');
         $extension = $this->getExtension();
         $options = $extension->buildOptions(
             [
                 'extras' => [
                     'test2' => 'options value',
-                ]
+                ],
             ]
         );
 
-        $extension->buildItem( $item, $options );
+        $extension->buildItem($item, $options);
 
-        $this->assertArrayHasKey( 'test1', $item->getExtras() );
-        $this->assertEquals( 'original value', $item->getExtra( 'test1' ) );
+        $this->assertArrayHasKey('test1', $item->getExtras());
+        $this->assertEquals('original value', $item->getExtra('test1'));
     }
 
     private function getExtension()
@@ -79,10 +79,10 @@ private function getExtension()
         return new CoreExtension();
     }
 
-    private function createItem( $name )
+    private function createItem($name)
     {
         $factory = new MenuFactory();
-        $item = new MenuItem( $name, $factory );
+        $item = new MenuItem($name, $factory);
 
         return $item;
     }
diff --git a/tests/Knp/Menu/Tests/Integration/Symfony/RoutingExtensionTest.php b/tests/Knp/Menu/Tests/Integration/Symfony/RoutingExtensionTest.php
index 54a09a67..739a98c1 100644
--- a/tests/Knp/Menu/Tests/Integration/Symfony/RoutingExtensionTest.php
+++ b/tests/Knp/Menu/Tests/Integration/Symfony/RoutingExtensionTest.php
@@ -6,11 +6,11 @@
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
 
-class RoutingExtensionTest extends TestCase
+final class RoutingExtensionTest extends TestCase
 {
     protected function setUp(): void
     {
-        if (!interface_exists('Symfony\Component\Routing\Generator\UrlGeneratorInterface')) {
+        if (!\interface_exists('Symfony\Component\Routing\Generator\UrlGeneratorInterface')) {
             $this->markTestSkipped('The Symfony Routing component is not available');
         }
     }
@@ -21,7 +21,7 @@ public function testCreateItemWithRoute(): void
         $generator->expects($this->once())
             ->method('generate')
             ->with('homepage', [], UrlGeneratorInterface::ABSOLUTE_PATH)
-            ->will($this->returnValue('/foobar'))
+            ->willReturn('/foobar')
         ;
 
         $extension = new RoutingExtension($generator);
@@ -38,7 +38,7 @@ public function testCreateItemWithRouteAndParameters(): void
         $generator->expects($this->once())
             ->method('generate')
             ->with('homepage', ['id' => 12], UrlGeneratorInterface::ABSOLUTE_PATH)
-            ->will($this->returnValue('/foobar'))
+            ->willReturn('/foobar')
         ;
 
         $extension = new RoutingExtension($generator);
@@ -54,7 +54,7 @@ public function testCreateItemWithAbsoluteRoute(): void
         $generator->expects($this->once())
             ->method('generate')
             ->with('homepage', [], UrlGeneratorInterface::ABSOLUTE_URL)
-            ->will($this->returnValue('http://php.net'))
+            ->willReturn('http://php.net')
         ;
 
         $extension = new RoutingExtension($generator);
@@ -70,13 +70,13 @@ public function testCreateItemAppendsRouteUnderExtras(): void
 
         $extension = new RoutingExtension($generator);
 
-        $processedOptions = $extension->buildOptions( ['route' => 'homepage']);
+        $processedOptions = $extension->buildOptions(['route' => 'homepage']);
         $this->assertEquals([['route' => 'homepage', 'parameters' => []]], $processedOptions['extras']['routes']);
 
-        $processedOptions = $extension->buildOptions( ['route' => 'homepage', 'routeParameters' => ['bar' => 'baz']]);
+        $processedOptions = $extension->buildOptions(['route' => 'homepage', 'routeParameters' => ['bar' => 'baz']]);
         $this->assertEquals([['route' => 'homepage', 'parameters' => ['bar' => 'baz']]], $processedOptions['extras']['routes']);
 
-        $processedOptions = $extension->buildOptions( ['route' => 'homepage', 'extras' => ['routes' => ['other_page']]]);
+        $processedOptions = $extension->buildOptions(['route' => 'homepage', 'extras' => ['routes' => ['other_page']]]);
         $this->assertContains(['route' => 'homepage', 'parameters' => []], $processedOptions['extras']['routes']);
         $this->assertContains('other_page', $processedOptions['extras']['routes']);
     }
diff --git a/tests/Knp/Menu/Tests/Iterator/CurrentItemFilterIteratorTest.php b/tests/Knp/Menu/Tests/Iterator/CurrentItemFilterIteratorTest.php
index be3a8f9a..a3636ffe 100644
--- a/tests/Knp/Menu/Tests/Iterator/CurrentItemFilterIteratorTest.php
+++ b/tests/Knp/Menu/Tests/Iterator/CurrentItemFilterIteratorTest.php
@@ -7,7 +7,7 @@
 use Knp\Menu\Matcher\Matcher;
 use Knp\Menu\Tests\MenuTestCase;
 
-class CurrentItemFilterIteratorTest extends MenuTestCase
+final class CurrentItemFilterIteratorTest extends MenuTestCase
 {
     public function testSimpleFiltering(): void
     {
diff --git a/tests/Knp/Menu/Tests/Iterator/DisplayedItemFilterIteratorTest.php b/tests/Knp/Menu/Tests/Iterator/DisplayedItemFilterIteratorTest.php
index 2b192225..cdfd1f80 100644
--- a/tests/Knp/Menu/Tests/Iterator/DisplayedItemFilterIteratorTest.php
+++ b/tests/Knp/Menu/Tests/Iterator/DisplayedItemFilterIteratorTest.php
@@ -6,7 +6,7 @@
 use Knp\Menu\Iterator\RecursiveItemIterator;
 use Knp\Menu\Tests\MenuTestCase;
 
-class DisplayedItemFilterIteratorTest extends MenuTestCase
+final class DisplayedItemFilterIteratorTest extends MenuTestCase
 {
     public function testFiltering(): void
     {
diff --git a/tests/Knp/Menu/Tests/Iterator/IteratorTest.php b/tests/Knp/Menu/Tests/Iterator/IteratorTest.php
index f109c5bf..82f2ff95 100644
--- a/tests/Knp/Menu/Tests/Iterator/IteratorTest.php
+++ b/tests/Knp/Menu/Tests/Iterator/IteratorTest.php
@@ -5,13 +5,13 @@
 use Knp\Menu\Iterator\RecursiveItemIterator;
 use Knp\Menu\Tests\MenuTestCase;
 
-class IteratorTest extends MenuTestCase
+final class IteratorTest extends MenuTestCase
 {
     public function testIterator(): void
     {
         $count = 0;
         foreach ($this->pt1 as $key => $value) {
-            $count++;
+            ++$count;
             $this->assertEquals('Child '.$count, $key);
             $this->assertEquals('Child '.$count, $value->getLabel());
         }
@@ -23,10 +23,10 @@ public function testRecursiveIterator(): void
         $child = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $child->expects($this->any())
             ->method('getName')
-            ->will($this->returnValue('Foo'));
+            ->willReturn('Foo');
         $child->expects($this->any())
             ->method('getIterator')
-            ->will($this->returnValue(new \EmptyIterator()));
+            ->willReturn(new \EmptyIterator());
         $this->menu->addChild($child);
 
         $names = [];
diff --git a/tests/Knp/Menu/Tests/Loader/ArrayLoaderTest.php b/tests/Knp/Menu/Tests/Loader/ArrayLoaderTest.php
index 1b4a2ba5..288f6043 100644
--- a/tests/Knp/Menu/Tests/Loader/ArrayLoaderTest.php
+++ b/tests/Knp/Menu/Tests/Loader/ArrayLoaderTest.php
@@ -6,7 +6,7 @@
 use Knp\Menu\MenuFactory;
 use PHPUnit\Framework\TestCase;
 
-class ArrayLoaderTest extends TestCase
+final class ArrayLoaderTest extends TestCase
 {
     public function testLoadWithoutChildren(): void
     {
@@ -36,8 +36,8 @@ public function testLoadWithChildren(): void
                     'label' => 'Jack',
                 ],
                 [
-                    'name' => 'john'
-                ]
+                    'name' => 'john',
+                ],
             ],
         ];
 
@@ -59,8 +59,8 @@ public function testLoadWithChildrenOmittingName(): void
                     'label' => 'Jack',
                 ],
                 'john' => [
-                    'label' => 'John'
-                ]
+                    'label' => 'John',
+                ],
             ],
         ];
 
@@ -74,11 +74,10 @@ public function testLoadWithChildrenOmittingName(): void
         $this->assertTrue(isset($item['jack']));
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
-    public function testLoadInvalidData()
+    public function testLoadInvalidData(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $loader = new ArrayLoader(new MenuFactory());
 
         $loader->load(new \stdClass());
diff --git a/tests/Knp/Menu/Tests/Matcher/MatcherTest.php b/tests/Knp/Menu/Tests/Matcher/MatcherTest.php
index 9d8d861c..f1d2eff8 100644
--- a/tests/Knp/Menu/Tests/Matcher/MatcherTest.php
+++ b/tests/Knp/Menu/Tests/Matcher/MatcherTest.php
@@ -5,7 +5,7 @@
 use Knp\Menu\Matcher\Matcher;
 use PHPUnit\Framework\TestCase;
 
-class MatcherTest extends TestCase
+final class MatcherTest extends TestCase
 {
     /**
      * @param bool|null $flag
@@ -18,7 +18,7 @@ public function testItemFlag($flag, $expected): void
         $item = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $item->expects($this->any())
             ->method('isCurrent')
-            ->will($this->returnValue($flag));
+            ->willReturn($flag);
 
         $matcher = new Matcher();
 
@@ -57,7 +57,7 @@ public function testFlagWinsOverVoter($value): void
         $item = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $item->expects($this->any())
             ->method('isCurrent')
-            ->will($this->returnValue($value));
+            ->willReturn($value);
 
         $voter = $this->getMockBuilder('Knp\Menu\Matcher\Voter\VoterInterface')->getMock();
         $voter->expects($this->never())
@@ -78,13 +78,13 @@ public function testFirstVoterWins($value): void
         $item = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $item->expects($this->any())
             ->method('isCurrent')
-            ->will($this->returnValue(null));
+            ->willReturn(null);
 
         $voter1 = $this->getMockBuilder('Knp\Menu\Matcher\Voter\VoterInterface')->getMock();
         $voter1->expects($this->once())
             ->method('matchItem')
             ->with($this->equalTo($item))
-            ->will($this->returnValue($value));
+            ->willReturn($value);
 
         $voter2 = $this->getMockBuilder('Knp\Menu\Matcher\Voter\VoterInterface')->getMock();
         $voter2->expects($this->never())
@@ -105,13 +105,13 @@ public function testVoterIterator(bool $value): void
         $item = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $item->expects($this->any())
             ->method('isCurrent')
-            ->will($this->returnValue(null));
+            ->willReturn(null);
 
         $voter1 = $this->getMockBuilder('Knp\Menu\Matcher\Voter\VoterInterface')->getMock();
         $voter1->expects($this->once())
             ->method('matchItem')
             ->with($this->equalTo($item))
-            ->will($this->returnValue($value));
+            ->willReturn($value);
 
         $voter2 = $this->getMockBuilder('Knp\Menu\Matcher\Voter\VoterInterface')->getMock();
         $voter2->expects($this->never())
diff --git a/tests/Knp/Menu/Tests/Matcher/Voter/RegexVoterTest.php b/tests/Knp/Menu/Tests/Matcher/Voter/RegexVoterTest.php
index 3f11140e..8c6b1358 100644
--- a/tests/Knp/Menu/Tests/Matcher/Voter/RegexVoterTest.php
+++ b/tests/Knp/Menu/Tests/Matcher/Voter/RegexVoterTest.php
@@ -5,7 +5,7 @@
 use Knp\Menu\Matcher\Voter\RegexVoter;
 use PHPUnit\Framework\TestCase;
 
-class RegexVoterTest extends TestCase
+final class RegexVoterTest extends TestCase
 {
     /**
      * @param string $exp
@@ -19,7 +19,7 @@ public function testMatching($exp, $itemUri, $expected): void
         $item = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $item->expects($this->any())
             ->method('getUri')
-            ->will($this->returnValue($itemUri));
+            ->willReturn($itemUri);
 
         $voter = new RegexVoter($exp);
 
diff --git a/tests/Knp/Menu/Tests/Matcher/Voter/RouteVoterTest.php b/tests/Knp/Menu/Tests/Matcher/Voter/RouteVoterTest.php
index 64668663..1927cc72 100644
--- a/tests/Knp/Menu/Tests/Matcher/Voter/RouteVoterTest.php
+++ b/tests/Knp/Menu/Tests/Matcher/Voter/RouteVoterTest.php
@@ -7,18 +7,18 @@
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\RequestStack;
 
-class RouteVoterTest extends TestCase
+final class RouteVoterTest extends TestCase
 {
-    protected function setUp()
+    protected function setUp(): void
     {
-        if (!class_exists('Symfony\Component\HttpFoundation\Request')) {
+        if (!\class_exists('Symfony\Component\HttpFoundation\Request')) {
             $this->markTestSkipped('The Symfony HttpFoundation component is not available.');
         }
     }
 
     public function testMatchingWithoutRequestInStack(): void
     {
-        if (!class_exists('Symfony\Component\HttpFoundation\RequestStack')) {
+        if (!\class_exists('Symfony\Component\HttpFoundation\RequestStack')) {
             $this->markTestSkipped('The RequestStack is not available in this version of HttpFoundation.');
         }
 
@@ -31,16 +31,15 @@ public function testMatchingWithoutRequestInStack(): void
         $this->assertNull($voter->matchItem($item));
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testInvalidRouteConfig(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $item = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $item->expects($this->any())
             ->method('getExtra')
             ->with('routes')
-            ->will($this->returnValue([['invalid' => 'array']]));
+            ->willReturn([['invalid' => 'array']]);
 
         $request = new Request();
         $request->attributes->set('_route', 'foo');
@@ -68,7 +67,7 @@ public function testMatching(?string $route, array $parameters, $itemRoutes, ?bo
         $item->expects($this->any())
             ->method('getExtra')
             ->with('routes')
-            ->will($this->returnValue($itemRoutes))
+            ->willReturn($itemRoutes)
         ;
 
         $request = new Request();
@@ -90,79 +89,79 @@ public function provideData(): array
                 null,
                 [],
                 'foo',
-                null
+                null,
             ],
             'integer parameters' => [
                 'foo',
                 ['bar' => 128],
                 [['route' => 'foo', 'parameters' => ['bar' => 128]]],
-                true
+                true,
             ],
             'no item route' => [
                 'foo',
                 [],
                 null,
-                null
+                null,
             ],
             'same single route' => [
                 'foo',
                 [],
                 'foo',
-                true
+                true,
             ],
             'different single route' => [
                 'foo',
                 [],
                 'bar',
-                null
+                null,
             ],
             'matching multiple routes' => [
                 'foo',
                 [],
                 ['foo', 'baz'],
-                true
+                true,
             ],
             'matching multiple routes 2' => [
                 'baz',
                 [],
                 ['foo', 'baz'],
-                true
+                true,
             ],
             'different multiple routes' => [
                 'foo',
                 [],
                 ['bar', 'baz'],
-                null
+                null,
             ],
             'same single route with different parameters' => [
                 'foo',
                 ['1' => 'bar'],
                 [['route' => 'foo', 'parameters' => ['1' => 'baz']]],
-                null
+                null,
             ],
             'same single route with same parameters' => [
                 'foo',
                 ['1' => 'bar'],
                 [['route' => 'foo', 'parameters' => ['1' => 'bar']]],
-                true
+                true,
             ],
             'same single route with additional parameters' => [
                 'foo',
                 ['1' => 'bar'],
                 [['route' => 'foo', 'parameters' => ['1' => 'bar', '2' => 'baz']]],
-                null
+                null,
             ],
             'same single route with less parameters' => [
                 'foo',
                 ['1' => 'bar', '2' => 'baz'],
                 [['route' => 'foo', 'parameters' => ['1' => 'bar']]],
-                true
+                true,
             ],
             'same single route with different type parameters' => [
                 'foo',
                 ['1' => '2'],
                 [['route' => 'foo', 'parameters' => ['1' => 2]]],
-                true
+                true,
             ],
             'same route with multiple route params' => [
                 'foo',
@@ -171,7 +170,7 @@ public function provideData(): array
                     ['route' => 'foo', 'parameters' => ['1' => 'baz']],
                     ['route' => 'foo', 'parameters' => ['1' => 'bar']],
                 ],
-                true
+                true,
             ],
             'same route with and without route params' => [
                 'foo',
@@ -180,7 +179,7 @@ public function provideData(): array
                     ['route' => 'foo', 'parameters' => ['1' => 'baz']],
                     ['route' => 'foo'],
                 ],
-                true
+                true,
             ],
             'same route with multiple different route params' => [
                 'foo',
@@ -189,30 +188,30 @@ public function provideData(): array
                     ['route' => 'foo', 'parameters' => ['1' => 'baz']],
                     ['route' => 'foo', 'parameters' => ['1' => 'foo']],
                 ],
-                null
+                null,
             ],
             'matching pattern without parameters' => [
                 'foo',
                 ['1' => 'bar'],
                 [['pattern' => '/fo/']],
-                true
+                true,
             ],
             'non matching pattern without parameters' => [
                 'foo',
                 ['1' => 'bar'],
                 [['pattern' => '/bar/']],
-                null
+                null,
             ],
             'matching pattern with parameters' => [
                 'foo',
                 ['1' => 'bar'],
                 [['pattern' => '/fo/', 'parameters' => ['1' => 'bar']]],
-                true
+                true,
             ],
             'matching pattern with different parameters' => [
                 'foo', ['1' => 'bar'],
                 [['pattern' => '/fo/', 'parameters' => ['1' => 'baz']]],
-                null
+                null,
             ],
         ];
     }
diff --git a/tests/Knp/Menu/Tests/Matcher/Voter/UriVoterTest.php b/tests/Knp/Menu/Tests/Matcher/Voter/UriVoterTest.php
index 7d9a9488..a5ebfcbe 100644
--- a/tests/Knp/Menu/Tests/Matcher/Voter/UriVoterTest.php
+++ b/tests/Knp/Menu/Tests/Matcher/Voter/UriVoterTest.php
@@ -5,7 +5,7 @@
 use Knp\Menu\Matcher\Voter\UriVoter;
 use PHPUnit\Framework\TestCase;
 
-class UriVoterTest extends TestCase
+final class UriVoterTest extends TestCase
 {
     /**
      * @param string $uri
@@ -19,7 +19,7 @@ public function testMatching($uri, $itemUri, $expected): void
         $item = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $item->expects($this->any())
             ->method('getUri')
-            ->will($this->returnValue($itemUri));
+            ->willReturn($itemUri);
 
         $voter = new UriVoter($uri);
 
diff --git a/tests/Knp/Menu/Tests/MenuFactoryTest.php b/tests/Knp/Menu/Tests/MenuFactoryTest.php
index 994b65ac..6b28c07c 100644
--- a/tests/Knp/Menu/Tests/MenuFactoryTest.php
+++ b/tests/Knp/Menu/Tests/MenuFactoryTest.php
@@ -5,7 +5,7 @@
 use Knp\Menu\MenuFactory;
 use PHPUnit\Framework\TestCase;
 
-class MenuFactoryTest extends TestCase
+final class MenuFactoryTest extends TestCase
 {
     public function testExtensions(): void
     {
@@ -15,7 +15,7 @@ public function testExtensions(): void
         $extension1->expects($this->once())
             ->method('buildOptions')
             ->with(['foo' => 'bar'])
-            ->will($this->returnValue(['uri' => 'foobar']));
+            ->willReturn(['uri' => 'foobar']);
         $extension1->expects($this->once())
             ->method('buildItem')
             ->with($this->isInstanceOf('Knp\Menu\ItemInterface'), $this->contains('foobar'));
@@ -26,7 +26,7 @@ public function testExtensions(): void
         $extension2->expects($this->once())
             ->method('buildOptions')
             ->with(['foo' => 'baz'])
-            ->will($this->returnValue(['foo' => 'bar']));
+            ->willReturn(['foo' => 'bar']);
         $extension1->expects($this->once())
             ->method('buildItem')
             ->with($this->isInstanceOf('Knp\Menu\ItemInterface'), $this->contains('foobar'));
diff --git a/tests/Knp/Menu/Tests/MenuItemGetterSetterTest.php b/tests/Knp/Menu/Tests/MenuItemGetterSetterTest.php
index 9e039de0..9714a0f2 100644
--- a/tests/Knp/Menu/Tests/MenuItemGetterSetterTest.php
+++ b/tests/Knp/Menu/Tests/MenuItemGetterSetterTest.php
@@ -2,11 +2,11 @@
 
 namespace Knp\Menu\Tests;
 
-use Knp\Menu\MenuItem;
 use Knp\Menu\MenuFactory;
+use Knp\Menu\MenuItem;
 use PHPUnit\Framework\TestCase;
 
-class MenuItemGetterSetterTest extends TestCase
+final class MenuItemGetterSetterTest extends TestCase
 {
     public function testCreateMenuItemWithEmptyParameter(): void
     {
@@ -143,17 +143,17 @@ public function testDefaultExtras(): void
     public function testDisplay(): void
     {
         $menu = $this->createMenu();
-        $this->assertEquals(true, $menu->isDisplayed());
+        $this->assertTrue($menu->isDisplayed());
         $menu->setDisplay(false);
-        $this->assertEquals(false, $menu->isDisplayed());
+        $this->assertFalse($menu->isDisplayed());
     }
 
     public function testShowChildren(): void
     {
         $menu = $this->createMenu();
-        $this->assertEquals(true, $menu->getDisplayChildren());
+        $this->assertTrue($menu->getDisplayChildren());
         $menu->setDisplayChildren(false);
-        $this->assertEquals(false, $menu->getDisplayChildren());
+        $this->assertFalse($menu->getDisplayChildren());
     }
 
     public function testParent(): void
@@ -173,11 +173,10 @@ public function testChildren(): void
         $this->assertEquals([$child], $menu->getChildren());
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
-    public function testSetExistingNameThrowsAnException()
+    public function testSetExistingNameThrowsAnException(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $menu = $this->createMenu();
         $menu->addChild('jack');
         $menu->addChild('joe');
@@ -202,7 +201,7 @@ public function testFactory(): void
         $factory = $this->getMockBuilder('Knp\Menu\FactoryInterface')->getMock();
         $factory->expects($this->once())
             ->method('createItem')
-            ->will($this->returnValue($child1));
+            ->willReturn($child1);
 
         $menu = $this->createMenu();
         $menu->setFactory($factory);
diff --git a/tests/Knp/Menu/Tests/MenuItemReorderTest.php b/tests/Knp/Menu/Tests/MenuItemReorderTest.php
index aa0d4184..98e4d8d6 100644
--- a/tests/Knp/Menu/Tests/MenuItemReorderTest.php
+++ b/tests/Knp/Menu/Tests/MenuItemReorderTest.php
@@ -2,11 +2,11 @@
 
 namespace Knp\Menu\Tests;
 
-use Knp\Menu\MenuItem;
 use Knp\Menu\MenuFactory;
+use Knp\Menu\MenuItem;
 use PHPUnit\Framework\TestCase;
 
-class MenuItemReorderTest extends TestCase
+final class MenuItemReorderTest extends TestCase
 {
     public function testReordering(): void
     {
@@ -18,26 +18,24 @@ public function testReordering(): void
         $menu->addChild('c4');
 
         $menu->reorderChildren(['c4', 'c3', 'c2', 'c1']);
-        $arr = array_keys($menu->getChildren());
+        $arr = \array_keys($menu->getChildren());
         $this->assertEquals(['c4', 'c3', 'c2', 'c1'], $arr);
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testReorderingWithTooManyItemNames(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $factory = new MenuFactory();
         $menu = new MenuItem('root', $factory);
         $menu->addChild('c1');
         $menu->reorderChildren(['c1', 'c3']);
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testReorderingWithWrongItemNames(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $factory = new MenuFactory();
         $menu = new MenuItem('root', $factory);
         $menu->addChild('c1');
diff --git a/tests/Knp/Menu/Tests/MenuItemTreeTest.php b/tests/Knp/Menu/Tests/MenuItemTreeTest.php
index 2e5b866d..56f7b60e 100644
--- a/tests/Knp/Menu/Tests/MenuItemTreeTest.php
+++ b/tests/Knp/Menu/Tests/MenuItemTreeTest.php
@@ -4,9 +4,11 @@
 
 use Knp\Menu\MenuItem;
 
-class TestMenuItem extends MenuItem {}
+final class TestMenuItem extends MenuItem
+{
+}
 
-class MenuItemTreeTest extends MenuTestCase
+final class MenuItemTreeTest extends MenuTestCase
 {
     public function testSampleTreeIntegrity(): void
     {
@@ -49,7 +51,7 @@ public function testGetParent(): void
 
     public function testMoveSampleMenuToNewRoot(): void
     {
-        $newRoot = new TestMenuItem("newRoot", $this->getMockBuilder('Knp\Menu\FactoryInterface')->getMock());
+        $newRoot = new TestMenuItem('newRoot', $this->getMockBuilder('Knp\Menu\FactoryInterface')->getMock());
         $newRoot->addChild($this->menu);
 
         $this->assertEquals(1, $this->menu->getLevel());
@@ -121,7 +123,7 @@ public function testArrayAccess(): void
         $this->assertNull($this->menu['Fake']);
 
         $this->menu['New Child'] = 'New Label';
-        $this->assertEquals('Knp\Menu\MenuItem', get_class($this->menu['New Child']));
+        $this->assertEquals('Knp\Menu\MenuItem', \get_class($this->menu['New Child']));
         $this->assertEquals('New Child', $this->menu['New Child']->getName());
         $this->assertEquals('New Label', $this->menu['New Child']->getLabel());
 
@@ -172,11 +174,10 @@ public function testAddChildDoesNotUSeTheFactoryIfItem(): void
         $menu->addChild(new MenuItem('Child 3', $factory));
     }
 
-    /**
-     * @expectedException \LogicException
-     */
     public function testAddChildFailsIfInAnotherMenu(): void
     {
+        $this->expectException(\LogicException::class);
+
         $factory = $this->getMockBuilder('Knp\Menu\FactoryInterface')->getMock();
         $menu = new MenuItem('Root li', $factory);
         $child = new MenuItem('Child 3', $factory);
@@ -224,15 +225,14 @@ public function testUpdateChildAfterRename(): void
     {
         $this->pt1->setName('Temp name');
         $this->assertSame($this->pt1, $this->menu->getChild('Temp name'));
-        $this->assertEquals(['Temp name', 'Parent 2'], array_keys($this->menu->getChildren()));
+        $this->assertEquals(['Temp name', 'Parent 2'], \array_keys($this->menu->getChildren()));
         $this->assertNull($this->menu->getChild('Parent 1'));
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testRenameToExistingSiblingNameThrowAnException(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $this->pt1->setName('Parent 2');
     }
 
diff --git a/tests/Knp/Menu/Tests/MenuTestCase.php b/tests/Knp/Menu/Tests/MenuTestCase.php
index 6ec8c149..6996df14 100644
--- a/tests/Knp/Menu/Tests/MenuTestCase.php
+++ b/tests/Knp/Menu/Tests/MenuTestCase.php
@@ -2,8 +2,8 @@
 
 namespace Knp\Menu\Tests;
 
-use Knp\Menu\MenuItem;
 use Knp\Menu\MenuFactory;
+use Knp\Menu\MenuItem;
 use PHPUnit\Framework\TestCase;
 
 abstract class MenuTestCase extends TestCase
@@ -80,13 +80,13 @@ protected function tearDown(): void
     // prints a visual representation of our basic testing tree
     protected function printTestTree(): void
     {
-        print('      Menu Structure   '."\n");
-        print('               rt      '."\n");
-        print('             /    \    '."\n");
-        print('          pt1      pt2 '."\n");
-        print('        /  | \      |  '."\n");
-        print('      ch1 ch2 ch3  ch4 '."\n");
-        print('                    |  '."\n");
-        print('                   gc1 '."\n");
+        echo '      Menu Structure   '."\n";
+        echo '               rt      '."\n";
+        echo '             /    \    '."\n";
+        echo '          pt1      pt2 '."\n";
+        echo '        /  | \      |  '."\n";
+        echo '      ch1 ch2 ch3  ch4 '."\n";
+        echo '                    |  '."\n";
+        echo '                   gc1 '."\n";
     }
 }
diff --git a/tests/Knp/Menu/Tests/Provider/ArrayAccessProviderTest.php b/tests/Knp/Menu/Tests/Provider/ArrayAccessProviderTest.php
index 5a95d938..324a816c 100644
--- a/tests/Knp/Menu/Tests/Provider/ArrayAccessProviderTest.php
+++ b/tests/Knp/Menu/Tests/Provider/ArrayAccessProviderTest.php
@@ -5,7 +5,7 @@
 use Knp\Menu\Provider\ArrayAccessProvider;
 use PHPUnit\Framework\TestCase;
 
-class ArrayAccessProviderTest extends TestCase
+final class ArrayAccessProviderTest extends TestCase
 {
     public function testHas(): void
     {
@@ -39,11 +39,10 @@ public function testGetMenuAsClosure(): void
         $this->assertEquals(['foo' => 'bar'], $registry['options']);
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testGetNonExistentMenu(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $provider = new ArrayAccessProvider(new \ArrayObject());
         $provider->get('non-existent');
     }
diff --git a/tests/Knp/Menu/Tests/Provider/ChainProviderTest.php b/tests/Knp/Menu/Tests/Provider/ChainProviderTest.php
index c6aa604e..772a0fbd 100644
--- a/tests/Knp/Menu/Tests/Provider/ChainProviderTest.php
+++ b/tests/Knp/Menu/Tests/Provider/ChainProviderTest.php
@@ -5,25 +5,25 @@
 use Knp\Menu\Provider\ChainProvider;
 use PHPUnit\Framework\TestCase;
 
-class ChainProviderTest extends TestCase
+final class ChainProviderTest extends TestCase
 {
     public function testHas(): void
     {
-        $innerProvider =  $this->getMockBuilder('Knp\Menu\Provider\MenuProviderInterface')->getMock();
+        $innerProvider = $this->getMockBuilder('Knp\Menu\Provider\MenuProviderInterface')->getMock();
         $innerProvider->expects($this->at(0))
             ->method('has')
             ->with('first')
-            ->will($this->returnValue(true))
+            ->willReturn(true)
         ;
         $innerProvider->expects($this->at(1))
             ->method('has')
             ->with('second')
-            ->will($this->returnValue(false))
+            ->willReturn(false)
         ;
         $innerProvider->expects($this->at(2))
             ->method('has')
             ->with('third', ['foo' => 'bar'])
-            ->will($this->returnValue(false))
+            ->willReturn(false)
         ;
         $provider = new ChainProvider([$innerProvider]);
         $this->assertTrue($provider->has('first'));
@@ -34,16 +34,16 @@ public function testHas(): void
     public function testGetExistentMenu(): void
     {
         $menu = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
-        $innerProvider =  $this->getMockBuilder('Knp\Menu\Provider\MenuProviderInterface')->getMock();
+        $innerProvider = $this->getMockBuilder('Knp\Menu\Provider\MenuProviderInterface')->getMock();
         $innerProvider->expects($this->any())
             ->method('has')
             ->with('default')
-            ->will($this->returnValue(true))
+            ->willReturn(true)
         ;
         $innerProvider->expects($this->once())
             ->method('get')
             ->with('default')
-            ->will($this->returnValue($menu))
+            ->willReturn($menu)
         ;
 
         $provider = new ChainProvider([$innerProvider]);
@@ -53,27 +53,26 @@ public function testGetExistentMenu(): void
     public function testGetWithOptions(): void
     {
         $menu = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
-        $innerProvider =  $this->getMockBuilder('Knp\Menu\Provider\MenuProviderInterface')->getMock();
+        $innerProvider = $this->getMockBuilder('Knp\Menu\Provider\MenuProviderInterface')->getMock();
         $innerProvider->expects($this->any())
             ->method('has')
             ->with('default', ['foo' => 'bar'])
-            ->will($this->returnValue(true))
+            ->willReturn(true)
         ;
         $innerProvider->expects($this->once())
             ->method('get')
             ->with('default', ['foo' => 'bar'])
-            ->will($this->returnValue($menu))
+            ->willReturn($menu)
         ;
 
         $provider = new ChainProvider([$innerProvider]);
         $this->assertSame($menu, $provider->get('default', ['foo' => 'bar']));
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testGetNonExistentMenu(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $provider = new ChainProvider([]);
         $provider->get('non-existent');
     }
diff --git a/tests/Knp/Menu/Tests/Provider/LazyProviderTest.php b/tests/Knp/Menu/Tests/Provider/LazyProviderTest.php
index 804d54a6..f0738618 100644
--- a/tests/Knp/Menu/Tests/Provider/LazyProviderTest.php
+++ b/tests/Knp/Menu/Tests/Provider/LazyProviderTest.php
@@ -6,11 +6,11 @@
 use Knp\Menu\Provider\LazyProvider;
 use PHPUnit\Framework\TestCase;
 
-class LazyProviderTest extends TestCase
+final class LazyProviderTest extends TestCase
 {
     public function testHas(): void
     {
-        $provider = new LazyProvider(['first' => function () {}, 'second' => function () {}]);
+        $provider = new LazyProvider(['first' => function (): void {}, 'second' => function (): void {}]);
         $this->assertTrue($provider->has('first'));
         $this->assertTrue($provider->has('second'));
         $this->assertFalse($provider->has('third'));
@@ -35,35 +35,32 @@ public function testGetMenuAsClosure(): void
         $this->assertSame($menu, $provider->get('default', ['foo' => 'bar']));
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testGetNonExistentMenu(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $provider = new LazyProvider([]);
         $provider->get('non-existent');
     }
 
-    /**
-     * @expectedException \LogicException
-     */
     public function testGetWithBrokenBuilder(): void
     {
+        $this->expectException(\LogicException::class);
+
         $provider = new LazyProvider(['broken' => new \stdClass()]);
         $provider->get('broken');
     }
 
-    /**
-     * @expectedException \LogicException
-     */
     public function testGetWithBrokenLazyBuilder(): void
     {
-        $provider = new LazyProvider(['broken' => [function () {return new \stdClass();}, 'nonExistentMethod']]);
+        $this->expectException(\LogicException::class);
+
+        $provider = new LazyProvider(['broken' => [function () {return new \stdClass(); }, 'nonExistentMethod']]);
         $provider->get('broken');
     }
 }
 
-class FakeBuilder
+final class FakeBuilder
 {
     private $menu;
 
diff --git a/tests/Knp/Menu/Tests/Provider/PsrProviderTest.php b/tests/Knp/Menu/Tests/Provider/PsrProviderTest.php
index c5601446..8d498d44 100644
--- a/tests/Knp/Menu/Tests/Provider/PsrProviderTest.php
+++ b/tests/Knp/Menu/Tests/Provider/PsrProviderTest.php
@@ -5,7 +5,7 @@
 use Knp\Menu\Provider\PsrProvider;
 use PHPUnit\Framework\TestCase;
 
-class PsrProviderTest extends TestCase
+final class PsrProviderTest extends TestCase
 {
     public function testHas(): void
     {
@@ -32,11 +32,10 @@ public function testGetExistentMenu(): void
         $this->assertSame($menu->reveal(), $provider->get('menu'));
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testGetNonExistentMenu(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $container = $this->prophesize('Psr\Container\ContainerInterface');
         $container->has('non-existent')->willReturn(false);
 
diff --git a/tests/Knp/Menu/Tests/Renderer/AbstractRendererTest.php b/tests/Knp/Menu/Tests/Renderer/AbstractRendererTest.php
index 63ea84c6..e50afd6f 100644
--- a/tests/Knp/Menu/Tests/Renderer/AbstractRendererTest.php
+++ b/tests/Knp/Menu/Tests/Renderer/AbstractRendererTest.php
@@ -2,10 +2,10 @@
 
 namespace Knp\Menu\Tests\Renderer;
 
-use Knp\Menu\MenuItem;
-use Knp\Menu\MenuFactory;
-use Knp\Menu\Matcher\MatcherInterface;
 use Knp\Menu\Matcher\Matcher;
+use Knp\Menu\Matcher\MatcherInterface;
+use Knp\Menu\MenuFactory;
+use Knp\Menu\MenuItem;
 use Knp\Menu\Tests\MenuTestCase;
 
 abstract class AbstractRendererTest extends MenuTestCase
@@ -83,7 +83,7 @@ public function testRenderLinkWithEmptyAttributes(): void
         $menu = new MenuItem('test', new MenuFactory());
         $menu->addChild('About', [
             'uri' => '/about',
-            'linkAttributes' => ['title' => '', 'rel' => null, 'target' => false]
+            'linkAttributes' => ['title' => '', 'rel' => null, 'target' => false],
         ]);
 
         $rendered = '<ul><li class="first last"><a href="/about" title="">About</a></li></ul>';
@@ -296,21 +296,21 @@ public function testMatchingDepth0(): void
     {
         $this->menu['Parent 1']['Child 1']->setCurrent(true);
         $rendered = '<ul class="root"><li class="first"><span>Parent 1</span></li><li class="last"><span>Parent 2</span></li></ul>';
-        $this->assertEquals($rendered, $this->renderer->render($this->menu, ['depth' => 1,'matchingDepth' => 1]));
+        $this->assertEquals($rendered, $this->renderer->render($this->menu, ['depth' => 1, 'matchingDepth' => 1]));
     }
 
     public function testMatchingDepth1(): void
     {
         $this->menu['Parent 1']['Child 1']->setCurrent(true);
         $rendered = '<ul class="root"><li class="current_ancestor first"><span>Parent 1</span></li><li class="last"><span>Parent 2</span></li></ul>';
-        $this->assertEquals($rendered, $this->renderer->render($this->menu, ['depth' => 1,'matchingDepth' => 2]));
+        $this->assertEquals($rendered, $this->renderer->render($this->menu, ['depth' => 1, 'matchingDepth' => 2]));
     }
 
     public function testMatchingDepth2(): void
     {
         $this->menu['Parent 1']['Child 1']->setCurrent(true);
         $rendered = '<ul class="root"><li class="first"><span>Parent 1</span></li><li class="last"><span>Parent 2</span></li></ul>';
-        $this->assertEquals($rendered, $this->renderer->render($this->menu, ['depth' => 1,'matchingDepth' => 0]));
+        $this->assertEquals($rendered, $this->renderer->render($this->menu, ['depth' => 1, 'matchingDepth' => 0]));
     }
 
     public function testLeafAndBranchRendering(): void
diff --git a/tests/Knp/Menu/Tests/Renderer/ArrayAccessProviderTest.php b/tests/Knp/Menu/Tests/Renderer/ArrayAccessProviderTest.php
index 703918e8..a7373e9a 100644
--- a/tests/Knp/Menu/Tests/Renderer/ArrayAccessProviderTest.php
+++ b/tests/Knp/Menu/Tests/Renderer/ArrayAccessProviderTest.php
@@ -5,7 +5,7 @@
 use Knp\Menu\Renderer\ArrayAccessProvider;
 use PHPUnit\Framework\TestCase;
 
-class ArrayAccessProviderTest extends TestCase
+final class ArrayAccessProviderTest extends TestCase
 {
     public function testHas(): void
     {
@@ -20,7 +20,7 @@ public function testGetExistentRenderer(): void
         $registry = new \ArrayObject();
         $renderer = $this->getMockBuilder('Knp\Menu\Renderer\RendererInterface')->getMock();
         $registry['renderer'] = $renderer;
-        $provider = new ArrayAccessProvider($registry, 'default',  ['default' => 'renderer']);
+        $provider = new ArrayAccessProvider($registry, 'default', ['default' => 'renderer']);
         $this->assertSame($renderer, $provider->get('default'));
     }
 
@@ -29,15 +29,14 @@ public function testGetDefaultRenderer(): void
         $registry = new \ArrayObject();
         $renderer = $this->getMockBuilder('Knp\Menu\Renderer\RendererInterface')->getMock();
         $registry['renderer'] = $renderer;
-        $provider = new ArrayAccessProvider($registry, 'default',  ['default' => 'renderer']);
+        $provider = new ArrayAccessProvider($registry, 'default', ['default' => 'renderer']);
         $this->assertSame($renderer, $provider->get());
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testGetNonExistentRenderer(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $provider = new ArrayAccessProvider(new \ArrayObject(), 'default', []);
         $provider->get('non-existent');
     }
diff --git a/tests/Knp/Menu/Tests/Renderer/ListRendererTest.php b/tests/Knp/Menu/Tests/Renderer/ListRendererTest.php
index 474c3fc3..db3415d1 100644
--- a/tests/Knp/Menu/Tests/Renderer/ListRendererTest.php
+++ b/tests/Knp/Menu/Tests/Renderer/ListRendererTest.php
@@ -2,10 +2,10 @@
 
 namespace Knp\Menu\Tests\Renderer;
 
-use Knp\Menu\Renderer\ListRenderer;
 use Knp\Menu\Matcher\MatcherInterface;
+use Knp\Menu\Renderer\ListRenderer;
 
-class ListRendererTest extends AbstractRendererTest
+final class ListRendererTest extends AbstractRendererTest
 {
     protected function createRenderer(MatcherInterface $matcher): ListRenderer
     {
diff --git a/tests/Knp/Menu/Tests/Renderer/PsrProviderTest.php b/tests/Knp/Menu/Tests/Renderer/PsrProviderTest.php
index b9897388..845976a3 100644
--- a/tests/Knp/Menu/Tests/Renderer/PsrProviderTest.php
+++ b/tests/Knp/Menu/Tests/Renderer/PsrProviderTest.php
@@ -5,7 +5,7 @@
 use Knp\Menu\Renderer\PsrProvider;
 use PHPUnit\Framework\TestCase;
 
-class PsrProviderTest extends TestCase
+final class PsrProviderTest extends TestCase
 {
     public function testHas(): void
     {
@@ -44,11 +44,10 @@ public function testGetDefaultRenderer(): void
         $this->assertSame($renderer->reveal(), $provider->get());
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testGetNonExistentRenderer(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $container = $this->prophesize('Psr\Container\ContainerInterface');
         $container->has('non-existent')->willReturn(false);
 
diff --git a/tests/Knp/Menu/Tests/Renderer/TwigRendererTest.php b/tests/Knp/Menu/Tests/Renderer/TwigRendererTest.php
index 76de63d9..22558c02 100644
--- a/tests/Knp/Menu/Tests/Renderer/TwigRendererTest.php
+++ b/tests/Knp/Menu/Tests/Renderer/TwigRendererTest.php
@@ -2,18 +2,18 @@
 
 namespace Knp\Menu\Tests\Renderer;
 
-use Knp\Menu\Renderer\TwigRenderer;
-use Knp\Menu\MenuItem;
-use Knp\Menu\MenuFactory;
 use Knp\Menu\Matcher\MatcherInterface;
+use Knp\Menu\MenuFactory;
+use Knp\Menu\MenuItem;
+use Knp\Menu\Renderer\TwigRenderer;
 use Twig\Environment;
 use Twig\Loader\FilesystemLoader;
 
-class TwigRendererTest extends AbstractRendererTest
+final class TwigRendererTest extends AbstractRendererTest
 {
     public function createRenderer(MatcherInterface $matcher): TwigRenderer
     {
-        if (!class_exists(Environment::class)) {
+        if (!\class_exists(Environment::class)) {
             $this->markTestSkipped('Twig is not available');
         }
         $loader = new FilesystemLoader(__DIR__.'/../../../../../src/Knp/Menu/Resources/views');
diff --git a/tests/Knp/Menu/Tests/Twig/HelperTest.php b/tests/Knp/Menu/Tests/Twig/HelperTest.php
index 33ec3874..6fa635f0 100644
--- a/tests/Knp/Menu/Tests/Twig/HelperTest.php
+++ b/tests/Knp/Menu/Tests/Twig/HelperTest.php
@@ -8,7 +8,7 @@
 use Knp\Menu\Twig\Helper;
 use PHPUnit\Framework\TestCase;
 
-class HelperTest extends TestCase
+final class HelperTest extends TestCase
 {
     public function testRenderMenu(): void
     {
@@ -17,14 +17,14 @@ public function testRenderMenu(): void
         $renderer->expects($this->once())
             ->method('render')
             ->with($menu, [])
-            ->will($this->returnValue('<p>foobar</p>'))
+            ->willReturn('<p>foobar</p>')
         ;
 
         $rendererProvider = $this->getMockBuilder('Knp\Menu\Renderer\RendererProviderInterface')->getMock();
         $rendererProvider->expects($this->once())
             ->method('get')
             ->with(null)
-            ->will($this->returnValue($renderer))
+            ->willReturn($renderer)
         ;
 
         $helper = new Helper($rendererProvider);
@@ -39,14 +39,14 @@ public function testRenderMenuWithOptions(): void
         $renderer->expects($this->once())
             ->method('render')
             ->with($menu, ['firstClass' => 'test'])
-            ->will($this->returnValue('<p>foobar</p>'))
+            ->willReturn('<p>foobar</p>')
         ;
 
         $rendererProvider = $this->getMockBuilder('Knp\Menu\Renderer\RendererProviderInterface')->getMock();
         $rendererProvider->expects($this->once())
             ->method('get')
             ->with(null)
-            ->will($this->returnValue($renderer))
+            ->willReturn($renderer)
         ;
 
         $helper = new Helper($rendererProvider);
@@ -56,19 +56,19 @@ public function testRenderMenuWithOptions(): void
 
     public function testRenderMenuWithRenderer(): void
     {
-        $menu = $this->getMockBuilder(  'Knp\Menu\ItemInterface')->getMock();
+        $menu = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $renderer = $this->getMockBuilder('Knp\Menu\Renderer\RendererInterface')->getMock();
         $renderer->expects($this->once())
             ->method('render')
             ->with($menu, [])
-            ->will($this->returnValue('<p>foobar</p>'))
+            ->willReturn('<p>foobar</p>')
         ;
 
         $rendererProvider = $this->getMockBuilder('Knp\Menu\Renderer\RendererProviderInterface')->getMock();
         $rendererProvider->expects($this->once())
             ->method('get')
             ->with('custom')
-            ->will($this->returnValue($renderer))
+            ->willReturn($renderer)
         ;
 
         $helper = new Helper($rendererProvider);
@@ -83,21 +83,21 @@ public function testRenderMenuByName(): void
         $menuProvider->expects($this->once())
             ->method('get')
             ->with('default')
-            ->will($this->returnValue($menu))
+            ->willReturn($menu)
         ;
 
         $renderer = $this->getMockBuilder('Knp\Menu\Renderer\RendererInterface')->getMock();
         $renderer->expects($this->once())
             ->method('render')
             ->with($menu, [])
-            ->will($this->returnValue('<p>foobar</p>'))
+            ->willReturn('<p>foobar</p>')
         ;
 
         $rendererProvider = $this->getMockBuilder('Knp\Menu\Renderer\RendererProviderInterface')->getMock();
         $rendererProvider->expects($this->once())
             ->method('get')
             ->with(null)
-            ->will($this->returnValue($renderer))
+            ->willReturn($renderer)
         ;
 
         $helper = new Helper($rendererProvider, $menuProvider);
@@ -113,7 +113,7 @@ public function testGetMenu(): void
         $menuProvider->expects($this->once())
             ->method('get')
             ->with('default')
-            ->will($this->returnValue($menu))
+            ->willReturn($menu)
         ;
 
         $helper = new Helper($rendererProvider, $menuProvider);
@@ -121,11 +121,10 @@ public function testGetMenu(): void
         $this->assertSame($menu, $helper->get('default'));
     }
 
-    /**
-     * @expectedException \BadMethodCallException
-     */
     public function testGetMenuWithoutProvider(): void
     {
+        $this->expectException(\BadMethodCallException::class);
+
         $rendererProvider = $this->getMockBuilder('Knp\Menu\Renderer\RendererProviderInterface')->getMock();
         $helper = new Helper($rendererProvider);
         $helper->get('default');
@@ -139,7 +138,7 @@ public function testGetMenuWithOptions(): void
         $menuProvider->expects($this->once())
             ->method('get')
             ->with('default', ['foo' => 'bar'])
-            ->will($this->returnValue($menu))
+            ->willReturn($menu)
         ;
 
         $helper = new Helper($rendererProvider, $menuProvider);
@@ -156,12 +155,12 @@ public function testGetMenuByPath(): void
         $menu->expects($this->any())
             ->method('getChild')
             ->with('child')
-            ->will($this->returnValue($child))
+            ->willReturn($child)
         ;
         $menuProvider->expects($this->once())
             ->method('get')
             ->with('default')
-            ->will($this->returnValue($menu))
+            ->willReturn($menu)
         ;
 
         $helper = new Helper($rendererProvider, $menuProvider);
@@ -169,28 +168,27 @@ public function testGetMenuByPath(): void
         $this->assertSame($child, $helper->get('default', ['child']));
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testGetMenuByInvalidPath(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $rendererProvider = $this->getMockBuilder('Knp\Menu\Renderer\RendererProviderInterface')->getMock();
         $menuProvider = $this->getMockBuilder('Knp\Menu\Provider\MenuProviderInterface')->getMock();
         $child = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $child->expects($this->any())
             ->method('getChild')
-            ->will($this->returnValue(null))
+            ->willReturn(null)
         ;
         $menu = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $menu->expects($this->any())
             ->method('getChild')
             ->with('child')
-            ->will($this->returnValue($child))
+            ->willReturn($child)
         ;
         $menuProvider->expects($this->once())
             ->method('get')
             ->with('default')
-            ->will($this->returnValue($menu))
+            ->willReturn($menu)
         ;
 
         $helper = new Helper($rendererProvider, $menuProvider);
@@ -205,21 +203,21 @@ public function testRenderMenuByPath(): void
         $menu->expects($this->any())
             ->method('getChild')
             ->with('child')
-            ->will($this->returnValue($child))
+            ->willReturn($child)
         ;
 
         $renderer = $this->getMockBuilder('Knp\Menu\Renderer\RendererInterface')->getMock();
         $renderer->expects($this->once())
             ->method('render')
             ->with($child, [])
-            ->will($this->returnValue('<p>foobar</p>'))
+            ->willReturn('<p>foobar</p>')
         ;
 
         $rendererProvider = $this->getMockBuilder('Knp\Menu\Renderer\RendererProviderInterface')->getMock();
         $rendererProvider->expects($this->once())
             ->method('get')
             ->with(null)
-            ->will($this->returnValue($renderer))
+            ->willReturn($renderer)
         ;
 
         $helper = new Helper($rendererProvider);
@@ -227,12 +225,11 @@ public function testRenderMenuByPath(): void
         $this->assertEquals('<p>foobar</p>', $helper->render([$menu, 'child']));
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     * @expectedExceptionMessage The array cannot be empty
-     */
     public function testRenderByEmptyPath(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('The array cannot be empty');
+
         $helper = new Helper($this->getMockBuilder('Knp\Menu\Renderer\RendererProviderInterface')->getMock());
         $helper->render([]);
     }
@@ -245,18 +242,17 @@ public function testBreadcrumbsArray(): void
         $manipulator->expects($this->any())
             ->method('getBreadcrumbsArray')
             ->with($menu)
-            ->will($this->returnValue(['A', 'B']));
+            ->willReturn(['A', 'B']);
 
         $helper = new Helper($this->getMockBuilder('Knp\Menu\Renderer\RendererProviderInterface')->getMock(), null, $manipulator);
 
         $this->assertEquals(['A', 'B'], $helper->getBreadcrumbsArray($menu));
     }
 
-    /**
-     * @expectedException \BadMethodCallException
-     */
     public function testCurrentItemWithoutMatcher(): void
     {
+        $this->expectException(\BadMethodCallException::class);
+
         $helper = new Helper($this->getMockBuilder('Knp\Menu\Renderer\RendererProviderInterface')->getMock());
         $helper->getCurrentItem('default');
     }
diff --git a/tests/Knp/Menu/Tests/Twig/MenuExtensionTest.php b/tests/Knp/Menu/Tests/Twig/MenuExtensionTest.php
index abb3090e..503ad6a1 100644
--- a/tests/Knp/Menu/Tests/Twig/MenuExtensionTest.php
+++ b/tests/Knp/Menu/Tests/Twig/MenuExtensionTest.php
@@ -11,11 +11,11 @@
 use Twig\Loader\ArrayLoader;
 use Twig\Template;
 
-class MenuExtensionTest extends TestCase
+final class MenuExtensionTest extends TestCase
 {
     protected function setUp(): void
     {
-        if (!class_exists(Environment::class)) {
+        if (!\class_exists(Environment::class)) {
             $this->markTestSkipped('Twig is not available');
         }
     }
@@ -27,7 +27,7 @@ public function testRenderMenu(): void
         $helper->expects($this->once())
             ->method('render')
             ->with($menu, [], null)
-            ->will($this->returnValue('<p>foobar</p>'))
+            ->willReturn('<p>foobar</p>')
         ;
 
         $this->assertEquals('<p>foobar</p>', $this->getTemplate('{{ knp_menu_render(menu) }}', $helper)->render(['menu' => $menu]));
@@ -40,7 +40,7 @@ public function testRenderMenuWithOptions(): void
         $helper->expects($this->once())
             ->method('render')
             ->with($menu, ['firstClass' => 'test'], null)
-            ->will($this->returnValue('<p>foobar</p>'))
+            ->willReturn('<p>foobar</p>')
         ;
 
         $this->assertEquals('<p>foobar</p>', $this->getTemplate('{{ knp_menu_render(menu, {"firstClass": "test"}) }}', $helper)->render(['menu' => $menu]));
@@ -53,7 +53,7 @@ public function testRenderMenuWithRenderer(): void
         $helper->expects($this->once())
             ->method('render')
             ->with($menu, [], 'custom')
-            ->will($this->returnValue('<p>foobar</p>'))
+            ->willReturn('<p>foobar</p>')
         ;
 
         $this->assertEquals('<p>foobar</p>', $this->getTemplate('{{ knp_menu_render(menu, {}, "custom") }}', $helper)->render(['menu' => $menu]));
@@ -65,7 +65,7 @@ public function testRenderMenuByName(): void
         $helper->expects($this->once())
             ->method('render')
             ->with('default', [], null)
-            ->will($this->returnValue('<p>foobar</p>'))
+            ->willReturn('<p>foobar</p>')
         ;
 
         $this->assertEquals('<p>foobar</p>', $this->getTemplate('{{ knp_menu_render(menu) }}', $helper)->render(['menu' => 'default']));
@@ -78,12 +78,12 @@ public function testRetrieveMenuByName(): void
         $helper->expects($this->once())
             ->method('render')
             ->with($menu, [], null)
-            ->will($this->returnValue('<p>foobar</p>'))
+            ->willReturn('<p>foobar</p>')
         ;
         $helper->expects($this->once())
             ->method('get')
             ->with('default')
-            ->will($this->returnValue($menu))
+            ->willReturn($menu)
         ;
 
         $this->assertEquals('<p>foobar</p>', $this->getTemplate('{{ knp_menu_render(knp_menu_get("default")) }}', $helper)->render([]));
@@ -95,7 +95,7 @@ public function testGetBreadcrumbsArray(): void
         $helper->expects($this->any())
             ->method('getBreadcrumbsArray')
             ->with('default')
-            ->will($this->returnValue(['A', 'B']))
+            ->willReturn(['A', 'B'])
         ;
 
         $this->assertEquals('A, B', $this->getTemplate('{{ knp_menu_get_breadcrumbs_array("default")|join(", ") }}', $helper)->render([]));
@@ -109,11 +109,11 @@ public function testPathAsString(): void
         $helper->expects($this->any())
             ->method('get')
             ->with('default')
-            ->will($this->returnValue($menu));
+            ->willReturn($menu);
         $manipulator->expects($this->any())
             ->method('getPathAsString')
             ->with($menu)
-            ->will($this->returnValue('A > B'))
+            ->willReturn('A > B')
         ;
 
         $this->assertEquals('A &gt; B', $this->getTemplate('{{ knp_menu_get("default")|knp_menu_as_string }}', $helper, null, $manipulator)->render([]));
@@ -127,7 +127,7 @@ public function testIsCurrent(): void
         $matcher->expects($this->any())
             ->method('isCurrent')
             ->with($menu)
-            ->will($this->returnValue(true))
+            ->willReturn(true)
         ;
 
         $this->assertEquals('current', $this->getTemplate('{{ menu is knp_menu_current ? "current" : "not current" }}', $helper, $matcher)->render(['menu' => $menu]));
@@ -141,7 +141,7 @@ public function testIsAncestor(): void
         $matcher->expects($this->any())
             ->method('isAncestor')
             ->with($menu)
-            ->will($this->returnValue(false))
+            ->willReturn(false)
         ;
 
         $this->assertEquals('not ancestor', $this->getTemplate('{{ menu is knp_menu_ancestor ? "ancestor" : "not ancestor" }}', $helper, $matcher)->render(['menu' => $menu]));
@@ -154,13 +154,13 @@ public function testGetCurrentItem(): void
         $helper->expects($this->once())
             ->method('get')
             ->with('default')
-            ->will($this->returnValue($menu))
+            ->willReturn($menu)
         ;
         $matcher = $this->getMatcherMock();
         $matcher->expects($this->any())
             ->method('isCurrent')
             ->with($menu)
-            ->will($this->returnValue(true))
+            ->willReturn(true)
         ;
 
         $this->assertEquals('current', $this->getTemplate('{{ knp_menu_get_current_item("default") is knp_menu_current ? "current" : "not current" }}', $helper, $matcher)->render([]));
diff --git a/tests/Knp/Menu/Tests/Util/MenuManipulatorTest.php b/tests/Knp/Menu/Tests/Util/MenuManipulatorTest.php
index 237a11f5..0af6bd7c 100644
--- a/tests/Knp/Menu/Tests/Util/MenuManipulatorTest.php
+++ b/tests/Knp/Menu/Tests/Util/MenuManipulatorTest.php
@@ -7,7 +7,7 @@
 use Knp\Menu\Tests\MenuTestCase;
 use Knp\Menu\Util\MenuManipulator;
 
-class MenuManipulatorTest extends MenuTestCase
+final class MenuManipulatorTest extends MenuTestCase
 {
     public function testMoveToFirstPosition(): void
     {
@@ -19,7 +19,7 @@ public function testMoveToFirstPosition(): void
 
         $manipulator = new MenuManipulator();
         $manipulator->moveToFirstPosition($menu['c3']);
-        $this->assertEquals(['c3', 'c1', 'c2', 'c4'], array_keys($menu->getChildren()));
+        $this->assertEquals(['c3', 'c1', 'c2', 'c4'], \array_keys($menu->getChildren()));
     }
 
     public function testMoveToLastPosition(): void
@@ -32,7 +32,7 @@ public function testMoveToLastPosition(): void
 
         $manipulator = new MenuManipulator();
         $manipulator->moveToLastPosition($menu['c2']);
-        $this->assertEquals(['c1', 'c3', 'c4', 'c2'], array_keys($menu->getChildren()));
+        $this->assertEquals(['c1', 'c3', 'c4', 'c2'], \array_keys($menu->getChildren()));
     }
 
     public function testMoveToPosition(): void
@@ -45,7 +45,7 @@ public function testMoveToPosition(): void
 
         $manipulator = new MenuManipulator();
         $manipulator->moveToPosition($menu['c1'], 2);
-        $this->assertEquals(['c2', 'c3', 'c1', 'c4'], array_keys($menu->getChildren()));
+        $this->assertEquals(['c2', 'c3', 'c1', 'c4'], \array_keys($menu->getChildren()));
     }
 
     /**
@@ -56,7 +56,7 @@ public function testSlice($offset, $length, $count, $keys): void
         $manipulator = new MenuManipulator();
         $sliced = $manipulator->slice($this->pt1, $offset, $length);
         $this->assertCount($count, $sliced);
-        $this->assertEquals($keys, array_keys($sliced->getChildren()));
+        $this->assertEquals($keys, \array_keys($sliced->getChildren()));
     }
 
     public function getSliceData()
@@ -84,7 +84,7 @@ public function testSplit($length, $count, $keys): void
         $this->assertArrayHasKey('secondary', $splitted);
         $this->assertCount($count, $splitted['primary']);
         $this->assertCount(3 - $count, $splitted['secondary']);
-        $this->assertEquals($keys, array_keys($splitted['primary']->getChildren()));
+        $this->assertEquals($keys, \array_keys($splitted['primary']->getChildren()));
     }
 
     public function getSplitData()
@@ -131,10 +131,10 @@ public function testBreadcrumbsArray(): void
         $item = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
         $item->expects($this->any())
             ->method('getLabel')
-            ->will($this->returnValue('mock'));
+            ->willReturn('mock');
         $item->expects($this->any())
             ->method('getUri')
-            ->will($this->returnValue('foo'));
+            ->willReturn('foo');
 
         $this->assertEquals(
             [
@@ -170,11 +170,10 @@ public function testBreadcrumbsArray(): void
         );
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     */
     public function testBreadcrumbsArrayInvalidData(): void
     {
+        $this->expectException(\InvalidArgumentException::class);
+
         $manipulator = new MenuManipulator();
         $manipulator->getBreadcrumbsArray($this->pt1, [new \stdClass()]);
     }
@@ -185,11 +184,11 @@ public function testCallRecursively(): void
 
         $menu = $factory->createItem('test_menu');
 
-        foreach (range(1, 2) as $i) {
+        foreach (\range(1, 2) as $i) {
             $child = $this->getMockBuilder('Knp\Menu\ItemInterface')->getMock();
             $child->expects($this->any())
                 ->method('getName')
-                ->will($this->returnValue('Child '.$i))
+                ->willReturn('Child '.$i)
             ;
             $child->expects($this->once())
                 ->method('setDisplay')
@@ -197,7 +196,7 @@ public function testCallRecursively(): void
             ;
             $child->expects($this->once())
                 ->method('getChildren')
-                ->will($this->returnValue([]))
+                ->willReturn([])
             ;
             $menu->addChild($child);
         }
@@ -375,9 +374,9 @@ public function testToArrayWithoutChildren(): void
      * @param string $uri
      * @param array  $attributes
      *
-     * @return \Knp\Menu\MenuItem
+     * @return MenuItem
      */
-    private function createMenu($name = 'test_menu', $uri = 'homepage', array $attributes = [])
+    private function createMenu(string $name = 'test_menu', string $uri = 'homepage', array $attributes = []): MenuItem
     {
         $factory = new MenuFactory();