chillerlan / php-traits

vendor/phpunit/phpunit-mock-objects/tests/_fixture/MockTestInterface.php

Indentation +2 added lines, -2 removed lines

@@ -1,6 +1,6 @@
 <?php
 interface MockTestInterface
 {
-    public function returnAnything();
-    public function returnAnythingElse();
+	public function returnAnything();
+	public function returnAnythingElse();
 }

vendor/phpunit/phpunit-mock-objects/tests/_fixture/AbstractMockTestClass.php

Indentation +5 added lines, -5 removed lines

@@ -1,10 +1,10 @@
 <?php
 abstract class AbstractMockTestClass implements MockTestInterface
 {
-    abstract public function doSomething();
+	abstract public function doSomething();
 
-    public function returnAnything()
-    {
-        return 1;
-    }
+	public function returnAnything()
+	{
+		return 1;
+	}
 }

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

Indentation +104 added lines, -104 removed lines

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

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());
+	}
 }

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);
 }