chillerlan / php-traits

vendor/phpunit/phpunit-mock-objects/tests/Invocation/StaticTest.php

Indentation +70 added lines, -70 removed lines

@@ -12,87 +12,87 @@
 
 class Framework_MockObject_Invocation_StaticTest extends TestCase
 {
-    public function testConstructorRequiresClassAndMethodAndParameters()
-    {
-        $this->assertInstanceOf(
-            PHPUnit_Framework_MockObject_Invocation_Static::class,
-            new PHPUnit_Framework_MockObject_Invocation_Static(
-                'FooClass',
-                'FooMethod',
-                ['an_argument'],
-                'ReturnType'
-            )
-        );
-    }
+	public function testConstructorRequiresClassAndMethodAndParameters()
+	{
+		$this->assertInstanceOf(
+			PHPUnit_Framework_MockObject_Invocation_Static::class,
+			new PHPUnit_Framework_MockObject_Invocation_Static(
+				'FooClass',
+				'FooMethod',
+				['an_argument'],
+				'ReturnType'
+			)
+		);
+	}
 
-    public function testAllowToGetClassNameSetInConstructor()
-    {
-        $invocation = new PHPUnit_Framework_MockObject_Invocation_Static(
-            'FooClass',
-            'FooMethod',
-            ['an_argument'],
-            'ReturnType'
-        );
+	public function testAllowToGetClassNameSetInConstructor()
+	{
+		$invocation = new PHPUnit_Framework_MockObject_Invocation_Static(
+			'FooClass',
+			'FooMethod',
+			['an_argument'],
+			'ReturnType'
+		);
 
-        $this->assertSame('FooClass', $invocation->className);
-    }
+		$this->assertSame('FooClass', $invocation->className);
+	}
 
-    public function testAllowToGetMethodNameSetInConstructor()
-    {
-        $invocation = new PHPUnit_Framework_MockObject_Invocation_Static(
-            'FooClass',
-            'FooMethod',
-            ['an_argument'],
-            'ReturnType'
-        );
+	public function testAllowToGetMethodNameSetInConstructor()
+	{
+		$invocation = new PHPUnit_Framework_MockObject_Invocation_Static(
+			'FooClass',
+			'FooMethod',
+			['an_argument'],
+			'ReturnType'
+		);
 
-        $this->assertSame('FooMethod', $invocation->methodName);
-    }
+		$this->assertSame('FooMethod', $invocation->methodName);
+	}
 
-    public function testAllowToGetMethodParametersSetInConstructor()
-    {
-        $expectedParameters = [
-          'foo', 5, ['a', 'b'], new stdClass, null, false
-        ];
+	public function testAllowToGetMethodParametersSetInConstructor()
+	{
+		$expectedParameters = [
+		  'foo', 5, ['a', 'b'], new stdClass, null, false
+		];
 
-        $invocation = new PHPUnit_Framework_MockObject_Invocation_Static(
-            'FooClass',
-            'FooMethod',
-            $expectedParameters,
-            'ReturnType'
-        );
+		$invocation = new PHPUnit_Framework_MockObject_Invocation_Static(
+			'FooClass',
+			'FooMethod',
+			$expectedParameters,
+			'ReturnType'
+		);
 
-        $this->assertSame($expectedParameters, $invocation->parameters);
-    }
+		$this->assertSame($expectedParameters, $invocation->parameters);
+	}
 
-    public function testConstructorAllowToSetFlagCloneObjectsInParameters()
-    {
-        $parameters   = [new stdClass];
-        $cloneObjects = true;
+	public function testConstructorAllowToSetFlagCloneObjectsInParameters()
+	{
+		$parameters   = [new stdClass];
+		$cloneObjects = true;
 
-        $invocation = new PHPUnit_Framework_MockObject_Invocation_Static(
-            'FooClass',
-            'FooMethod',
-            $parameters,
-            'ReturnType',
-            $cloneObjects
-        );
+		$invocation = new PHPUnit_Framework_MockObject_Invocation_Static(
+			'FooClass',
+			'FooMethod',
+			$parameters,
+			'ReturnType',
+			$cloneObjects
+		);
 
-        $this->assertEquals($parameters, $invocation->parameters);
-        $this->assertNotSame($parameters, $invocation->parameters);
-    }
+		$this->assertEquals($parameters, $invocation->parameters);
+		$this->assertNotSame($parameters, $invocation->parameters);
+	}
 
-    public function testAllowToGetReturnTypeSetInConstructor()
-    {
-        $expectedReturnType = 'string';
+	public function testAllowToGetReturnTypeSetInConstructor()
+	{
+		$expectedReturnType = 'string';
 
-        $invocation = new PHPUnit_Framework_MockObject_Invocation_Static(
-            'FooClass',
-            'FooMethod',
-            ['an_argument'],
-            $expectedReturnType
-        );
+		$invocation = new PHPUnit_Framework_MockObject_Invocation_Static(
+			'FooClass',
+			'FooMethod',
+			['an_argument'],
+			$expectedReturnType
+		);
 
-        $this->assertSame($expectedReturnType, $invocation->returnType);
-    }
+		$this->assertSame($expectedReturnType, $invocation->returnType);
+	}
 }

vendor/phpunit/phpunit-mock-objects/tests/Matcher/ConsecutiveParametersTest.php

Indentation +42 added lines, -42 removed lines

@@ -13,56 +13,56 @@
 
 class Framework_MockObject_Matcher_ConsecutiveParametersTest extends TestCase
 {
-    public function testIntegration()
-    {
-        $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+	public function testIntegration()
+	{
+		$mock = $this->getMockBuilder(stdClass::class)
+					 ->setMethods(['foo'])
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('foo')
-             ->withConsecutive(
-                 ['bar'],
-                 [21, 42]
-             );
+		$mock->expects($this->any())
+			 ->method('foo')
+			 ->withConsecutive(
+				 ['bar'],
+				 [21, 42]
+			 );
 
-        $this->assertNull($mock->foo('bar'));
-        $this->assertNull($mock->foo(21, 42));
-    }
+		$this->assertNull($mock->foo('bar'));
+		$this->assertNull($mock->foo(21, 42));
+	}
 
-    public function testIntegrationWithLessAssertionsThanMethodCalls()
-    {
-        $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+	public function testIntegrationWithLessAssertionsThanMethodCalls()
+	{
+		$mock = $this->getMockBuilder(stdClass::class)
+					 ->setMethods(['foo'])
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('foo')
-             ->withConsecutive(
-                 ['bar']
-             );
+		$mock->expects($this->any())
+			 ->method('foo')
+			 ->withConsecutive(
+				 ['bar']
+			 );
 
-        $this->assertNull($mock->foo('bar'));
-        $this->assertNull($mock->foo(21, 42));
-    }
+		$this->assertNull($mock->foo('bar'));
+		$this->assertNull($mock->foo(21, 42));
+	}
 
-    public function testIntegrationExpectingException()
-    {
-        $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+	public function testIntegrationExpectingException()
+	{
+		$mock = $this->getMockBuilder(stdClass::class)
+					 ->setMethods(['foo'])
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('foo')
-             ->withConsecutive(
-                 ['bar'],
-                 [21, 42]
-             );
+		$mock->expects($this->any())
+			 ->method('foo')
+			 ->withConsecutive(
+				 ['bar'],
+				 [21, 42]
+			 );
 
-        $mock->foo('bar');
+		$mock->foo('bar');
 
-        $this->expectException(ExpectationFailedException::class);
+		$this->expectException(ExpectationFailedException::class);
 
-        $mock->foo('invalid');
-    }
+		$mock->foo('invalid');
+	}
 }

vendor/phpunit/phpunit-mock-objects/tests/GeneratorTest.php

Indentation +183 added lines, -183 removed lines

@@ -25,187 +25,187 @@
  */
 class Framework_MockObject_GeneratorTest extends TestCase
 {
-    /**
-     * @var PHPUnit_Framework_MockObject_Generator
-     */
-    private $generator;
-
-    protected function setUp()
-    {
-        $this->generator = new PHPUnit_Framework_MockObject_Generator;
-    }
-
-    /**
-     * @expectedException PHPUnit_Framework_MockObject_RuntimeException
-     */
-    public function testGetMockFailsWhenInvalidFunctionNameIsPassedInAsAFunctionToMock()
-    {
-        $this->generator->getMock(stdClass::class, [0]);
-    }
-
-    public function testGetMockCanCreateNonExistingFunctions()
-    {
-        $mock = $this->generator->getMock(stdClass::class, ['testFunction']);
-
-        $this->assertTrue(method_exists($mock, 'testFunction'));
-    }
-
-    /**
-     * @expectedException PHPUnit_Framework_MockObject_RuntimeException
-     * @expectedExceptionMessage duplicates: "foo, bar, foo" (duplicate: "foo")
-     */
-    public function testGetMockGeneratorFails()
-    {
-        $this->generator->getMock(stdClass::class, ['foo', 'bar', 'foo']);
-    }
-
-    /**
-     * @requires PHP 7
-     */
-    public function testGetMockBlacklistedMethodNamesPhp7()
-    {
-        $mock = $this->generator->getMock(InterfaceWithSemiReservedMethodName::class);
-
-        $this->assertTrue(method_exists($mock, 'unset'));
-        $this->assertInstanceOf(InterfaceWithSemiReservedMethodName::class, $mock);
-    }
-
-    public function testGetMockForAbstractClassDoesNotFailWhenFakingInterfaces()
-    {
-        $mock = $this->generator->getMockForAbstractClass(Countable::class);
-
-        $this->assertTrue(method_exists($mock, 'count'));
-    }
-
-    public function testGetMockForAbstractClassStubbingAbstractClass()
-    {
-        $mock = $this->generator->getMockForAbstractClass(AbstractMockTestClass::class);
-
-        $this->assertTrue(method_exists($mock, 'doSomething'));
-    }
-
-    public function testGetMockForAbstractClassWithNonExistentMethods()
-    {
-        $mock = $this->generator->getMockForAbstractClass(
-            AbstractMockTestClass::class,
-            [],
-            '',
-            true,
-            true,
-            true,
-            ['nonexistentMethod']
-        );
-
-        $this->assertTrue(method_exists($mock, 'nonexistentMethod'));
-        $this->assertTrue(method_exists($mock, 'doSomething'));
-    }
-
-    public function testGetMockForAbstractClassShouldCreateStubsOnlyForAbstractMethodWhenNoMethodsWereInformed()
-    {
-        $mock = $this->generator->getMockForAbstractClass(AbstractMockTestClass::class);
-
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturn('testing');
-
-        $this->assertEquals('testing', $mock->doSomething());
-        $this->assertEquals(1, $mock->returnAnything());
-    }
-
-    /**
-     * @dataProvider getMockForAbstractClassExpectsInvalidArgumentExceptionDataprovider
-     * @expectedException PHPUnit\Framework\Exception
-     */
-    public function testGetMockForAbstractClassExpectingInvalidArgumentException($className, $mockClassName)
-    {
-        $this->generator->getMockForAbstractClass($className, [], $mockClassName);
-    }
-
-    /**
-     * @expectedException PHPUnit_Framework_MockObject_RuntimeException
-     */
-    public function testGetMockForAbstractClassAbstractClassDoesNotExist()
-    {
-        $this->generator->getMockForAbstractClass('Tux');
-    }
-
-    public function getMockForAbstractClassExpectsInvalidArgumentExceptionDataprovider()
-    {
-        return [
-            'className not a string'     => [[], ''],
-            'mockClassName not a string' => [Countable::class, new stdClass],
-        ];
-    }
-
-    public function testGetMockForTraitWithNonExistentMethodsAndNonAbstractMethods()
-    {
-        $mock = $this->generator->getMockForTrait(
-            AbstractTrait::class,
-            [],
-            '',
-            true,
-            true,
-            true,
-            ['nonexistentMethod']
-        );
-
-        $this->assertTrue(method_exists($mock, 'nonexistentMethod'));
-        $this->assertTrue(method_exists($mock, 'doSomething'));
-        $this->assertTrue($mock->mockableMethod());
-        $this->assertTrue($mock->anotherMockableMethod());
-    }
-
-    public function testGetMockForTraitStubbingAbstractMethod()
-    {
-        $mock = $this->generator->getMockForTrait(AbstractTrait::class);
-
-        $this->assertTrue(method_exists($mock, 'doSomething'));
-    }
-
-    public function testGetMockForSingletonWithReflectionSuccess()
-    {
-        $mock = $this->generator->getMock(SingletonClass::class, ['doSomething'], [], '', false);
-
-        $this->assertInstanceOf('SingletonClass', $mock);
-    }
-
-    /**
-     * @expectedException PHPUnit_Framework_MockObject_RuntimeException
-     */
-    public function testExceptionIsRaisedForMutuallyExclusiveOptions()
-    {
-        $this->generator->getMock(stdClass::class, [], [], '', false, true, true, true, true);
-    }
-
-    /**
-     * @requires PHP 7
-     */
-    public function testCanImplementInterfacesThatHaveMethodsWithReturnTypes()
-    {
-        $stub = $this->generator->getMock([AnInterfaceWithReturnType::class, AnInterface::class]);
-
-        $this->assertInstanceOf(AnInterfaceWithReturnType::class, $stub);
-        $this->assertInstanceOf(AnInterface::class, $stub);
-        $this->assertInstanceOf(PHPUnit_Framework_MockObject_MockObject::class, $stub);
-    }
-
-    public function testCanConfigureMethodsForDoubleOfNonExistentClass()
-    {
-        $className = 'X' . md5(microtime());
-
-        $mock = $this->generator->getMock($className, ['someMethod']);
-
-        $this->assertInstanceOf($className, $mock);
-    }
-
-    public function testCanInvokeMethodsOfNonExistentClass()
-    {
-        $className = 'X' . md5(microtime());
-
-        $mock = $this->generator->getMock($className, ['someMethod']);
-
-        $mock->expects($this->once())->method('someMethod');
-
-        $this->assertNull($mock->someMethod());
-    }
+	/**
+	 * @var PHPUnit_Framework_MockObject_Generator
+	 */
+	private $generator;
+
+	protected function setUp()
+	{
+		$this->generator = new PHPUnit_Framework_MockObject_Generator;
+	}
+
+	/**
+	 * @expectedException PHPUnit_Framework_MockObject_RuntimeException
+	 */
+	public function testGetMockFailsWhenInvalidFunctionNameIsPassedInAsAFunctionToMock()
+	{
+		$this->generator->getMock(stdClass::class, [0]);
+	}
+
+	public function testGetMockCanCreateNonExistingFunctions()
+	{
+		$mock = $this->generator->getMock(stdClass::class, ['testFunction']);
+
+		$this->assertTrue(method_exists($mock, 'testFunction'));
+	}
+
+	/**
+	 * @expectedException PHPUnit_Framework_MockObject_RuntimeException
+	 * @expectedExceptionMessage duplicates: "foo, bar, foo" (duplicate: "foo")
+	 */
+	public function testGetMockGeneratorFails()
+	{
+		$this->generator->getMock(stdClass::class, ['foo', 'bar', 'foo']);
+	}
+
+	/**
+	 * @requires PHP 7
+	 */
+	public function testGetMockBlacklistedMethodNamesPhp7()
+	{
+		$mock = $this->generator->getMock(InterfaceWithSemiReservedMethodName::class);
+
+		$this->assertTrue(method_exists($mock, 'unset'));
+		$this->assertInstanceOf(InterfaceWithSemiReservedMethodName::class, $mock);
+	}
+
+	public function testGetMockForAbstractClassDoesNotFailWhenFakingInterfaces()
+	{
+		$mock = $this->generator->getMockForAbstractClass(Countable::class);
+
+		$this->assertTrue(method_exists($mock, 'count'));
+	}
+
+	public function testGetMockForAbstractClassStubbingAbstractClass()
+	{
+		$mock = $this->generator->getMockForAbstractClass(AbstractMockTestClass::class);
+
+		$this->assertTrue(method_exists($mock, 'doSomething'));
+	}
+
+	public function testGetMockForAbstractClassWithNonExistentMethods()
+	{
+		$mock = $this->generator->getMockForAbstractClass(
+			AbstractMockTestClass::class,
+			[],
+			'',
+			true,
+			true,
+			true,
+			['nonexistentMethod']
+		);
+
+		$this->assertTrue(method_exists($mock, 'nonexistentMethod'));
+		$this->assertTrue(method_exists($mock, 'doSomething'));
+	}
+
+	public function testGetMockForAbstractClassShouldCreateStubsOnlyForAbstractMethodWhenNoMethodsWereInformed()
+	{
+		$mock = $this->generator->getMockForAbstractClass(AbstractMockTestClass::class);
+
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->willReturn('testing');
+
+		$this->assertEquals('testing', $mock->doSomething());
+		$this->assertEquals(1, $mock->returnAnything());
+	}
+
+	/**
+	 * @dataProvider getMockForAbstractClassExpectsInvalidArgumentExceptionDataprovider
+	 * @expectedException PHPUnit\Framework\Exception
+	 */
+	public function testGetMockForAbstractClassExpectingInvalidArgumentException($className, $mockClassName)
+	{
+		$this->generator->getMockForAbstractClass($className, [], $mockClassName);
+	}
+
+	/**
+	 * @expectedException PHPUnit_Framework_MockObject_RuntimeException
+	 */
+	public function testGetMockForAbstractClassAbstractClassDoesNotExist()
+	{
+		$this->generator->getMockForAbstractClass('Tux');
+	}
+
+	public function getMockForAbstractClassExpectsInvalidArgumentExceptionDataprovider()
+	{
+		return [
+			'className not a string'     => [[], ''],
+			'mockClassName not a string' => [Countable::class, new stdClass],
+		];
+	}
+
+	public function testGetMockForTraitWithNonExistentMethodsAndNonAbstractMethods()
+	{
+		$mock = $this->generator->getMockForTrait(
+			AbstractTrait::class,
+			[],
+			'',
+			true,
+			true,
+			true,
+			['nonexistentMethod']
+		);
+
+		$this->assertTrue(method_exists($mock, 'nonexistentMethod'));
+		$this->assertTrue(method_exists($mock, 'doSomething'));
+		$this->assertTrue($mock->mockableMethod());
+		$this->assertTrue($mock->anotherMockableMethod());
+	}
+
+	public function testGetMockForTraitStubbingAbstractMethod()
+	{
+		$mock = $this->generator->getMockForTrait(AbstractTrait::class);
+
+		$this->assertTrue(method_exists($mock, 'doSomething'));
+	}
+
+	public function testGetMockForSingletonWithReflectionSuccess()
+	{
+		$mock = $this->generator->getMock(SingletonClass::class, ['doSomething'], [], '', false);
+
+		$this->assertInstanceOf('SingletonClass', $mock);
+	}
+
+	/**
+	 * @expectedException PHPUnit_Framework_MockObject_RuntimeException
+	 */
+	public function testExceptionIsRaisedForMutuallyExclusiveOptions()
+	{
+		$this->generator->getMock(stdClass::class, [], [], '', false, true, true, true, true);
+	}
+
+	/**
+	 * @requires PHP 7
+	 */
+	public function testCanImplementInterfacesThatHaveMethodsWithReturnTypes()
+	{
+		$stub = $this->generator->getMock([AnInterfaceWithReturnType::class, AnInterface::class]);
+
+		$this->assertInstanceOf(AnInterfaceWithReturnType::class, $stub);
+		$this->assertInstanceOf(AnInterface::class, $stub);
+		$this->assertInstanceOf(PHPUnit_Framework_MockObject_MockObject::class, $stub);
+	}
+
+	public function testCanConfigureMethodsForDoubleOfNonExistentClass()
+	{
+		$className = 'X' . md5(microtime());
+
+		$mock = $this->generator->getMock($className, ['someMethod']);
+
+		$this->assertInstanceOf($className, $mock);
+	}
+
+	public function testCanInvokeMethodsOfNonExistentClass()
+	{
+		$className = 'X' . md5(microtime());
+
+		$mock = $this->generator->getMock($className, ['someMethod']);
+
+		$mock->expects($this->once())->method('someMethod');
+
+		$this->assertNull($mock->someMethod());
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -191,7 +191,7 @@ 
 
     public function testCanConfigureMethodsForDoubleOfNonExistentClass()
     {
-        $className = 'X' . md5(microtime());
+        $className = 'X'.md5(microtime());
 
         $mock = $this->generator->getMock($className, ['someMethod']);
 
@@ -200,7 +200,7 @@ 
 
     public function testCanInvokeMethodsOfNonExistentClass()
     {
-        $className = 'X' . md5(microtime());
+        $className = 'X'.md5(microtime());
 
         $mock = $this->generator->getMock($className, ['someMethod']);
 

vendor/phpunit/phpunit-mock-objects/tests/Builder/InvocationMockerTest.php

Indentation +48 added lines, -48 removed lines

@@ -12,63 +12,63 @@
 
 class Framework_MockObject_Builder_InvocationMockerTest extends TestCase
 {
-    public function testWillReturnWithOneValue()
-    {
-        $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+	public function testWillReturnWithOneValue()
+	{
+		$mock = $this->getMockBuilder(stdClass::class)
+					 ->setMethods(['foo'])
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('foo')
-             ->willReturn(1);
+		$mock->expects($this->any())
+			 ->method('foo')
+			 ->willReturn(1);
 
-        $this->assertEquals(1, $mock->foo());
-    }
+		$this->assertEquals(1, $mock->foo());
+	}
 
-    public function testWillReturnWithMultipleValues()
-    {
-        $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+	public function testWillReturnWithMultipleValues()
+	{
+		$mock = $this->getMockBuilder(stdClass::class)
+					 ->setMethods(['foo'])
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('foo')
-             ->willReturn(1, 2, 3);
+		$mock->expects($this->any())
+			 ->method('foo')
+			 ->willReturn(1, 2, 3);
 
-        $this->assertEquals(1, $mock->foo());
-        $this->assertEquals(2, $mock->foo());
-        $this->assertEquals(3, $mock->foo());
-    }
+		$this->assertEquals(1, $mock->foo());
+		$this->assertEquals(2, $mock->foo());
+		$this->assertEquals(3, $mock->foo());
+	}
 
-    public function testWillReturnOnConsecutiveCalls()
-    {
-        $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+	public function testWillReturnOnConsecutiveCalls()
+	{
+		$mock = $this->getMockBuilder(stdClass::class)
+					 ->setMethods(['foo'])
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('foo')
-             ->willReturnOnConsecutiveCalls(1, 2, 3);
+		$mock->expects($this->any())
+			 ->method('foo')
+			 ->willReturnOnConsecutiveCalls(1, 2, 3);
 
-        $this->assertEquals(1, $mock->foo());
-        $this->assertEquals(2, $mock->foo());
-        $this->assertEquals(3, $mock->foo());
-    }
+		$this->assertEquals(1, $mock->foo());
+		$this->assertEquals(2, $mock->foo());
+		$this->assertEquals(3, $mock->foo());
+	}
 
-    public function testWillReturnByReference()
-    {
-        $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
+	public function testWillReturnByReference()
+	{
+		$mock = $this->getMockBuilder(stdClass::class)
+					 ->setMethods(['foo'])
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('foo')
-             ->willReturnReference($value);
+		$mock->expects($this->any())
+			 ->method('foo')
+			 ->willReturnReference($value);
 
-        $this->assertSame(null, $mock->foo());
-        $value = 'foo';
-        $this->assertSame('foo', $mock->foo());
-        $value = 'bar';
-        $this->assertSame('bar', $mock->foo());
-    }
+		$this->assertSame(null, $mock->foo());
+		$value = 'foo';
+		$this->assertSame('foo', $mock->foo());
+		$value = 'bar';
+		$this->assertSame('bar', $mock->foo());
+	}
 }

vendor/phpunit/phpunit-mock-objects/tests/MockBuilderTest.php

Indentation +113 added lines, -113 removed lines

@@ -12,117 +12,117 @@
 
 class Framework_MockBuilderTest extends TestCase
 {
-    public function testMockBuilderRequiresClassName()
-    {
-        $mock = $this->getMockBuilder(Mockable::class)->getMock();
-
-        $this->assertTrue($mock instanceof Mockable);
-    }
-
-    public function testByDefaultMocksAllMethods()
-    {
-        $mock = $this->getMockBuilder(Mockable::class)->getMock();
-
-        $this->assertNull($mock->mockableMethod());
-        $this->assertNull($mock->anotherMockableMethod());
-    }
-
-    public function testMethodsToMockCanBeSpecified()
-    {
-        $mock = $this->getMockBuilder(Mockable::class)
-                     ->setMethods(['mockableMethod'])
-                     ->getMock();
-
-        $this->assertNull($mock->mockableMethod());
-        $this->assertTrue($mock->anotherMockableMethod());
-    }
-
-    public function testMethodExceptionsToMockCanBeSpecified()
-    {
-        $mock = $this->getMockBuilder(Mockable::class)
-            ->setMethodsExcept(['mockableMethod'])
-            ->getMock();
-
-        $this->assertTrue($mock->mockableMethod());
-        $this->assertNull($mock->anotherMockableMethod());
-    }
-
-    public function testEmptyMethodExceptionsToMockCanBeSpecified()
-    {
-        $mock = $this->getMockBuilder(Mockable::class)
-            ->setMethodsExcept()
-            ->getMock();
-
-        $this->assertNull($mock->mockableMethod());
-        $this->assertNull($mock->anotherMockableMethod());
-    }
-
-    public function testByDefaultDoesNotPassArgumentsToTheConstructor()
-    {
-        $mock = $this->getMockBuilder(Mockable::class)->getMock();
-
-        $this->assertEquals([null, null], $mock->constructorArgs);
-    }
-
-    public function testMockClassNameCanBeSpecified()
-    {
-        $mock = $this->getMockBuilder(Mockable::class)
-                     ->setMockClassName('ACustomClassName')
-                     ->getMock();
-
-        $this->assertTrue($mock instanceof ACustomClassName);
-    }
-
-    public function testConstructorArgumentsCanBeSpecified()
-    {
-        $mock = $this->getMockBuilder(Mockable::class)
-                     ->setConstructorArgs([23, 42])
-                     ->getMock();
-
-        $this->assertEquals([23, 42], $mock->constructorArgs);
-    }
-
-    public function testOriginalConstructorCanBeDisabled()
-    {
-        $mock = $this->getMockBuilder(Mockable::class)
-                     ->disableOriginalConstructor()
-                     ->getMock();
-
-        $this->assertNull($mock->constructorArgs);
-    }
-
-    public function testByDefaultOriginalCloneIsPreserved()
-    {
-        $mock = $this->getMockBuilder(Mockable::class)
-                     ->getMock();
-
-        $cloned = clone $mock;
-
-        $this->assertTrue($cloned->cloned);
-    }
-
-    public function testOriginalCloneCanBeDisabled()
-    {
-        $mock = $this->getMockBuilder(Mockable::class)
-                     ->disableOriginalClone()
-                     ->getMock();
-
-        $mock->cloned = false;
-        $cloned       = clone $mock;
-
-        $this->assertFalse($cloned->cloned);
-    }
-
-    public function testProvidesAFluentInterface()
-    {
-        $spec = $this->getMockBuilder(Mockable::class)
-                     ->setMethods(['mockableMethod'])
-                     ->setConstructorArgs([])
-                     ->setMockClassName('DummyClassName')
-                     ->disableOriginalConstructor()
-                     ->disableOriginalClone()
-                     ->disableAutoload();
-
-        $this->assertTrue($spec instanceof PHPUnit_Framework_MockObject_MockBuilder);
-    }
+	public function testMockBuilderRequiresClassName()
+	{
+		$mock = $this->getMockBuilder(Mockable::class)->getMock();
+
+		$this->assertTrue($mock instanceof Mockable);
+	}
+
+	public function testByDefaultMocksAllMethods()
+	{
+		$mock = $this->getMockBuilder(Mockable::class)->getMock();
+
+		$this->assertNull($mock->mockableMethod());
+		$this->assertNull($mock->anotherMockableMethod());
+	}
+
+	public function testMethodsToMockCanBeSpecified()
+	{
+		$mock = $this->getMockBuilder(Mockable::class)
+					 ->setMethods(['mockableMethod'])
+					 ->getMock();
+
+		$this->assertNull($mock->mockableMethod());
+		$this->assertTrue($mock->anotherMockableMethod());
+	}
+
+	public function testMethodExceptionsToMockCanBeSpecified()
+	{
+		$mock = $this->getMockBuilder(Mockable::class)
+			->setMethodsExcept(['mockableMethod'])
+			->getMock();
+
+		$this->assertTrue($mock->mockableMethod());
+		$this->assertNull($mock->anotherMockableMethod());
+	}
+
+	public function testEmptyMethodExceptionsToMockCanBeSpecified()
+	{
+		$mock = $this->getMockBuilder(Mockable::class)
+			->setMethodsExcept()
+			->getMock();
+
+		$this->assertNull($mock->mockableMethod());
+		$this->assertNull($mock->anotherMockableMethod());
+	}
+
+	public function testByDefaultDoesNotPassArgumentsToTheConstructor()
+	{
+		$mock = $this->getMockBuilder(Mockable::class)->getMock();
+
+		$this->assertEquals([null, null], $mock->constructorArgs);
+	}
+
+	public function testMockClassNameCanBeSpecified()
+	{
+		$mock = $this->getMockBuilder(Mockable::class)
+					 ->setMockClassName('ACustomClassName')
+					 ->getMock();
+
+		$this->assertTrue($mock instanceof ACustomClassName);
+	}
+
+	public function testConstructorArgumentsCanBeSpecified()
+	{
+		$mock = $this->getMockBuilder(Mockable::class)
+					 ->setConstructorArgs([23, 42])
+					 ->getMock();
+
+		$this->assertEquals([23, 42], $mock->constructorArgs);
+	}
+
+	public function testOriginalConstructorCanBeDisabled()
+	{
+		$mock = $this->getMockBuilder(Mockable::class)
+					 ->disableOriginalConstructor()
+					 ->getMock();
+
+		$this->assertNull($mock->constructorArgs);
+	}
+
+	public function testByDefaultOriginalCloneIsPreserved()
+	{
+		$mock = $this->getMockBuilder(Mockable::class)
+					 ->getMock();
+
+		$cloned = clone $mock;
+
+		$this->assertTrue($cloned->cloned);
+	}
+
+	public function testOriginalCloneCanBeDisabled()
+	{
+		$mock = $this->getMockBuilder(Mockable::class)
+					 ->disableOriginalClone()
+					 ->getMock();
+
+		$mock->cloned = false;
+		$cloned       = clone $mock;
+
+		$this->assertFalse($cloned->cloned);
+	}
+
+	public function testProvidesAFluentInterface()
+	{
+		$spec = $this->getMockBuilder(Mockable::class)
+					 ->setMethods(['mockableMethod'])
+					 ->setConstructorArgs([])
+					 ->setMockClassName('DummyClassName')
+					 ->disableOriginalConstructor()
+					 ->disableOriginalClone()
+					 ->disableAutoload();
+
+		$this->assertTrue($spec instanceof PHPUnit_Framework_MockObject_MockBuilder);
+	}
 }

vendor/phpunit/phpunit-mock-objects/src/Stub.php

Indentation +9 added lines, -9 removed lines

@@ -18,13 +18,13 @@
  */
 interface PHPUnit_Framework_MockObject_Stub extends SelfDescribing
 {
-    /**
-     * Fakes the processing of the invocation $invocation by returning a
-     * specific value.
-     *
-     * @param PHPUnit_Framework_MockObject_Invocation $invocation The invocation which was mocked and matched by the current method and argument matchers
-     *
-     * @return mixed
-     */
-    public function invoke(PHPUnit_Framework_MockObject_Invocation $invocation);
+	/**
+	 * Fakes the processing of the invocation $invocation by returning a
+	 * specific value.
+	 *
+	 * @param PHPUnit_Framework_MockObject_Invocation $invocation The invocation which was mocked and matched by the current method and argument matchers
+	 *
+	 * @return mixed
+	 */
+	public function invoke(PHPUnit_Framework_MockObject_Invocation $invocation);
 }

vendor/phpunit/phpunit-mock-objects/src/Invocation/Static.php

Indentation +190 added lines, -190 removed lines

@@ -16,194 +16,194 @@
  */
 class PHPUnit_Framework_MockObject_Invocation_Static implements PHPUnit_Framework_MockObject_Invocation, SelfDescribing
 {
-    /**
-     * @var array
-     */
-    protected static $uncloneableExtensions = [
-        'mysqli'    => true,
-        'SQLite'    => true,
-        'sqlite3'   => true,
-        'tidy'      => true,
-        'xmlwriter' => true,
-        'xsl'       => true
-    ];
-
-    /**
-     * @var array
-     */
-    protected static $uncloneableClasses = [
-        'Closure',
-        'COMPersistHelper',
-        'IteratorIterator',
-        'RecursiveIteratorIterator',
-        'SplFileObject',
-        'PDORow',
-        'ZipArchive'
-    ];
-
-    /**
-     * @var string
-     */
-    public $className;
-
-    /**
-     * @var string
-     */
-    public $methodName;
-
-    /**
-     * @var array
-     */
-    public $parameters;
-
-    /**
-     * @var string
-     */
-    public $returnType;
-
-    /**
-     * @var bool
-     */
-    public $returnTypeNullable = false;
-
-    /**
-     * @param string $className
-     * @param string $methodName
-     * @param array  $parameters
-     * @param string $returnType
-     * @param bool   $cloneObjects
-     */
-    public function __construct($className, $methodName, array $parameters, $returnType, $cloneObjects = false)
-    {
-        $this->className  = $className;
-        $this->methodName = $methodName;
-        $this->parameters = $parameters;
-
-        if (strpos($returnType, '?') === 0) {
-            $returnType               = substr($returnType, 1);
-            $this->returnTypeNullable = true;
-        }
-
-        $this->returnType = $returnType;
-
-        if (!$cloneObjects) {
-            return;
-        }
-
-        foreach ($this->parameters as $key => $value) {
-            if (is_object($value)) {
-                $this->parameters[$key] = $this->cloneObject($value);
-            }
-        }
-    }
-
-    /**
-     * @return string
-     */
-    public function toString()
-    {
-        $exporter = new Exporter;
-
-        return sprintf(
-            '%s::%s(%s)%s',
-            $this->className,
-            $this->methodName,
-            implode(
-                ', ',
-                array_map(
-                    [$exporter, 'shortenedExport'],
-                    $this->parameters
-                )
-            ),
-            $this->returnType ? sprintf(': %s', $this->returnType) : ''
-        );
-    }
-
-    /**
-     * @return mixed Mocked return value.
-     */
-    public function generateReturnValue()
-    {
-        switch ($this->returnType) {
-            case '':       return;
-            case 'string': return $this->returnTypeNullable ? null : '';
-            case 'float':  return $this->returnTypeNullable ? null : 0.0;
-            case 'int':    return $this->returnTypeNullable ? null : 0;
-            case 'bool':   return $this->returnTypeNullable ? null : false;
-            case 'array':  return $this->returnTypeNullable ? null : [];
-            case 'void':   return;
-
-            case 'callable':
-            case 'Closure':
-                return function () {
-                };
-
-            case 'Traversable':
-            case 'Generator':
-                $generator = function () {
-                    yield;
-                };
-
-                return $generator();
-
-            default:
-                if ($this->returnTypeNullable) {
-                    return;
-                }
-
-                $generator = new PHPUnit_Framework_MockObject_Generator;
-
-                return $generator->getMock($this->returnType, [], [], '', false);
-        }
-    }
-
-    /**
-     * @param object $original
-     *
-     * @return object
-     */
-    protected function cloneObject($original)
-    {
-        $cloneable = null;
-        $object    = new ReflectionObject($original);
-
-        // Check the blacklist before asking PHP reflection to work around
-        // https://bugs.php.net/bug.php?id=53967
-        if ($object->isInternal() &&
-            isset(self::$uncloneableExtensions[$object->getExtensionName()])) {
-            $cloneable = false;
-        }
-
-        if ($cloneable === null) {
-            foreach (self::$uncloneableClasses as $class) {
-                if ($original instanceof $class) {
-                    $cloneable = false;
-                    break;
-                }
-            }
-        }
-
-        if ($cloneable === null && method_exists($object, 'isCloneable')) {
-            $cloneable = $object->isCloneable();
-        }
-
-        if ($cloneable === null && $object->hasMethod('__clone')) {
-            $method    = $object->getMethod('__clone');
-            $cloneable = $method->isPublic();
-        }
-
-        if ($cloneable === null) {
-            $cloneable = true;
-        }
-
-        if ($cloneable) {
-            try {
-                return clone $original;
-            } catch (Exception $e) {
-                return $original;
-            }
-        } else {
-            return $original;
-        }
-    }
+	/**
+	 * @var array
+	 */
+	protected static $uncloneableExtensions = [
+		'mysqli'    => true,
+		'SQLite'    => true,
+		'sqlite3'   => true,
+		'tidy'      => true,
+		'xmlwriter' => true,
+		'xsl'       => true
+	];
+
+	/**
+	 * @var array
+	 */
+	protected static $uncloneableClasses = [
+		'Closure',
+		'COMPersistHelper',
+		'IteratorIterator',
+		'RecursiveIteratorIterator',
+		'SplFileObject',
+		'PDORow',
+		'ZipArchive'
+	];
+
+	/**
+	 * @var string
+	 */
+	public $className;
+
+	/**
+	 * @var string
+	 */
+	public $methodName;
+
+	/**
+	 * @var array
+	 */
+	public $parameters;
+
+	/**
+	 * @var string
+	 */
+	public $returnType;
+
+	/**
+	 * @var bool
+	 */
+	public $returnTypeNullable = false;
+
+	/**
+	 * @param string $className
+	 * @param string $methodName
+	 * @param array  $parameters
+	 * @param string $returnType
+	 * @param bool   $cloneObjects
+	 */
+	public function __construct($className, $methodName, array $parameters, $returnType, $cloneObjects = false)
+	{
+		$this->className  = $className;
+		$this->methodName = $methodName;
+		$this->parameters = $parameters;
+
+		if (strpos($returnType, '?') === 0) {
+			$returnType               = substr($returnType, 1);
+			$this->returnTypeNullable = true;
+		}
+
+		$this->returnType = $returnType;
+
+		if (!$cloneObjects) {
+			return;
+		}
+
+		foreach ($this->parameters as $key => $value) {
+			if (is_object($value)) {
+				$this->parameters[$key] = $this->cloneObject($value);
+			}
+		}
+	}
+
+	/**
+	 * @return string
+	 */
+	public function toString()
+	{
+		$exporter = new Exporter;
+
+		return sprintf(
+			'%s::%s(%s)%s',
+			$this->className,
+			$this->methodName,
+			implode(
+				', ',
+				array_map(
+					[$exporter, 'shortenedExport'],
+					$this->parameters
+				)
+			),
+			$this->returnType ? sprintf(': %s', $this->returnType) : ''
+		);
+	}
+
+	/**
+	 * @return mixed Mocked return value.
+	 */
+	public function generateReturnValue()
+	{
+		switch ($this->returnType) {
+			case '':       return;
+			case 'string': return $this->returnTypeNullable ? null : '';
+			case 'float':  return $this->returnTypeNullable ? null : 0.0;
+			case 'int':    return $this->returnTypeNullable ? null : 0;
+			case 'bool':   return $this->returnTypeNullable ? null : false;
+			case 'array':  return $this->returnTypeNullable ? null : [];
+			case 'void':   return;
+
+			case 'callable':
+			case 'Closure':
+				return function () {
+				};
+
+			case 'Traversable':
+			case 'Generator':
+				$generator = function () {
+					yield;
+				};
+
+				return $generator();
+
+			default:
+				if ($this->returnTypeNullable) {
+					return;
+				}
+
+				$generator = new PHPUnit_Framework_MockObject_Generator;
+
+				return $generator->getMock($this->returnType, [], [], '', false);
+		}
+	}
+
+	/**
+	 * @param object $original
+	 *
+	 * @return object
+	 */
+	protected function cloneObject($original)
+	{
+		$cloneable = null;
+		$object    = new ReflectionObject($original);
+
+		// Check the blacklist before asking PHP reflection to work around
+		// https://bugs.php.net/bug.php?id=53967
+		if ($object->isInternal() &&
+			isset(self::$uncloneableExtensions[$object->getExtensionName()])) {
+			$cloneable = false;
+		}
+
+		if ($cloneable === null) {
+			foreach (self::$uncloneableClasses as $class) {
+				if ($original instanceof $class) {
+					$cloneable = false;
+					break;
+				}
+			}
+		}
+
+		if ($cloneable === null && method_exists($object, 'isCloneable')) {
+			$cloneable = $object->isCloneable();
+		}
+
+		if ($cloneable === null && $object->hasMethod('__clone')) {
+			$method    = $object->getMethod('__clone');
+			$cloneable = $method->isPublic();
+		}
+
+		if ($cloneable === null) {
+			$cloneable = true;
+		}
+
+		if ($cloneable) {
+			try {
+				return clone $original;
+			} catch (Exception $e) {
+				return $original;
+			}
+		} else {
+			return $original;
+		}
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -135,12 +135,12 @@
 
             case 'callable':
             case 'Closure':
-                return function () {
+                return function() {
                 };
 
             case 'Traversable':
             case 'Generator':
-                $generator = function () {
+                $generator = function() {
                     yield;
                 };
 

vendor/phpunit/phpunit-mock-objects/src/Invocation/Object.php

Indentation +17 added lines, -17 removed lines

@@ -13,23 +13,23 @@
  */
 class PHPUnit_Framework_MockObject_Invocation_Object extends PHPUnit_Framework_MockObject_Invocation_Static
 {
-    /**
-     * @var object
-     */
-    public $object;
+	/**
+	 * @var object
+	 */
+	public $object;
 
-    /**
-     * @param string $className
-     * @param string $methodName
-     * @param array  $parameters
-     * @param string $returnType
-     * @param object $object
-     * @param bool   $cloneObjects
-     */
-    public function __construct($className, $methodName, array $parameters, $returnType, $object, $cloneObjects = false)
-    {
-        parent::__construct($className, $methodName, $parameters, $returnType, $cloneObjects);
+	/**
+	 * @param string $className
+	 * @param string $methodName
+	 * @param array  $parameters
+	 * @param string $returnType
+	 * @param object $object
+	 * @param bool   $cloneObjects
+	 */
+	public function __construct($className, $methodName, array $parameters, $returnType, $object, $cloneObjects = false)
+	{
+		parent::__construct($className, $methodName, $parameters, $returnType, $cloneObjects);
 
-        $this->object = $object;
-    }
+		$this->object = $object;
+	}
 }

vendor/phpunit/phpunit-mock-objects/src/Stub/ReturnArgument.php

Indentation +17 added lines, -17 removed lines

@@ -13,24 +13,24 @@
  */
 class PHPUnit_Framework_MockObject_Stub_ReturnArgument extends PHPUnit_Framework_MockObject_Stub_Return
 {
-    protected $argumentIndex;
+	protected $argumentIndex;
 
-    public function __construct($argumentIndex)
-    {
-        $this->argumentIndex = $argumentIndex;
-    }
+	public function __construct($argumentIndex)
+	{
+		$this->argumentIndex = $argumentIndex;
+	}
 
-    public function invoke(PHPUnit_Framework_MockObject_Invocation $invocation)
-    {
-        if (isset($invocation->parameters[$this->argumentIndex])) {
-            return $invocation->parameters[$this->argumentIndex];
-        } else {
-            return;
-        }
-    }
+	public function invoke(PHPUnit_Framework_MockObject_Invocation $invocation)
+	{
+		if (isset($invocation->parameters[$this->argumentIndex])) {
+			return $invocation->parameters[$this->argumentIndex];
+		} else {
+			return;
+		}
+	}
 
-    public function toString()
-    {
-        return sprintf('return argument #%d', $this->argumentIndex);
-    }
+	public function toString()
+	{
+		return sprintf('return argument #%d', $this->argumentIndex);
+	}
 }