ylvarw / module

a/vendor/phpunit/phpunit/tests/unit/Util/TestTest.php

Spacing +16 added lines, -16 removed lines

@@ -125,19 +125,19 @@ 
     public function requirementsProvider(): array
     {
         return [
-            ['testOne',    []],
-            ['testTwo',    ['PHPUnit'    => ['version' => '1.0', 'operator' => '']]],
-            ['testThree',  ['PHP'        => ['version' => '2.0', 'operator' => '']]],
-            ['testFour',   [
+            ['testOne', []],
+            ['testTwo', ['PHPUnit'    => ['version' => '1.0', 'operator' => '']]],
+            ['testThree', ['PHP'        => ['version' => '2.0', 'operator' => '']]],
+            ['testFour', [
                 'PHPUnit'    => ['version' => '2.0', 'operator' => ''],
                 'PHP'        => ['version' => '1.0', 'operator' => ''],
             ]],
-            ['testFive',   ['PHP'        => ['version' => '5.4.0RC6', 'operator' => '']]],
-            ['testSix',    ['PHP'        => ['version' => '5.4.0-alpha1', 'operator' => '']]],
-            ['testSeven',  ['PHP'        => ['version' => '5.4.0beta2', 'operator' => '']]],
-            ['testEight',  ['PHP'        => ['version' => '5.4-dev', 'operator' => '']]],
-            ['testNine',   ['functions'  => ['testFunc']]],
-            ['testTen',    ['extensions' => ['testExt']]],
+            ['testFive', ['PHP'        => ['version' => '5.4.0RC6', 'operator' => '']]],
+            ['testSix', ['PHP'        => ['version' => '5.4.0-alpha1', 'operator' => '']]],
+            ['testSeven', ['PHP'        => ['version' => '5.4.0beta2', 'operator' => '']]],
+            ['testEight', ['PHP'        => ['version' => '5.4-dev', 'operator' => '']]],
+            ['testNine', ['functions'  => ['testFunc']]],
+            ['testTen', ['extensions' => ['testExt']]],
             ['testEleven', [
                 'OS'         => 'SunOS',
                 'OSFAMILY'   => 'Solaris',
@@ -515,12 +515,12 @@ 
     public function missingRequirementsProvider(): array
     {
         return [
-            ['testOne',            []],
-            ['testNine',           ['Function testFunc is required.']],
-            ['testTen',            ['Extension testExt is required.']],
-            ['testAlwaysSkip',     ['PHPUnit >= 1111111 is required.']],
-            ['testAlwaysSkip2',    ['PHP >= 9999999 is required.']],
-            ['testAlwaysSkip3',    ['Operating system matching /DOESNOTEXIST/i is required.']],
+            ['testOne', []],
+            ['testNine', ['Function testFunc is required.']],
+            ['testTen', ['Extension testExt is required.']],
+            ['testAlwaysSkip', ['PHPUnit >= 1111111 is required.']],
+            ['testAlwaysSkip2', ['PHP >= 9999999 is required.']],
+            ['testAlwaysSkip3', ['Operating system matching /DOESNOTEXIST/i is required.']],
             ['testAllPossibleRequirements', [
                 'PHP >= 99-dev is required.',
                 'PHPUnit >= 9-dev is required.',

a/vendor/phpunit/phpunit/tests/unit/Framework/TestCaseTest.php

Spacing +10 added lines, -10 removed lines

@@ -118,7 +118,7 @@ 
 
     public function testExceptionInSetUp(): void
     {
-        $test   = new \ExceptionInSetUpTest('testSomething');
+        $test = new \ExceptionInSetUpTest('testSomething');
         $test->run();
 
         $this->assertTrue($test->setUp);
@@ -130,7 +130,7 @@ 
 
     public function testExceptionInAssertPreConditions(): void
     {
-        $test   = new \ExceptionInAssertPreConditionsTest('testSomething');
+        $test = new \ExceptionInAssertPreConditionsTest('testSomething');
         $test->run();
 
         $this->assertTrue($test->setUp);
@@ -142,7 +142,7 @@ 
 
     public function testExceptionInTest(): void
     {
-        $test   = new \ExceptionInTest('testSomething');
+        $test = new \ExceptionInTest('testSomething');
         $test->run();
 
         $this->assertTrue($test->setUp);
@@ -154,7 +154,7 @@ 
 
     public function testExceptionInAssertPostConditions(): void
     {
-        $test   = new \ExceptionInAssertPostConditionsTest('testSomething');
+        $test = new \ExceptionInAssertPostConditionsTest('testSomething');
         $test->run();
 
         $this->assertTrue($test->setUp);
@@ -166,7 +166,7 @@ 
 
     public function testExceptionInTearDown(): void
     {
-        $test   = new \ExceptionInTearDownTest('testSomething');
+        $test = new \ExceptionInTearDownTest('testSomething');
         $test->run();
 
         $this->assertTrue($test->setUp);
@@ -180,7 +180,7 @@ 
 
     public function testExceptionInTestIsDetectedInTeardown(): void
     {
-        $test   = new \ExceptionInTestDetectedInTeardown('testSomething');
+        $test = new \ExceptionInTestDetectedInTeardown('testSomething');
         $test->run();
 
         $this->assertTrue($test->exceptionDetected);
@@ -558,7 +558,7 @@ 
 
     public function testSkipsIfRequiresNonExistingExtension(): void
     {
-        $test   = new \RequirementsTest('testTen');
+        $test = new \RequirementsTest('testTen');
         $test->run();
 
         $this->assertEquals(
@@ -569,7 +569,7 @@ 
 
     public function testSkipsIfRequiresExtensionWithAMinimumVersion(): void
     {
-        $test   = new \RequirementsTest('testSpecificExtensionVersion');
+        $test = new \RequirementsTest('testSpecificExtensionVersion');
         $test->run();
 
         $this->assertEquals(
@@ -580,7 +580,7 @@ 
 
     public function testSkipsProvidesMessagesForAllSkippingReasons(): void
     {
-        $test   = new \RequirementsTest('testAllPossibleRequirements');
+        $test = new \RequirementsTest('testAllPossibleRequirements');
         $test->run();
 
         $this->assertEquals(
@@ -627,7 +627,7 @@ 
 
     public function testRequiringASetting(): void
     {
-        $test   = new \RequirementsTest('testSettingDisplayErrorsOn');
+        $test = new \RequirementsTest('testSettingDisplayErrorsOn');
 
         // Get this so we can return it to whatever it was before the test.
         $displayErrorsVal = \ini_get('display_errors');

a/vendor/phpunit/phpunit/tests/unit/Framework/TestResultTest.php

Spacing +1 added lines, -1 removed lines

@@ -55,7 +55,7 @@
         //Stop
         $result->stopOnIncomplete(true);
         $result->addError($test, $throwable, $time);
-        $this->assertAttributeEquals(2 * $time, 'time', $result);
+        $this->assertAttributeEquals(2*$time, 'time', $result);
         $this->assertAttributeCount(2, 'notImplemented', $result);
         $this->assertAttributeEquals(true, 'stop', $result);
         //Final checks

a/vendor/phpunit/phpunit/tests/unit/Framework/MockObject/MockObjectTest.php

Indentation +176 added lines, -176 removed lines

@@ -17,20 +17,20 @@ 
     public function testMockedMethodIsNeverCalled(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->never())
-             ->method('doSomething');
+                ->method('doSomething');
     }
 
     public function testMockedMethodIsNeverCalledWithParameter(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->never())
-             ->method('doSomething')
-             ->with('someArg');
+                ->method('doSomething')
+                ->with('someArg');
     }
 
     /**
@@ -39,11 +39,11 @@ 
     public function testMockedMethodIsNotCalledWhenExpectsAnyWithParameter(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomethingElse')
-             ->with('someArg');
+                ->method('doSomethingElse')
+                ->with('someArg');
     }
 
     /**
@@ -52,19 +52,19 @@ 
     public function testMockedMethodIsNotCalledWhenMethodSpecifiedDirectlyWithParameter(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->method('doSomethingElse')
-             ->with('someArg');
+                ->with('someArg');
     }
 
     public function testMockedMethodIsCalledAtLeastOnce(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->atLeastOnce())
-             ->method('doSomething');
+                ->method('doSomething');
 
         $mock->doSomething();
     }
@@ -72,10 +72,10 @@ 
     public function testMockedMethodIsCalledAtLeastOnce2(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->atLeastOnce())
-             ->method('doSomething');
+                ->method('doSomething');
 
         $mock->doSomething();
         $mock->doSomething();
@@ -84,10 +84,10 @@ 
     public function testMockedMethodIsCalledAtLeastTwice(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->atLeast(2))
-             ->method('doSomething');
+                ->method('doSomething');
 
         $mock->doSomething();
         $mock->doSomething();
@@ -96,10 +96,10 @@ 
     public function testMockedMethodIsCalledAtLeastTwice2(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->atLeast(2))
-             ->method('doSomething');
+                ->method('doSomething');
 
         $mock->doSomething();
         $mock->doSomething();
@@ -109,10 +109,10 @@ 
     public function testMockedMethodIsCalledAtMostTwice(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->atMost(2))
-             ->method('doSomething');
+                ->method('doSomething');
 
         $mock->doSomething();
         $mock->doSomething();
@@ -121,10 +121,10 @@ 
     public function testMockedMethodIsCalledAtMosttTwice2(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->atMost(2))
-             ->method('doSomething');
+                ->method('doSomething');
 
         $mock->doSomething();
     }
@@ -132,10 +132,10 @@ 
     public function testMockedMethodIsCalledOnce(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('doSomething');
+                ->method('doSomething');
 
         $mock->doSomething();
     }
@@ -143,11 +143,11 @@ 
     public function testMockedMethodIsCalledOnceWithParameter(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('doSomethingElse')
-             ->with($this->equalTo('something'));
+                ->method('doSomethingElse')
+                ->with($this->equalTo('something'));
 
         $mock->doSomethingElse('something');
     }
@@ -155,10 +155,10 @@ 
     public function testMockedMethodIsCalledExactly(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->exactly(2))
-             ->method('doSomething');
+                ->method('doSomething');
 
         $mock->doSomething();
         $mock->doSomething();
@@ -167,11 +167,11 @@ 
     public function testStubbedException(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->will($this->throwException(new \Exception));
+                ->method('doSomething')
+                ->will($this->throwException(new \Exception));
 
         $this->expectException(\Exception::class);
 
@@ -181,11 +181,11 @@ 
     public function testStubbedWillThrowException(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->willThrowException(new \Exception);
+                ->method('doSomething')
+                ->willThrowException(new \Exception);
 
         $this->expectException(\Exception::class);
 
@@ -195,20 +195,20 @@ 
     public function testStubbedReturnValue(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->will($this->returnValue('something'));
+                ->method('doSomething')
+                ->will($this->returnValue('something'));
 
         $this->assertEquals('something', $mock->doSomething());
 
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturn('something');
+                ->method('doSomething')
+                ->willReturn('something');
 
         $this->assertEquals('something', $mock->doSomething());
     }
@@ -221,22 +221,22 @@ 
         ];
 
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->will($this->returnValueMap($map));
+                ->method('doSomething')
+                ->will($this->returnValueMap($map));
 
         $this->assertEquals('d', $mock->doSomething('a', 'b', 'c'));
         $this->assertEquals('h', $mock->doSomething('e', 'f', 'g'));
         $this->assertNull($mock->doSomething('foo', 'bar'));
 
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturnMap($map);
+                ->method('doSomething')
+                ->willReturnMap($map);
 
         $this->assertEquals('d', $mock->doSomething('a', 'b', 'c'));
         $this->assertEquals('h', $mock->doSomething('e', 'f', 'g'));
@@ -246,20 +246,20 @@ 
     public function testStubbedReturnArgument(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->will($this->returnArgument(1));
+                ->method('doSomething')
+                ->will($this->returnArgument(1));
 
         $this->assertEquals('b', $mock->doSomething('a', 'b'));
 
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturnArgument(1);
+                ->method('doSomething')
+                ->willReturnArgument(1);
 
         $this->assertEquals('b', $mock->doSomething('a', 'b'));
     }
@@ -267,22 +267,22 @@ 
     public function testFunctionCallback(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['doSomething'])
-                     ->getMock();
+                        ->setMethods(['doSomething'])
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('doSomething')
-             ->will($this->returnCallback('FunctionCallbackWrapper::functionCallback'));
+                ->method('doSomething')
+                ->will($this->returnCallback('FunctionCallbackWrapper::functionCallback'));
 
         $this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
 
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['doSomething'])
-                     ->getMock();
+                        ->setMethods(['doSomething'])
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('doSomething')
-             ->willReturnCallback('FunctionCallbackWrapper::functionCallback');
+                ->method('doSomething')
+                ->willReturnCallback('FunctionCallbackWrapper::functionCallback');
 
         $this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
     }
@@ -290,20 +290,20 @@ 
     public function testStubbedReturnSelf(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->will($this->returnSelf());
+                ->method('doSomething')
+                ->will($this->returnSelf());
 
         $this->assertEquals($mock, $mock->doSomething());
 
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturnSelf();
+                ->method('doSomething')
+                ->willReturnSelf();
 
         $this->assertEquals($mock, $mock->doSomething());
     }
@@ -311,22 +311,22 @@ 
     public function testStubbedReturnOnConsecutiveCalls(): void
     {
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->will($this->onConsecutiveCalls('a', 'b', 'c'));
+                ->method('doSomething')
+                ->will($this->onConsecutiveCalls('a', 'b', 'c'));
 
         $this->assertEquals('a', $mock->doSomething());
         $this->assertEquals('b', $mock->doSomething());
         $this->assertEquals('c', $mock->doSomething());
 
         $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturnOnConsecutiveCalls('a', 'b', 'c');
+                ->method('doSomething')
+                ->willReturnOnConsecutiveCalls('a', 'b', 'c');
 
         $this->assertEquals('a', $mock->doSomething());
         $this->assertEquals('b', $mock->doSomething());
@@ -336,12 +336,12 @@ 
     public function testStaticMethodCallback(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['doSomething'])
-                     ->getMock();
+                        ->setMethods(['doSomething'])
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('doSomething')
-             ->will($this->returnCallback(['MethodCallback', 'staticCallback']));
+                ->method('doSomething')
+                ->will($this->returnCallback(['MethodCallback', 'staticCallback']));
 
         $this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
     }
@@ -349,12 +349,12 @@ 
     public function testPublicMethodCallback(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['doSomething'])
-                     ->getMock();
+                        ->setMethods(['doSomething'])
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('doSomething')
-             ->will($this->returnCallback([new MethodCallback, 'nonStaticCallback']));
+                ->method('doSomething')
+                ->will($this->returnCallback([new MethodCallback, 'nonStaticCallback']));
 
         $this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
     }
@@ -362,10 +362,10 @@ 
     public function testMockClassOnlyGeneratedOnce(): void
     {
         $mock1 = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock2 = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+                        ->getMock();
 
         $this->assertEquals(\get_class($mock1), \get_class($mock2));
     }
@@ -373,23 +373,23 @@ 
     public function testMockClassDifferentForPartialMocks(): void
     {
         $mock1 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->getMock();
+                        ->getMock();
 
         $mock2 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMethods(['doSomething'])
-                      ->getMock();
+                        ->setMethods(['doSomething'])
+                        ->getMock();
 
         $mock3 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMethods(['doSomething'])
-                      ->getMock();
+                        ->setMethods(['doSomething'])
+                        ->getMock();
 
         $mock4 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMethods(['doAnotherThing'])
-                      ->getMock();
+                        ->setMethods(['doAnotherThing'])
+                        ->getMock();
 
         $mock5 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMethods(['doAnotherThing'])
-                      ->getMock();
+                        ->setMethods(['doAnotherThing'])
+                        ->getMock();
 
         $this->assertNotEquals(\get_class($mock1), \get_class($mock2));
         $this->assertNotEquals(\get_class($mock1), \get_class($mock3));
@@ -404,23 +404,23 @@ 
     public function testMockClassStoreOverrulable(): void
     {
         $mock1 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->getMock();
+                        ->getMock();
 
         $mock2 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMockClassName('MyMockClassNameForPartialMockTestClass1')
-                      ->getMock();
+                        ->setMockClassName('MyMockClassNameForPartialMockTestClass1')
+                        ->getMock();
 
         $mock3 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->getMock();
+                        ->getMock();
 
         $mock4 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMethods(['doSomething'])
-                      ->setMockClassName('AnotherMockClassNameForPartialMockTestClass')
-                      ->getMock();
+                        ->setMethods(['doSomething'])
+                        ->setMockClassName('AnotherMockClassNameForPartialMockTestClass')
+                        ->getMock();
 
         $mock5 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMockClassName('MyMockClassNameForPartialMockTestClass2')
-                      ->getMock();
+                        ->setMockClassName('MyMockClassNameForPartialMockTestClass2')
+                        ->getMock();
 
         $this->assertNotEquals(\get_class($mock1), \get_class($mock2));
         $this->assertEquals(\get_class($mock1), \get_class($mock3));
@@ -442,11 +442,11 @@ 
     public function testOriginalConstructorSettingConsidered(): void
     {
         $mock1 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->getMock();
+                        ->getMock();
 
         $mock2 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->disableOriginalConstructor()
-                      ->getMock();
+                        ->disableOriginalConstructor()
+                        ->getMock();
 
         $this->assertTrue($mock1->constructorCalled);
         $this->assertFalse($mock2->constructorCalled);
@@ -455,11 +455,11 @@ 
     public function testOriginalCloneSettingConsidered(): void
     {
         $mock1 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->getMock();
+                        ->getMock();
 
         $mock2 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->disableOriginalClone()
-                      ->getMock();
+                        ->disableOriginalClone()
+                        ->getMock();
 
         $this->assertNotEquals(\get_class($mock1), \get_class($mock2));
     }
@@ -467,10 +467,10 @@ 
     public function testGetMockForAbstractClass(): void
     {
         $mock = $this->getMockBuilder(AbstractMockTestClass::class)
-                     ->getMock();
+                        ->getMock();
 
         $mock->expects($this->never())
-             ->method('doSomething');
+                ->method('doSomething');
     }
 
     /**
@@ -479,7 +479,7 @@ 
     public function testGetMockForTraversable($type): void
     {
         $mock = $this->getMockBuilder($type)
-                     ->getMock();
+                        ->getMock();
 
         $this->assertInstanceOf(Traversable::class, $mock);
     }
@@ -487,7 +487,7 @@ 
     public function testMultipleInterfacesCanBeMockedInSingleObject(): void
     {
         $mock = $this->getMockBuilder([AnInterface::class, AnotherInterface::class])
-                     ->getMock();
+                        ->getMock();
 
         $this->assertInstanceOf(AnInterface::class, $mock);
         $this->assertInstanceOf(AnotherInterface::class, $mock);
@@ -498,7 +498,7 @@ 
         $mock = $this->getMockForTrait(AbstractTrait::class);
 
         $mock->expects($this->never())
-             ->method('doSomething');
+                ->method('doSomething');
 
         $parent = \get_parent_class($mock);
         $traits = \class_uses($parent, false);
@@ -509,7 +509,7 @@ 
     public function testClonedMockObjectShouldStillEqualTheOriginal(): void
     {
         $a = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
+                    ->getMock();
 
         $b = clone $a;
 
@@ -519,10 +519,10 @@ 
     public function testMockObjectsConstructedIndepentantlyShouldBeEqual(): void
     {
         $a = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
+                    ->getMock();
 
         $b = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
+                    ->getMock();
 
         $this->assertEquals($a, $b);
     }
@@ -530,10 +530,10 @@ 
     public function testMockObjectsConstructedIndepentantlyShouldNotBeTheSame(): void
     {
         $a = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
+                    ->getMock();
 
         $b = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
+                    ->getMock();
 
         $this->assertNotSame($a, $b);
     }
@@ -541,17 +541,17 @@ 
     public function testClonedMockObjectCanBeUsedInPlaceOfOriginalOne(): void
     {
         $x = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
+                    ->getMock();
 
         $y = clone $x;
 
         $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+                        ->setMethods(['foo'])
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('foo')
-             ->with($this->equalTo($x));
+                ->method('foo')
+                ->with($this->equalTo($x));
 
         $mock->foo($y);
     }
@@ -559,17 +559,17 @@ 
     public function testClonedMockObjectIsNotIdenticalToOriginalOne(): void
     {
         $x = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
+                    ->getMock();
 
         $y = clone $x;
 
         $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+                        ->setMethods(['foo'])
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('foo')
-             ->with($this->logicalNot($this->identicalTo($x)));
+                ->method('foo')
+                ->with($this->logicalNot($this->identicalTo($x)));
 
         $mock->foo($y);
     }
@@ -579,21 +579,21 @@ 
         $expectedObject = new stdClass;
 
         $mock = $this->getMockBuilder('SomeClass')
-                     ->setMethods(['doSomethingElse'])
-                     ->enableArgumentCloning()
-                     ->getMock();
+                        ->setMethods(['doSomethingElse'])
+                        ->enableArgumentCloning()
+                        ->getMock();
 
         $actualArguments = [];
 
         $mock->expects($this->any())
-             ->method('doSomethingElse')
-             ->will(
-                 $this->returnCallback(
-                     function () use (&$actualArguments): void {
-                         $actualArguments = \func_get_args();
-                     }
-                 )
-             );
+                ->method('doSomethingElse')
+                ->will(
+                    $this->returnCallback(
+                        function () use (&$actualArguments): void {
+                            $actualArguments = \func_get_args();
+                        }
+                    )
+                );
 
         $mock->doSomethingElse($expectedObject);
 
@@ -607,21 +607,21 @@ 
         $expectedObject = new stdClass;
 
         $mock = $this->getMockBuilder('SomeClass')
-                     ->setMethods(['doSomethingElse'])
-                     ->disableArgumentCloning()
-                     ->getMock();
+                        ->setMethods(['doSomethingElse'])
+                        ->disableArgumentCloning()
+                        ->getMock();
 
         $actualArguments = [];
 
         $mock->expects($this->any())
-             ->method('doSomethingElse')
-             ->will(
-                 $this->returnCallback(
-                     function () use (&$actualArguments): void {
-                         $actualArguments = \func_get_args();
-                     }
-                 )
-             );
+                ->method('doSomethingElse')
+                ->will(
+                    $this->returnCallback(
+                        function () use (&$actualArguments): void {
+                            $actualArguments = \func_get_args();
+                        }
+                    )
+                );
 
         $mock->doSomethingElse($expectedObject);
 
@@ -637,9 +637,9 @@ 
                                 ->getMock();
 
         $mockWithoutCloning = $this->getMockBuilder('SomeClass')
-                                   ->setMethods(['doSomethingElse'])
-                                   ->disableArgumentCloning()
-                                   ->getMock();
+                                    ->setMethods(['doSomethingElse'])
+                                    ->disableArgumentCloning()
+                                    ->getMock();
 
         $this->assertNotEquals($mockWithCloning, $mockWithoutCloning);
     }
@@ -647,11 +647,11 @@ 
     public function testVerificationOfMethodNameFailsWithoutParameters(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
+                        ->setMethods(['right', 'wrong'])
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('right');
+                ->method('right');
 
         $mock->wrong();
 
@@ -672,11 +672,11 @@ 
     public function testVerificationOfMethodNameFailsWithParameters(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
+                        ->setMethods(['right', 'wrong'])
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('right');
+                ->method('right');
 
         $mock->wrong();
 
@@ -697,12 +697,12 @@ 
     public function testVerificationOfMethodNameFailsWithWrongParameters(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
+                        ->setMethods(['right', 'wrong'])
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('right')
-             ->with(['first', 'second']);
+                ->method('right')
+                ->with(['first', 'second']);
 
         try {
             $mock->right(['second']);
@@ -743,12 +743,12 @@ 
     public function testVerificationOfNeverFailsWithEmptyParameters(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
+                        ->setMethods(['right', 'wrong'])
+                        ->getMock();
 
         $mock->expects($this->never())
-             ->method('right')
-             ->with();
+                ->method('right')
+                ->with();
 
         try {
             $mock->right();
@@ -766,12 +766,12 @@ 
     public function testVerificationOfNeverFailsWithAnyParameters(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
+                        ->setMethods(['right', 'wrong'])
+                        ->getMock();
 
         $mock->expects($this->never())
-             ->method('right')
-             ->withAnyParameters();
+                ->method('right')
+                ->withAnyParameters();
 
         try {
             $mock->right();
@@ -789,12 +789,12 @@ 
     public function testWithAnythingInsteadOfWithAnyParameters(): void
     {
         $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
+                        ->setMethods(['right', 'wrong'])
+                        ->getMock();
 
         $mock->expects($this->once())
-             ->method('right')
-             ->with($this->anything());
+                ->method('right')
+                ->with($this->anything());
 
         try {
             $mock->right();
@@ -982,8 +982,8 @@ 
         $this->assertInstanceOf(
             ClassThatImplementsSerializable::class,
             $this->getMockBuilder(ClassThatImplementsSerializable::class)
-                 ->disableOriginalConstructor()
-                 ->getMock()
+                    ->disableOriginalConstructor()
+                    ->getMock()
         );
     }
 

Spacing +7 added lines, -7 removed lines

@@ -589,7 +589,7 @@ 
              ->method('doSomethingElse')
              ->will(
                  $this->returnCallback(
-                     function () use (&$actualArguments): void {
+                     function() use (&$actualArguments): void {
                          $actualArguments = \func_get_args();
                      }
                  )
@@ -617,7 +617,7 @@ 
              ->method('doSomethingElse')
              ->will(
                  $this->returnCallback(
-                     function () use (&$actualArguments): void {
+                     function() use (&$actualArguments): void {
                          $actualArguments = \func_get_args();
                      }
                  )
@@ -846,7 +846,7 @@ 
         $foo->expects($this->any())
             ->method('bar')
             ->will($this->returnCallback(
-                function (&$a, &$b, $c): void {
+                function(&$a, &$b, $c): void {
                     $b = 1;
                 }
             ));
@@ -1000,7 +1000,7 @@ 
         /** @var PHPUnit\Framework\MockObject\MockObject|StringableClass $mock */
         $mock = $this->getMockBuilder(StringableClass::class)->getMock();
 
-        $this->assertIsString((string) $mock);
+        $this->assertIsString((string)$mock);
     }
 
     public function testStringableClassCanBeMocked(): void
@@ -1010,7 +1010,7 @@ 
 
         $mock->method('__toString')->willReturn('foo');
 
-        $this->assertSame('foo', (string) $mock);
+        $this->assertSame('foo', (string)$mock);
     }
 
     public function traversableProvider(): array
@@ -1032,7 +1032,7 @@ 
         $callCount             = 0;
 
         $mock->expects($this->exactly($expectedNumberOfCalls))->method('bar')
-            ->with($this->callback(function ($argument) use (&$callCount) {
+            ->with($this->callback(function($argument) use (&$callCount) {
                 return $argument === 'call_' . $callCount++;
             }));
 
@@ -1076,7 +1076,7 @@ 
             ->disableAutoReturnValueGeneration()
             ->getMock();
 
-        (string) $mock;
+        (string)$mock;
 
         try {
             $mock->__phpunit_verify();

a/vendor/phpunit/phpunit/tests/unit/Framework/MockObject/GeneratorTest.php

Indentation +2 added lines, -2 removed lines

@@ -102,8 +102,8 @@
         $mock = $this->generator->getMockForAbstractClass(AbstractMockTestClass::class);
 
         $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturn('testing');
+                ->method('doSomething')
+                ->willReturn('testing');
 
         $this->assertEquals('testing', $mock->doSomething());
         $this->assertEquals(1, $mock->returnAnything());

a/vendor/phpunit/phpunit/tests/unit/Framework/MockObject/MockBuilderTest.php

Indentation +17 added lines, -17 removed lines

@@ -31,8 +31,8 @@ 
     public function testMethodsToMockCanBeSpecified(): void
     {
         $mock = $this->getMockBuilder(Mockable::class)
-                     ->setMethods(['mockableMethod'])
-                     ->getMock();
+                        ->setMethods(['mockableMethod'])
+                        ->getMock();
 
         $this->assertNull($mock->mockableMethod());
         $this->assertTrue($mock->anotherMockableMethod());
@@ -68,8 +68,8 @@ 
     public function testMockClassNameCanBeSpecified(): void
     {
         $mock = $this->getMockBuilder(Mockable::class)
-                     ->setMockClassName('ACustomClassName')
-                     ->getMock();
+                        ->setMockClassName('ACustomClassName')
+                        ->getMock();
 
         $this->assertInstanceOf(ACustomClassName::class, $mock);
     }
@@ -77,8 +77,8 @@ 
     public function testConstructorArgumentsCanBeSpecified(): void
     {
         $mock = $this->getMockBuilder(Mockable::class)
-                     ->setConstructorArgs([23, 42])
-                     ->getMock();
+                        ->setConstructorArgs([23, 42])
+                        ->getMock();
 
         $this->assertEquals([23, 42], $mock->constructorArgs);
     }
@@ -86,8 +86,8 @@ 
     public function testOriginalConstructorCanBeDisabled(): void
     {
         $mock = $this->getMockBuilder(Mockable::class)
-                     ->disableOriginalConstructor()
-                     ->getMock();
+                        ->disableOriginalConstructor()
+                        ->getMock();
 
         $this->assertNull($mock->constructorArgs);
     }
@@ -95,7 +95,7 @@ 
     public function testByDefaultOriginalCloneIsPreserved(): void
     {
         $mock = $this->getMockBuilder(Mockable::class)
-                     ->getMock();
+                        ->getMock();
 
         $cloned = clone $mock;
 
@@ -105,8 +105,8 @@ 
     public function testOriginalCloneCanBeDisabled(): void
     {
         $mock = $this->getMockBuilder(Mockable::class)
-                     ->disableOriginalClone()
-                     ->getMock();
+                        ->disableOriginalClone()
+                        ->getMock();
 
         $mock->cloned = false;
         $cloned       = clone $mock;
@@ -117,12 +117,12 @@ 
     public function testProvidesAFluentInterface(): void
     {
         $spec = $this->getMockBuilder(Mockable::class)
-                     ->setMethods(['mockableMethod'])
-                     ->setConstructorArgs([])
-                     ->setMockClassName('DummyClassName')
-                     ->disableOriginalConstructor()
-                     ->disableOriginalClone()
-                     ->disableAutoload();
+                        ->setMethods(['mockableMethod'])
+                        ->setConstructorArgs([])
+                        ->setMockClassName('DummyClassName')
+                        ->disableOriginalConstructor()
+                        ->disableOriginalClone()
+                        ->disableAutoload();
 
         $this->assertInstanceOf(MockBuilder::class, $spec);
     }

a/vendor/phpunit/phpunit/tests/unit/Framework/MockObject/Matcher/ConsecutiveParametersTest.php

Indentation +20 added lines, -20 removed lines

@@ -17,15 +17,15 @@ 
     public function testIntegration(): void
     {
         $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+                        ->setMethods(['foo'])
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('foo')
-             ->withConsecutive(
-                 ['bar'],
-                 [21, 42]
-             );
+                ->method('foo')
+                ->withConsecutive(
+                    ['bar'],
+                    [21, 42]
+                );
 
         $this->assertNull($mock->foo('bar'));
         $this->assertNull($mock->foo(21, 42));
@@ -34,14 +34,14 @@ 
     public function testIntegrationWithLessAssertionsThanMethodCalls(): void
     {
         $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+                        ->setMethods(['foo'])
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('foo')
-             ->withConsecutive(
-                 ['bar']
-             );
+                ->method('foo')
+                ->withConsecutive(
+                    ['bar']
+                );
 
         $this->assertNull($mock->foo('bar'));
         $this->assertNull($mock->foo(21, 42));
@@ -50,15 +50,15 @@ 
     public function testIntegrationExpectingException(): void
     {
         $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+                        ->setMethods(['foo'])
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('foo')
-             ->withConsecutive(
-                 ['bar'],
-                 [21, 42]
-             );
+                ->method('foo')
+                ->withConsecutive(
+                    ['bar'],
+                    [21, 42]
+                );
 
         $mock->foo('bar');
 

a/vendor/phpunit/phpunit/tests/unit/Framework/MockObject/Builder/InvocationMockerTest.php

Indentation +16 added lines, -16 removed lines

@@ -16,12 +16,12 @@ 
     public function testWillReturnWithOneValue(): void
     {
         $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+                        ->setMethods(['foo'])
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('foo')
-             ->willReturn(1);
+                ->method('foo')
+                ->willReturn(1);
 
         $this->assertEquals(1, $mock->foo());
     }
@@ -29,12 +29,12 @@ 
     public function testWillReturnWithMultipleValues(): void
     {
         $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+                        ->setMethods(['foo'])
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('foo')
-             ->willReturn(1, 2, 3);
+                ->method('foo')
+                ->willReturn(1, 2, 3);
 
         $this->assertEquals(1, $mock->foo());
         $this->assertEquals(2, $mock->foo());
@@ -44,12 +44,12 @@ 
     public function testWillReturnOnConsecutiveCalls(): void
     {
         $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+                        ->setMethods(['foo'])
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('foo')
-             ->willReturnOnConsecutiveCalls(1, 2, 3);
+                ->method('foo')
+                ->willReturnOnConsecutiveCalls(1, 2, 3);
 
         $this->assertEquals(1, $mock->foo());
         $this->assertEquals(2, $mock->foo());
@@ -59,12 +59,12 @@ 
     public function testWillReturnByReference(): void
     {
         $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+                        ->setMethods(['foo'])
+                        ->getMock();
 
         $mock->expects($this->any())
-             ->method('foo')
-             ->willReturnReference($value);
+                ->method('foo')
+                ->willReturnReference($value);
 
         $this->assertNull($mock->foo());
         $value = 'foo';

a/vendor/phpunit/phpunit/tests/unit/Framework/MockObject/ProxyObjectTest.php

Indentation +6 added lines, -6 removed lines

@@ -18,7 +18,7 @@ 
         $proxy = $this->createTestProxy(TestProxyFixture::class);
 
         $proxy->expects($this->once())
-              ->method('returnString');
+                ->method('returnString');
 
         \assert($proxy instanceof MockObject);
         \assert($proxy instanceof TestProxyFixture);
@@ -31,7 +31,7 @@ 
         $proxy = $this->createTestProxy(TestProxyFixture::class);
 
         $proxy->expects($this->once())
-              ->method('returnTypedString');
+                ->method('returnTypedString');
 
         \assert($proxy instanceof MockObject);
         \assert($proxy instanceof TestProxyFixture);
@@ -44,7 +44,7 @@ 
         $proxy = $this->createTestProxy(TestProxyFixture::class);
 
         $proxy->expects($this->once())
-              ->method('returnObject');
+                ->method('returnObject');
 
         \assert($proxy instanceof MockObject);
         \assert($proxy instanceof TestProxyFixture);
@@ -57,7 +57,7 @@ 
         $proxy = $this->createTestProxy(TestProxyFixture::class);
 
         $proxy->expects($this->once())
-              ->method('returnTypedObject');
+                ->method('returnTypedObject');
 
         \assert($proxy instanceof MockObject);
         \assert($proxy instanceof TestProxyFixture);
@@ -70,7 +70,7 @@ 
         $proxy = $this->createTestProxy(TestProxyFixture::class);
 
         $proxy->expects($this->once())
-              ->method('returnObjectOfFinalClass');
+                ->method('returnObjectOfFinalClass');
 
         \assert($proxy instanceof MockObject);
         \assert($proxy instanceof TestProxyFixture);
@@ -83,7 +83,7 @@ 
         $proxy = $this->createTestProxy(TestProxyFixture::class);
 
         $proxy->expects($this->once())
-              ->method('returnTypedObjectOfFinalClass');
+                ->method('returnTypedObjectOfFinalClass');
 
         \assert($proxy instanceof MockObject);
         \assert($proxy instanceof TestProxyFixture);