Upgrade PHPUnit, switch to GitHub actions

matthiasnoback · matthiasnoback · commit 63c709a93214 · 2022-02-02T11:57:21.000+01:00
diff --git a/.github/workflows/code_analysis.yaml b/.github/workflows/code_analysis.yaml
@@ -0,0 +1,34 @@
+name: Code Analysis
+
+on:
+    pull_request: null
+    push: null
+
+jobs:
+    code_analysis:
+        strategy:
+            fail-fast: false
+            matrix:
+                actions:
+                    -
+                        name: "Composer validate"
+                        run: composer validate
+
+                    -
+                        name: "PHPUnit"
+                        run: vendor/bin/phpunit --color
+
+        name: ${{ matrix.actions.name }}
+        runs-on: ubuntu-latest
+
+        steps:
+            -   uses: actions/checkout@v2
+
+            -   uses: shivammathur/setup-php@v2
+                with:
+                    php-version: 7.4
+                    coverage: none
+
+            -   uses: "ramsey/composer-install@v1"
+
+            -   run: ${{ matrix.actions.run }}
diff --git a/.gitignore b/.gitignore
@@ -1,3 +1,4 @@
 composer.lock
 phpunit.xml
-vendor
+vendor
+.phpunit.result.cache
diff --git a/Tests/ArgumentValidatorTest.php b/Tests/ArgumentValidatorTest.php
@@ -4,16 +4,17 @@
 
 use Matthias\SymfonyServiceDefinitionValidator\ArgumentValidator;
 use Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException;
+use PHPUnit\Framework\TestCase;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Definition;
 use Symfony\Component\DependencyInjection\Reference;
 use Symfony\Component\ExpressionLanguage\Expression;
 
-class ArgumentValidatorTest extends \PHPUnit_Framework_TestCase
+class ArgumentValidatorTest extends TestCase
 {
     private $containerBuilder;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->containerBuilder = new ContainerBuilder();
     }
@@ -24,7 +25,7 @@ public function testFailsWhenParameterHasTypeHintButNoReferenceOrDefinitionWasPr
 
         $validator = new ArgumentValidator($this->containerBuilder, $this->createMockResultingClassResolver());
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'reference');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'reference');
         $validator->validate(new \ReflectionParameter(array($class, '__construct'), 'expected'), new \stdClass());
     }
 
@@ -43,7 +44,7 @@ public function testFailsWhenParameterHasTypeHintForObjectButArgumentIsDefinitio
             ->will($this->returnValue('Matthias\SymfonyServiceDefinitionValidator\Tests\Fixtures\WrongClass'));
         $validator = new ArgumentValidator($this->containerBuilder, $resultingClassResolver);
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
         $validator->validate(new \ReflectionParameter(array($class, '__construct'), 'expected'), $inlineDefinition);
     }
 
@@ -65,7 +66,7 @@ public function testFailsWhenParameterHasTypeHintForObjectButArgumentIsReference
             ->will($this->returnValue('stdClass'));
         $validator = new ArgumentValidator($this->containerBuilder, $resultingClassResolver);
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
 
         $validator->validate($parameter, $argument);
     }
@@ -79,7 +80,7 @@ public function testFailsWhenParameterHasArrayTypeHintButArgumentIsNotArray()
 
         $validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver());
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'array');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'array');
 
         $validator->validate($parameter, $argument);
     }
@@ -114,7 +115,7 @@ public function testFailsWhenResultOfExpressionIsNotAnObjectOfTheExpectedClass()
 
         $validator = new ArgumentValidator($containerBuilder, $this->createMockResultingClassResolver(), true);
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
 
         $validator->validate($parameter, $argument);
     }
@@ -130,7 +131,7 @@ public function testFailsWhenResultOfExpressionIsNotAnObject()
 
         $validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver(), true);
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
 
         $validator->validate($parameter, $argument);
     }
@@ -164,7 +165,7 @@ public function testFailsIfSyntaxOfExpressionIsInvalid()
 
         $validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver());
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\InvalidExpressionSyntaxException');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\InvalidExpressionSyntaxException');
 
         $validator->validate($parameter, $argument);
     }
@@ -180,7 +181,7 @@ public function testFailsIfExpressionCouldNotBeEvaluated()
 
         $validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver(), true);
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\InvalidExpressionException');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\InvalidExpressionException');
 
         $validator->validate($parameter, $argument);
     }
@@ -231,14 +232,14 @@ public function testFailsIfContainerReferenceArgumentIsInjectedForParameterWithI
             ->willReturn('Symfony\Component\DependencyInjection\Container');
         $validator = new ArgumentValidator(new ContainerBuilder(), $classResolver);
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
 
         $validator->validate($parameter, $argument);
     }
 
     private function createMockResultingClassResolver()
     {
-        return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\ResultingClassResolverInterface');
+        return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\ResultingClassResolverInterface');
     }
 
     private function skipTestIfExpressionsAreNotAvailable()
diff --git a/Tests/ArgumentsValidatorTest.php b/Tests/ArgumentsValidatorTest.php
@@ -3,9 +3,10 @@
 namespace Matthias\SymfonyServiceDefinitionValidator\Tests;
 
 use Matthias\SymfonyServiceDefinitionValidator\ArgumentsValidator;
+use PHPUnit\Framework\TestCase;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 
-class ArgumentsValidatorTest extends \PHPUnit_Framework_TestCase
+class ArgumentsValidatorTest extends TestCase
 {
     /**
      * @test
@@ -16,13 +17,13 @@ public function ifRequiredArgumentIsMissingFails()
         $class = 'Matthias\SymfonyServiceDefinitionValidator\Tests\Fixtures\ClassWithRequiredConstructorArguments';
         $method = new \ReflectionMethod($class, '__construct');
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\MissingRequiredArgumentException');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\MissingRequiredArgumentException');
 
         $validator->validate($method, array('argument1'));
     }
 
     private function createMockArgumentValidator()
     {
-        return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\ArgumentValidatorInterface');
+        return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\ArgumentValidatorInterface');
     }
 }
diff --git a/Tests/BatchServiceDefinitionValidatorTest.php b/Tests/BatchServiceDefinitionValidatorTest.php
@@ -4,8 +4,9 @@
 
 use Matthias\SymfonyServiceDefinitionValidator\BatchServiceDefinitionValidator;
 use Matthias\SymfonyServiceDefinitionValidator\Tests\Fixtures\InvalidServiceDefinitionException;
+use PHPUnit\Framework\TestCase;
 
-class BatchServiceDefinitionValidatorTest extends \PHPUnit_Framework_TestCase
+class BatchServiceDefinitionValidatorTest extends TestCase
 {
     public function testCreatesErrorListAndTransformsValidationExceptionIntoErrors()
     {
@@ -60,12 +61,12 @@ public function testCreatesErrorListAndTransformsValidationExceptionIntoErrors()
 
     private function createMockErrorFactory()
     {
-        return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorFactoryInterface');
+        return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorFactoryInterface');
     }
 
     private function createMockErrorList()
     {
-        return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\Tests\Error\ValidationErrorListInterface');
+        return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\Tests\Error\ValidationErrorListInterface');
     }
 
     private function createMockDefinition()
@@ -78,7 +79,7 @@ private function createMockDefinition()
 
     private function createMockValidator()
     {
-        return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\ServiceDefinitionValidatorInterface');
+        return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\ServiceDefinitionValidatorInterface');
     }
 
     private function createException()
@@ -88,6 +89,6 @@ private function createException()
 
     private function createMockError()
     {
-        return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorInterface');
+        return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorInterface');
     }
 }
diff --git a/Tests/ConstructorResolverTest.php b/Tests/ConstructorResolverTest.php
@@ -4,11 +4,12 @@
 
 use Matthias\SymfonyServiceDefinitionValidator\ConstructorResolver;
 use Matthias\SymfonyServiceDefinitionValidator\ResultingClassResolver;
+use PHPUnit\Framework\TestCase;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Definition;
 use Symfony\Component\DependencyInjection\Reference;
 
-class ConstructorResolverTest extends \PHPUnit_Framework_TestCase
+class ConstructorResolverTest extends TestCase
 {
     /**
      * @test
@@ -50,7 +51,7 @@ public function ifConstructorIsNotPublicItFails()
         // ClassWithNonPublicConstructor has a non-public constructor
         $definition = new Definition('Matthias\SymfonyServiceDefinitionValidator\Tests\Fixtures\ClassWithNonPublicConstructor');
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\NonPublicConstructorException');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\NonPublicConstructorException');
         $this->assertSame(null, $resolver->resolve($definition));
     }
 
@@ -141,7 +142,7 @@ public function ifFactoryClassDoesNotExistFails(Definition $definition)
         $containerBuilder = new ContainerBuilder();
         $resolver = new ConstructorResolver($containerBuilder, new ResultingClassResolver($containerBuilder));
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\ClassNotFoundException');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\ClassNotFoundException');
         $resolver->resolve($definition);
     }
 
@@ -179,7 +180,7 @@ public function ifFactoryMethodIsNotStaticItFails(Definition $definition)
         $containerBuilder = new ContainerBuilder();
         $resolver = new ConstructorResolver($containerBuilder, new ResultingClassResolver($containerBuilder));
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\NonStaticFactoryMethodException');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\NonStaticFactoryMethodException');
         $resolver->resolve($definition);
     }
 
@@ -241,7 +242,7 @@ public function ifFactoryFunctionDoesNotExistFails()
         $definition = new Definition();
         $definition->setFactory('NotExistingFactoryCallback');
 
-        $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\FunctionNotFoundException');
+        $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\FunctionNotFoundException');
         $resolver->resolve($definition);
     }
 }
diff --git a/Tests/DefinitionArgumentsValidatorTest.php b/Tests/DefinitionArgumentsValidatorTest.php
@@ -3,9 +3,10 @@
 namespace Matthias\SymfonyServiceDefinitionValidator\Tests;
 
 use Matthias\SymfonyServiceDefinitionValidator\DefinitionArgumentsValidator;
+use PHPUnit\Framework\TestCase;
 use Symfony\Component\DependencyInjection\Definition;
 
-class DefinitionArgumentsValidatorTest extends \PHPUnit_Framework_TestCase
+class DefinitionArgumentsValidatorTest extends TestCase
 {
     /**
      * @test
@@ -128,11 +129,11 @@ public function itConvertsAnAssociativeArrayOfArgumentsToANumericallyIndexedOrde
 
     private function createMockConstructorResolver()
     {
-        return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\ConstructorResolverInterface');
+        return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\ConstructorResolverInterface');
     }
 
     private function createMockArgumentsValidator()
     {
-        return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\ArgumentsValidatorInterface');
+        return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\ArgumentsValidatorInterface');
     }
 }
diff --git a/Tests/Error/Printer/SimpleErrorListPrinterTest.php b/Tests/Error/Printer/SimpleErrorListPrinterTest.php
@@ -4,8 +4,9 @@
 
 use Matthias\SymfonyServiceDefinitionValidator\Error\Printer\SimpleErrorListPrinter;
 use Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorList;
+use PHPUnit\Framework\TestCase;
 
-class SimpleErrorListPrinterTest extends \PHPUnit_Framework_TestCase
+class SimpleErrorListPrinterTest extends TestCase
 {
     public function testPrintsErrorMessageInAList()
     {
@@ -34,7 +35,7 @@ public function testPrintsErrorMessageInAList()
 
     private function createMockError($serviceId, \Exception $exception)
     {
-        $error = $this->getMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorInterface');
+        $error = $this->createMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorInterface');
 
         $error
             ->expects($this->any())
diff --git a/Tests/Error/ValidationErrorFactoryTest.php b/Tests/Error/ValidationErrorFactoryTest.php
@@ -3,8 +3,9 @@
 namespace Matthias\SymfonyServiceDefinitionValidator\Tests\Error;
 
 use Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorFactory;
+use PHPUnit\Framework\TestCase;
 
-class ValidationErrorFactoryTest extends \PHPUnit_Framework_TestCase
+class ValidationErrorFactoryTest extends TestCase
 {
     public function testCreatesValidationError()
     {
@@ -42,8 +43,6 @@ private function createMockDefinition()
 
     private function createMockException()
     {
-        return $this
-            ->getMockBuilder('\Exception')
-            ->getMock();
+        return $this->createMock('\Exception');
     }
 }
diff --git a/Tests/Error/ValidationErrorListTest.php b/Tests/Error/ValidationErrorListTest.php
@@ -3,8 +3,9 @@
 namespace Matthias\SymfonyServiceDefinitionValidator\Tests\Error;
 
 use Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorList;
+use PHPUnit\Framework\TestCase;
 
-class ValidationErrorListTest extends \PHPUnit_Framework_TestCase
+class ValidationErrorListTest extends TestCase
 {
     public function testAddsErrorToList()
     {
@@ -24,6 +25,6 @@ public function testAddsErrorToList()
 
     private function createMockError()
     {
-        return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorInterface');
+        return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorInterface');
     }
 }
diff --git a/Tests/Error/ValidationErrorTest.php b/Tests/Error/ValidationErrorTest.php
@@ -3,8 +3,9 @@
 namespace Matthias\SymfonyServiceDefinitionValidator\Tests\Error;
 
 use Matthias\SymfonyServiceDefinitionValidator\Error\ValidationError;
+use PHPUnit\Framework\TestCase;
 
-class ValidationErrorTest extends \PHPUnit_Framework_TestCase
+class ValidationErrorTest extends TestCase
 {
     public function testConstructor()
     {
@@ -29,8 +30,6 @@ private function createMockDefinition()
 
     private function createMockException()
     {
-        return $this
-            ->getMockBuilder('\Exception')
-            ->getMock();
+        return $this->createMock('\Exception');
     }
 }
diff --git a/Tests/Functional/FunctionalTest.php b/Tests/Functional/FunctionalTest.php
diff --git a/Tests/ResultingClassResolverTest.php b/Tests/ResultingClassResolverTest.php
diff --git a/Tests/ServiceDefinitionValidatorTest.php b/Tests/ServiceDefinitionValidatorTest.php
diff --git a/composer.json b/composer.json
diff --git a/phpunit.xml.dist b/phpunit.xml.dist

Original file line number	Diff line number	Diff line change
`@@ -4,16 +4,17 @@`
`4`	`4`
`5`	`5`	`use Matthias\SymfonyServiceDefinitionValidator\ArgumentValidator;`
`6`	`6`	`use Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException;`
	`7`	`+use PHPUnit\Framework\TestCase;`
`7`	`8`	`use Symfony\Component\DependencyInjection\ContainerBuilder;`
`8`	`9`	`use Symfony\Component\DependencyInjection\Definition;`
`9`	`10`	`use Symfony\Component\DependencyInjection\Reference;`
`10`	`11`	`use Symfony\Component\ExpressionLanguage\Expression;`
`11`	`12`
`12`		`-class ArgumentValidatorTest extends \PHPUnit_Framework_TestCase`
	`13`	`+class ArgumentValidatorTest extends TestCase`
`13`	`14`	`{`
`14`	`15`	`private $containerBuilder;`
`15`	`16`
`16`		`- protected function setUp()`
	`17`	`+ protected function setUp(): void`
`17`	`18`	`{`
`18`	`19`	`$this->containerBuilder = new ContainerBuilder();`
`19`	`20`	`}`
`@@ -24,7 +25,7 @@ public function testFailsWhenParameterHasTypeHintButNoReferenceOrDefinitionWasPr`
`24`	`25`
`25`	`26`	`$validator = new ArgumentValidator($this->containerBuilder, $this->createMockResultingClassResolver());`
`26`	`27`
`27`		`- $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'reference');`
	`28`	`+ $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'reference');`
`28`	`29`	`$validator->validate(new \ReflectionParameter(array($class, '__construct'), 'expected'), new \stdClass());`
`29`	`30`	`}`
`30`	`31`
`@@ -43,7 +44,7 @@ public function testFailsWhenParameterHasTypeHintForObjectButArgumentIsDefinitio`
`43`	`44`	`->will($this->returnValue('Matthias\SymfonyServiceDefinitionValidator\Tests\Fixtures\WrongClass'));`
`44`	`45`	`$validator = new ArgumentValidator($this->containerBuilder, $resultingClassResolver);`
`45`	`46`
`46`		`- $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');`
	`47`	`+ $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');`
`47`	`48`	`$validator->validate(new \ReflectionParameter(array($class, '__construct'), 'expected'), $inlineDefinition);`
`48`	`49`	`}`
`49`	`50`
`@@ -65,7 +66,7 @@ public function testFailsWhenParameterHasTypeHintForObjectButArgumentIsReference`
`65`	`66`	`->will($this->returnValue('stdClass'));`
`66`	`67`	`$validator = new ArgumentValidator($this->containerBuilder, $resultingClassResolver);`
`67`	`68`
`68`		`- $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');`
	`69`	`+ $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');`
`69`	`70`
`70`	`71`	`$validator->validate($parameter, $argument);`
`71`	`72`	`}`
`@@ -79,7 +80,7 @@ public function testFailsWhenParameterHasArrayTypeHintButArgumentIsNotArray()`
`79`	`80`
`80`	`81`	`$validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver());`
`81`	`82`
`82`		`- $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'array');`
	`83`	`+ $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'array');`
`83`	`84`
`84`	`85`	`$validator->validate($parameter, $argument);`
`85`	`86`	`}`
`@@ -114,7 +115,7 @@ public function testFailsWhenResultOfExpressionIsNotAnObjectOfTheExpectedClass()`
`114`	`115`
`115`	`116`	`$validator = new ArgumentValidator($containerBuilder, $this->createMockResultingClassResolver(), true);`
`116`	`117`
`117`		`- $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');`
	`118`	`+ $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');`
`118`	`119`
`119`	`120`	`$validator->validate($parameter, $argument);`
`120`	`121`	`}`
`@@ -130,7 +131,7 @@ public function testFailsWhenResultOfExpressionIsNotAnObject()`
`130`	`131`
`131`	`132`	`$validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver(), true);`
`132`	`133`
`133`		`- $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');`
	`134`	`+ $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');`
`134`	`135`
`135`	`136`	`$validator->validate($parameter, $argument);`
`136`	`137`	`}`
`@@ -164,7 +165,7 @@ public function testFailsIfSyntaxOfExpressionIsInvalid()`
`164`	`165`
`165`	`166`	`$validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver());`
`166`	`167`
`167`		`- $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\InvalidExpressionSyntaxException');`
	`168`	`+ $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\InvalidExpressionSyntaxException');`
`168`	`169`
`169`	`170`	`$validator->validate($parameter, $argument);`
`170`	`171`	`}`
`@@ -180,7 +181,7 @@ public function testFailsIfExpressionCouldNotBeEvaluated()`
`180`	`181`
`181`	`182`	`$validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver(), true);`
`182`	`183`
`183`		`- $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\InvalidExpressionException');`
	`184`	`+ $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\InvalidExpressionException');`
`184`	`185`
`185`	`186`	`$validator->validate($parameter, $argument);`
`186`	`187`	`}`
`@@ -231,14 +232,14 @@ public function testFailsIfContainerReferenceArgumentIsInjectedForParameterWithI`
`231`	`232`	`->willReturn('Symfony\Component\DependencyInjection\Container');`
`232`	`233`	`$validator = new ArgumentValidator(new ContainerBuilder(), $classResolver);`
`233`	`234`
`234`		`- $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');`
	`235`	`+ $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');`
`235`	`236`
`236`	`237`	`$validator->validate($parameter, $argument);`
`237`	`238`	`}`
`238`	`239`
`239`	`240`	`private function createMockResultingClassResolver()`
`240`	`241`	`{`
`241`		`- return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\ResultingClassResolverInterface');`
	`242`	`+ return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\ResultingClassResolverInterface');`
`242`	`243`	`}`
`243`	`244`
`244`	`245`	`private function skipTestIfExpressionsAreNotAvailable()`
Original file line number	Diff line number	Diff line change
`@@ -3,9 +3,10 @@`
`3`	`3`	`namespace Matthias\SymfonyServiceDefinitionValidator\Tests;`
`4`	`4`
`5`	`5`	`use Matthias\SymfonyServiceDefinitionValidator\ArgumentsValidator;`
	`6`	`+use PHPUnit\Framework\TestCase;`
`6`	`7`	`use Symfony\Component\DependencyInjection\ContainerBuilder;`
`7`	`8`
`8`		`-class ArgumentsValidatorTest extends \PHPUnit_Framework_TestCase`
	`9`	`+class ArgumentsValidatorTest extends TestCase`
`9`	`10`	`{`
`10`	`11`	`/**`
`11`	`12`	`* @test`
`@@ -16,13 +17,13 @@ public function ifRequiredArgumentIsMissingFails()`
`16`	`17`	`$class = 'Matthias\SymfonyServiceDefinitionValidator\Tests\Fixtures\ClassWithRequiredConstructorArguments';`
`17`	`18`	`$method = new \ReflectionMethod($class, '__construct');`
`18`	`19`
`19`		`- $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\MissingRequiredArgumentException');`
	`20`	`+ $this->expectException('Matthias\SymfonyServiceDefinitionValidator\Exception\MissingRequiredArgumentException');`
`20`	`21`
`21`	`22`	`$validator->validate($method, array('argument1'));`
`22`	`23`	`}`
`23`	`24`
`24`	`25`	`private function createMockArgumentValidator()`
`25`	`26`	`{`
`26`		`- return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\ArgumentValidatorInterface');`
	`27`	`+ return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\ArgumentValidatorInterface');`
`27`	`28`	`}`
`28`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,8 +4,9 @@`
`4`	`4`
`5`	`5`	`use Matthias\SymfonyServiceDefinitionValidator\BatchServiceDefinitionValidator;`
`6`	`6`	`use Matthias\SymfonyServiceDefinitionValidator\Tests\Fixtures\InvalidServiceDefinitionException;`
	`7`	`+use PHPUnit\Framework\TestCase;`
`7`	`8`
`8`		`-class BatchServiceDefinitionValidatorTest extends \PHPUnit_Framework_TestCase`
	`9`	`+class BatchServiceDefinitionValidatorTest extends TestCase`
`9`	`10`	`{`
`10`	`11`	`public function testCreatesErrorListAndTransformsValidationExceptionIntoErrors()`
`11`	`12`	`{`
`@@ -60,12 +61,12 @@ public function testCreatesErrorListAndTransformsValidationExceptionIntoErrors()`
`60`	`61`
`61`	`62`	`private function createMockErrorFactory()`
`62`	`63`	`{`
`63`		`- return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorFactoryInterface');`
	`64`	`+ return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorFactoryInterface');`
`64`	`65`	`}`
`65`	`66`
`66`	`67`	`private function createMockErrorList()`
`67`	`68`	`{`
`68`		`- return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\Tests\Error\ValidationErrorListInterface');`
	`69`	`+ return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\Tests\Error\ValidationErrorListInterface');`
`69`	`70`	`}`
`70`	`71`
`71`	`72`	`private function createMockDefinition()`
`@@ -78,7 +79,7 @@ private function createMockDefinition()`
`78`	`79`
`79`	`80`	`private function createMockValidator()`
`80`	`81`	`{`
`81`		`- return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\ServiceDefinitionValidatorInterface');`
	`82`	`+ return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\ServiceDefinitionValidatorInterface');`
`82`	`83`	`}`
`83`	`84`
`84`	`85`	`private function createException()`
`@@ -88,6 +89,6 @@ private function createException()`
`88`	`89`
`89`	`90`	`private function createMockError()`
`90`	`91`	`{`
`91`		`- return $this->getMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorInterface');`
	`92`	`+ return $this->createMock('Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorInterface');`
`92`	`93`	`}`
`93`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,8 +3,9 @@`
`3`	`3`	`namespace Matthias\SymfonyServiceDefinitionValidator\Tests\Error;`
`4`	`4`
`5`	`5`	`use Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorFactory;`
	`6`	`+use PHPUnit\Framework\TestCase;`
`6`	`7`
`7`		`-class ValidationErrorFactoryTest extends \PHPUnit_Framework_TestCase`
	`8`	`+class ValidationErrorFactoryTest extends TestCase`
`8`	`9`	`{`
`9`	`10`	`public function testCreatesValidationError()`
`10`	`11`	`{`
`@@ -42,8 +43,6 @@ private function createMockDefinition()`
`42`	`43`
`43`	`44`	`private function createMockException()`
`44`	`45`	`{`
`45`		`- return $this`
`46`		`- ->getMockBuilder('\Exception')`
`47`		`- ->getMock();`
	`46`	`+ return $this->createMock('\Exception');`
`48`	`47`	`}`
`49`	`48`	`}`