chillerlan / php-traits

vendor/phpunit/phpunit/src/Runner/TestSuiteLoader.php

Indentation +13 added lines, -13 removed lines

@@ -17,18 +17,18 @@
  */
 interface TestSuiteLoader
 {
-    /**
-     * @param string $suiteClassName
-     * @param string $suiteClassFile
-     *
-     * @return ReflectionClass
-     */
-    public function load($suiteClassName, $suiteClassFile = '');
+	/**
+	 * @param string $suiteClassName
+	 * @param string $suiteClassFile
+	 *
+	 * @return ReflectionClass
+	 */
+	public function load($suiteClassName, $suiteClassFile = '');
 
-    /**
-     * @param ReflectionClass $aClass
-     *
-     * @return ReflectionClass
-     */
-    public function reload(ReflectionClass $aClass);
+	/**
+	 * @param ReflectionClass $aClass
+	 *
+	 * @return ReflectionClass
+	 */
+	public function reload(ReflectionClass $aClass);
 }

vendor/phpunit/phpunit/src/Runner/StandardTestSuiteLoader.php

Indentation +98 added lines, -98 removed lines

@@ -19,102 +19,102 @@
  */
 class StandardTestSuiteLoader implements TestSuiteLoader
 {
-    /**
-     * @param string $suiteClassName
-     * @param string $suiteClassFile
-     *
-     * @return ReflectionClass
-     *
-     * @throws Exception
-     */
-    public function load($suiteClassName, $suiteClassFile = '')
-    {
-        $suiteClassName = \str_replace('.php', '', $suiteClassName);
-
-        if (empty($suiteClassFile)) {
-            $suiteClassFile = Filesystem::classNameToFilename(
-                $suiteClassName
-            );
-        }
-
-        if (!\class_exists($suiteClassName, false)) {
-            $loadedClasses = \get_declared_classes();
-
-            $filename = Fileloader::checkAndLoad($suiteClassFile);
-
-            $loadedClasses = \array_values(
-                \array_diff(\get_declared_classes(), $loadedClasses)
-            );
-        }
-
-        if (!\class_exists($suiteClassName, false) && !empty($loadedClasses)) {
-            $offset = 0 - \strlen($suiteClassName);
-
-            foreach ($loadedClasses as $loadedClass) {
-                $class = new ReflectionClass($loadedClass);
-                if (\substr($loadedClass, $offset) === $suiteClassName &&
-                    $class->getFileName() == $filename) {
-                    $suiteClassName = $loadedClass;
-
-                    break;
-                }
-            }
-        }
-
-        if (!\class_exists($suiteClassName, false) && !empty($loadedClasses)) {
-            $testCaseClass = TestCase::class;
-
-            foreach ($loadedClasses as $loadedClass) {
-                $class     = new ReflectionClass($loadedClass);
-                $classFile = $class->getFileName();
-
-                if ($class->isSubclassOf($testCaseClass) && !$class->isAbstract()) {
-                    $suiteClassName = $loadedClass;
-                    $testCaseClass  = $loadedClass;
-
-                    if ($classFile == \realpath($suiteClassFile)) {
-                        break;
-                    }
-                }
-
-                if ($class->hasMethod('suite')) {
-                    $method = $class->getMethod('suite');
-
-                    if (!$method->isAbstract() && $method->isPublic() && $method->isStatic()) {
-                        $suiteClassName = $loadedClass;
-
-                        if ($classFile == \realpath($suiteClassFile)) {
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
-        if (\class_exists($suiteClassName, false)) {
-            $class = new ReflectionClass($suiteClassName);
-
-            if ($class->getFileName() == \realpath($suiteClassFile)) {
-                return $class;
-            }
-        }
-
-        throw new Exception(
-            \sprintf(
-                "Class '%s' could not be found in '%s'.",
-                $suiteClassName,
-                $suiteClassFile
-            )
-        );
-    }
-
-    /**
-     * @param ReflectionClass $aClass
-     *
-     * @return ReflectionClass
-     */
-    public function reload(ReflectionClass $aClass)
-    {
-        return $aClass;
-    }
+	/**
+	 * @param string $suiteClassName
+	 * @param string $suiteClassFile
+	 *
+	 * @return ReflectionClass
+	 *
+	 * @throws Exception
+	 */
+	public function load($suiteClassName, $suiteClassFile = '')
+	{
+		$suiteClassName = \str_replace('.php', '', $suiteClassName);
+
+		if (empty($suiteClassFile)) {
+			$suiteClassFile = Filesystem::classNameToFilename(
+				$suiteClassName
+			);
+		}
+
+		if (!\class_exists($suiteClassName, false)) {
+			$loadedClasses = \get_declared_classes();
+
+			$filename = Fileloader::checkAndLoad($suiteClassFile);
+
+			$loadedClasses = \array_values(
+				\array_diff(\get_declared_classes(), $loadedClasses)
+			);
+		}
+
+		if (!\class_exists($suiteClassName, false) && !empty($loadedClasses)) {
+			$offset = 0 - \strlen($suiteClassName);
+
+			foreach ($loadedClasses as $loadedClass) {
+				$class = new ReflectionClass($loadedClass);
+				if (\substr($loadedClass, $offset) === $suiteClassName &&
+					$class->getFileName() == $filename) {
+					$suiteClassName = $loadedClass;
+
+					break;
+				}
+			}
+		}
+
+		if (!\class_exists($suiteClassName, false) && !empty($loadedClasses)) {
+			$testCaseClass = TestCase::class;
+
+			foreach ($loadedClasses as $loadedClass) {
+				$class     = new ReflectionClass($loadedClass);
+				$classFile = $class->getFileName();
+
+				if ($class->isSubclassOf($testCaseClass) && !$class->isAbstract()) {
+					$suiteClassName = $loadedClass;
+					$testCaseClass  = $loadedClass;
+
+					if ($classFile == \realpath($suiteClassFile)) {
+						break;
+					}
+				}
+
+				if ($class->hasMethod('suite')) {
+					$method = $class->getMethod('suite');
+
+					if (!$method->isAbstract() && $method->isPublic() && $method->isStatic()) {
+						$suiteClassName = $loadedClass;
+
+						if ($classFile == \realpath($suiteClassFile)) {
+							break;
+						}
+					}
+				}
+			}
+		}
+
+		if (\class_exists($suiteClassName, false)) {
+			$class = new ReflectionClass($suiteClassName);
+
+			if ($class->getFileName() == \realpath($suiteClassFile)) {
+				return $class;
+			}
+		}
+
+		throw new Exception(
+			\sprintf(
+				"Class '%s' could not be found in '%s'.",
+				$suiteClassName,
+				$suiteClassFile
+			)
+		);
+	}
+
+	/**
+	 * @param ReflectionClass $aClass
+	 *
+	 * @return ReflectionClass
+	 */
+	public function reload(ReflectionClass $aClass)
+	{
+		return $aClass;
+	}
 }

vendor/phpunit/php-timer/tests/TimerTest.php

Indentation +78 added lines, -78 removed lines

@@ -12,87 +12,87 @@
 
 class PHP_TimerTest extends TestCase
 {
-    /**
-     * @covers PHP_Timer::start
-     * @covers PHP_Timer::stop
-     */
-    public function testStartStop()
-    {
-        $this->assertInternalType('float', PHP_Timer::stop());
-    }
+	/**
+	 * @covers PHP_Timer::start
+	 * @covers PHP_Timer::stop
+	 */
+	public function testStartStop()
+	{
+		$this->assertInternalType('float', PHP_Timer::stop());
+	}
 
-    /**
-     * @covers       PHP_Timer::secondsToTimeString
-     * @dataProvider secondsProvider
-     */
-    public function testSecondsToTimeString($string, $seconds)
-    {
-        $this->assertEquals(
-            $string,
-            PHP_Timer::secondsToTimeString($seconds)
-        );
-    }
+	/**
+	 * @covers       PHP_Timer::secondsToTimeString
+	 * @dataProvider secondsProvider
+	 */
+	public function testSecondsToTimeString($string, $seconds)
+	{
+		$this->assertEquals(
+			$string,
+			PHP_Timer::secondsToTimeString($seconds)
+		);
+	}
 
-    /**
-     * @covers PHP_Timer::timeSinceStartOfRequest
-     */
-    public function testTimeSinceStartOfRequest()
-    {
-        $this->assertStringMatchesFormat(
-            '%f %s',
-            PHP_Timer::timeSinceStartOfRequest()
-        );
-    }
+	/**
+	 * @covers PHP_Timer::timeSinceStartOfRequest
+	 */
+	public function testTimeSinceStartOfRequest()
+	{
+		$this->assertStringMatchesFormat(
+			'%f %s',
+			PHP_Timer::timeSinceStartOfRequest()
+		);
+	}
 
 
-    /**
-     * @covers PHP_Timer::resourceUsage
-     */
-    public function testResourceUsage()
-    {
-        $this->assertStringMatchesFormat(
-            'Time: %s, Memory: %fMB',
-            PHP_Timer::resourceUsage()
-        );
-    }
+	/**
+	 * @covers PHP_Timer::resourceUsage
+	 */
+	public function testResourceUsage()
+	{
+		$this->assertStringMatchesFormat(
+			'Time: %s, Memory: %fMB',
+			PHP_Timer::resourceUsage()
+		);
+	}
 
-    public function secondsProvider()
-    {
-        return array(
-          array('0 ms', 0),
-          array('1 ms', .001),
-          array('10 ms', .01),
-          array('100 ms', .1),
-          array('999 ms', .999),
-          array('1 second', .9999),
-          array('1 second', 1),
-          array('2 seconds', 2),
-          array('59.9 seconds', 59.9),
-          array('59.99 seconds', 59.99),
-          array('59.99 seconds', 59.999),
-          array('1 minute', 59.9999),
-          array('59 seconds', 59.001),
-          array('59.01 seconds', 59.01),
-          array('1 minute', 60),
-          array('1.01 minutes', 61),
-          array('2 minutes', 120),
-          array('2.01 minutes', 121),
-          array('59.99 minutes', 3599.9),
-          array('59.99 minutes', 3599.99),
-          array('59.99 minutes', 3599.999),
-          array('1 hour', 3599.9999),
-          array('59.98 minutes', 3599.001),
-          array('59.98 minutes', 3599.01),
-          array('1 hour', 3600),
-          array('1 hour', 3601),
-          array('1 hour', 3601.9),
-          array('1 hour', 3601.99),
-          array('1 hour', 3601.999),
-          array('1 hour', 3601.9999),
-          array('1.01 hours', 3659.9999),
-          array('1.01 hours', 3659.001),
-          array('1.01 hours', 3659.01),
-          array('2 hours', 7199.9999),
-        );
-    }
+	public function secondsProvider()
+	{
+		return array(
+		  array('0 ms', 0),
+		  array('1 ms', .001),
+		  array('10 ms', .01),
+		  array('100 ms', .1),
+		  array('999 ms', .999),
+		  array('1 second', .9999),
+		  array('1 second', 1),
+		  array('2 seconds', 2),
+		  array('59.9 seconds', 59.9),
+		  array('59.99 seconds', 59.99),
+		  array('59.99 seconds', 59.999),
+		  array('1 minute', 59.9999),
+		  array('59 seconds', 59.001),
+		  array('59.01 seconds', 59.01),
+		  array('1 minute', 60),
+		  array('1.01 minutes', 61),
+		  array('2 minutes', 120),
+		  array('2.01 minutes', 121),
+		  array('59.99 minutes', 3599.9),
+		  array('59.99 minutes', 3599.99),
+		  array('59.99 minutes', 3599.999),
+		  array('1 hour', 3599.9999),
+		  array('59.98 minutes', 3599.001),
+		  array('59.98 minutes', 3599.01),
+		  array('1 hour', 3600),
+		  array('1 hour', 3601),
+		  array('1 hour', 3601.9),
+		  array('1 hour', 3601.99),
+		  array('1 hour', 3601.999),
+		  array('1 hour', 3601.9999),
+		  array('1.01 hours', 3659.9999),
+		  array('1.01 hours', 3659.001),
+		  array('1.01 hours', 3659.01),
+		  array('2 hours', 7199.9999),
+		);
+	}
 }

vendor/phpunit/php-timer/src/Timer.php

Indentation +74 added lines, -74 removed lines

@@ -13,93 +13,93 @@
  */
 class PHP_Timer
 {
-    /**
-     * @var array
-     */
-    private static $times = array(
-      'hour'   => 3600000,
-      'minute' => 60000,
-      'second' => 1000
-    );
+	/**
+	 * @var array
+	 */
+	private static $times = array(
+	  'hour'   => 3600000,
+	  'minute' => 60000,
+	  'second' => 1000
+	);
 
-    /**
-     * @var array
-     */
-    private static $startTimes = array();
+	/**
+	 * @var array
+	 */
+	private static $startTimes = array();
 
-    /**
-     * @var float
-     */
-    public static $requestTime;
+	/**
+	 * @var float
+	 */
+	public static $requestTime;
 
-    /**
-     * Starts the timer.
-     */
-    public static function start()
-    {
-        array_push(self::$startTimes, microtime(true));
-    }
+	/**
+	 * Starts the timer.
+	 */
+	public static function start()
+	{
+		array_push(self::$startTimes, microtime(true));
+	}
 
-    /**
-     * Stops the timer and returns the elapsed time.
-     *
-     * @return float
-     */
-    public static function stop()
-    {
-        return microtime(true) - array_pop(self::$startTimes);
-    }
+	/**
+	 * Stops the timer and returns the elapsed time.
+	 *
+	 * @return float
+	 */
+	public static function stop()
+	{
+		return microtime(true) - array_pop(self::$startTimes);
+	}
 
-    /**
-     * Formats the elapsed time as a string.
-     *
-     * @param  float  $time
-     * @return string
-     */
-    public static function secondsToTimeString($time)
-    {
-        $ms = round($time * 1000);
+	/**
+	 * Formats the elapsed time as a string.
+	 *
+	 * @param  float  $time
+	 * @return string
+	 */
+	public static function secondsToTimeString($time)
+	{
+		$ms = round($time * 1000);
 
-        foreach (self::$times as $unit => $value) {
-            if ($ms >= $value) {
-                $time = floor($ms / $value * 100.0) / 100.0;
+		foreach (self::$times as $unit => $value) {
+			if ($ms >= $value) {
+				$time = floor($ms / $value * 100.0) / 100.0;
 
-                return $time . ' ' . ($time == 1 ? $unit : $unit . 's');
-            }
-        }
+				return $time . ' ' . ($time == 1 ? $unit : $unit . 's');
+			}
+		}
 
-        return $ms . ' ms';
-    }
+		return $ms . ' ms';
+	}
 
-    /**
-     * Formats the elapsed time since the start of the request as a string.
-     *
-     * @return string
-     */
-    public static function timeSinceStartOfRequest()
-    {
-        return self::secondsToTimeString(microtime(true) - self::$requestTime);
-    }
+	/**
+	 * Formats the elapsed time since the start of the request as a string.
+	 *
+	 * @return string
+	 */
+	public static function timeSinceStartOfRequest()
+	{
+		return self::secondsToTimeString(microtime(true) - self::$requestTime);
+	}
 
-    /**
-     * Returns the resources (time, memory) of the request as a string.
-     *
-     * @return string
-     */
-    public static function resourceUsage()
-    {
-        return sprintf(
-            'Time: %s, Memory: %4.2fMB',
-            self::timeSinceStartOfRequest(),
-            memory_get_peak_usage(true) / 1048576
-        );
-    }
+	/**
+	 * Returns the resources (time, memory) of the request as a string.
+	 *
+	 * @return string
+	 */
+	public static function resourceUsage()
+	{
+		return sprintf(
+			'Time: %s, Memory: %4.2fMB',
+			self::timeSinceStartOfRequest(),
+			memory_get_peak_usage(true) / 1048576
+		);
+	}
 }
 
 if (isset($_SERVER['REQUEST_TIME_FLOAT'])) {
-    PHP_Timer::$requestTime = $_SERVER['REQUEST_TIME_FLOAT'];
+	PHP_Timer::$requestTime = $_SERVER['REQUEST_TIME_FLOAT'];
 } elseif (isset($_SERVER['REQUEST_TIME'])) {
-    PHP_Timer::$requestTime = $_SERVER['REQUEST_TIME'];
+	PHP_Timer::$requestTime = $_SERVER['REQUEST_TIME'];
 } else {
-    PHP_Timer::$requestTime = microtime(true);
+	PHP_Timer::$requestTime = microtime(true);
 }

Spacing +2 added lines, -2 removed lines

@@ -64,11 +64,11 @@
             if ($ms >= $value) {
                 $time = floor($ms / $value * 100.0) / 100.0;
 
-                return $time . ' ' . ($time == 1 ? $unit : $unit . 's');
+                return $time.' '.($time == 1 ? $unit : $unit.'s');
             }
         }
 
-        return $ms . ' ms';
+        return $ms.' ms';
     }
 
     /**

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

Indentation +19 added lines, -19 removed lines

@@ -12,30 +12,30 @@
 
 class Framework_ProxyObjectTest extends TestCase
 {
-    public function testMockedMethodIsProxiedToOriginalMethod()
-    {
-        $proxy = $this->getMockBuilder(Bar::class)
-                      ->enableProxyingToOriginalMethods()
-                      ->getMock();
+	public function testMockedMethodIsProxiedToOriginalMethod()
+	{
+		$proxy = $this->getMockBuilder(Bar::class)
+					  ->enableProxyingToOriginalMethods()
+					  ->getMock();
 
-        $proxy->expects($this->once())
-              ->method('doSomethingElse');
+		$proxy->expects($this->once())
+			  ->method('doSomethingElse');
 
-        $foo = new Foo;
+		$foo = new Foo;
 
-        $this->assertEquals('result', $foo->doSomething($proxy));
-    }
+		$this->assertEquals('result', $foo->doSomething($proxy));
+	}
 
-    public function testMockedMethodWithReferenceIsProxiedToOriginalMethod()
-    {
-        $proxy = $this->getMockBuilder(MethodCallbackByReference::class)
-                      ->enableProxyingToOriginalMethods()
-                      ->getMock();
+	public function testMockedMethodWithReferenceIsProxiedToOriginalMethod()
+	{
+		$proxy = $this->getMockBuilder(MethodCallbackByReference::class)
+					  ->enableProxyingToOriginalMethods()
+					  ->getMock();
 
-        $a = $b = $c = 0;
+		$a = $b = $c = 0;
 
-        $proxy->callback($a, $b, $c);
+		$proxy->callback($a, $b, $c);
 
-        $this->assertEquals(1, $b);
-    }
+		$this->assertEquals(1, $b);
+	}
 }

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

Indentation +972 added lines, -972 removed lines

@@ -13,1025 +13,1025 @@
 
 class Framework_MockObjectTest extends TestCase
 {
-    public function testMockedMethodIsNeverCalled()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
-
-        $mock->expects($this->never())
-             ->method('doSomething');
-    }
-
-    public function testMockedMethodIsNeverCalledWithParameter()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->getMock();
-
-        $mock->expects($this->never())
-             ->method('doSomething')
-             ->with('someArg');
-    }
-
-    /**
-     * @doesNotPerformAssertions
-     */
-    public function testMockedMethodIsNotCalledWhenExpectsAnyWithParameter()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->getMock();
-
-        $mock->expects($this->any())
-             ->method('doSomethingElse')
-             ->with('someArg');
-    }
-
-    /**
-     * @doesNotPerformAssertions
-     */
-    public function testMockedMethodIsNotCalledWhenMethodSpecifiedDirectlyWithParameter()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->getMock();
-
-        $mock->method('doSomethingElse')
-             ->with('someArg');
-    }
-
-    public function testMockedMethodIsCalledAtLeastOnce()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
-
-        $mock->expects($this->atLeastOnce())
-             ->method('doSomething');
-
-        $mock->doSomething();
-    }
-
-    public function testMockedMethodIsCalledAtLeastOnce2()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
-
-        $mock->expects($this->atLeastOnce())
-             ->method('doSomething');
-
-        $mock->doSomething();
-        $mock->doSomething();
-    }
-
-    public function testMockedMethodIsCalledAtLeastTwice()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
-
-        $mock->expects($this->atLeast(2))
-             ->method('doSomething');
-
-        $mock->doSomething();
-        $mock->doSomething();
-    }
-
-    public function testMockedMethodIsCalledAtLeastTwice2()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
-
-        $mock->expects($this->atLeast(2))
-             ->method('doSomething');
-
-        $mock->doSomething();
-        $mock->doSomething();
-        $mock->doSomething();
-    }
-
-    public function testMockedMethodIsCalledAtMostTwice()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
-
-        $mock->expects($this->atMost(2))
-             ->method('doSomething');
-
-        $mock->doSomething();
-        $mock->doSomething();
-    }
-
-    public function testMockedMethodIsCalledAtMosttTwice2()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+	public function testMockedMethodIsNeverCalled()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
+
+		$mock->expects($this->never())
+			 ->method('doSomething');
+	}
+
+	public function testMockedMethodIsNeverCalledWithParameter()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->getMock();
+
+		$mock->expects($this->never())
+			 ->method('doSomething')
+			 ->with('someArg');
+	}
+
+	/**
+	 * @doesNotPerformAssertions
+	 */
+	public function testMockedMethodIsNotCalledWhenExpectsAnyWithParameter()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->getMock();
+
+		$mock->expects($this->any())
+			 ->method('doSomethingElse')
+			 ->with('someArg');
+	}
+
+	/**
+	 * @doesNotPerformAssertions
+	 */
+	public function testMockedMethodIsNotCalledWhenMethodSpecifiedDirectlyWithParameter()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->getMock();
+
+		$mock->method('doSomethingElse')
+			 ->with('someArg');
+	}
+
+	public function testMockedMethodIsCalledAtLeastOnce()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
+
+		$mock->expects($this->atLeastOnce())
+			 ->method('doSomething');
+
+		$mock->doSomething();
+	}
+
+	public function testMockedMethodIsCalledAtLeastOnce2()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
+
+		$mock->expects($this->atLeastOnce())
+			 ->method('doSomething');
+
+		$mock->doSomething();
+		$mock->doSomething();
+	}
+
+	public function testMockedMethodIsCalledAtLeastTwice()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
+
+		$mock->expects($this->atLeast(2))
+			 ->method('doSomething');
+
+		$mock->doSomething();
+		$mock->doSomething();
+	}
+
+	public function testMockedMethodIsCalledAtLeastTwice2()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
+
+		$mock->expects($this->atLeast(2))
+			 ->method('doSomething');
+
+		$mock->doSomething();
+		$mock->doSomething();
+		$mock->doSomething();
+	}
+
+	public function testMockedMethodIsCalledAtMostTwice()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
+
+		$mock->expects($this->atMost(2))
+			 ->method('doSomething');
+
+		$mock->doSomething();
+		$mock->doSomething();
+	}
+
+	public function testMockedMethodIsCalledAtMosttTwice2()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->atMost(2))
-             ->method('doSomething');
-
-        $mock->doSomething();
-    }
-
-    public function testMockedMethodIsCalledOnce()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+		$mock->expects($this->atMost(2))
+			 ->method('doSomething');
+
+		$mock->doSomething();
+	}
+
+	public function testMockedMethodIsCalledOnce()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->once())
-             ->method('doSomething');
+		$mock->expects($this->once())
+			 ->method('doSomething');
 
-        $mock->doSomething();
-    }
+		$mock->doSomething();
+	}
 
-    public function testMockedMethodIsCalledOnceWithParameter()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->getMock();
+	public function testMockedMethodIsCalledOnceWithParameter()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->getMock();
 
-        $mock->expects($this->once())
-             ->method('doSomethingElse')
-             ->with($this->equalTo('something'));
+		$mock->expects($this->once())
+			 ->method('doSomethingElse')
+			 ->with($this->equalTo('something'));
 
-        $mock->doSomethingElse('something');
-    }
+		$mock->doSomethingElse('something');
+	}
 
-    public function testMockedMethodIsCalledExactly()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+	public function testMockedMethodIsCalledExactly()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->exactly(2))
-             ->method('doSomething');
+		$mock->expects($this->exactly(2))
+			 ->method('doSomething');
 
-        $mock->doSomething();
-        $mock->doSomething();
-    }
+		$mock->doSomething();
+		$mock->doSomething();
+	}
 
-    public function testStubbedException()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+	public function testStubbedException()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->will($this->throwException(new Exception));
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->will($this->throwException(new Exception));
 
-        $this->expectException(Exception::class);
+		$this->expectException(Exception::class);
 
-        $mock->doSomething();
-    }
+		$mock->doSomething();
+	}
 
-    public function testStubbedWillThrowException()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+	public function testStubbedWillThrowException()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->willThrowException(new Exception);
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->willThrowException(new Exception);
 
-        $this->expectException(Exception::class);
+		$this->expectException(Exception::class);
 
-        $mock->doSomething();
-    }
+		$mock->doSomething();
+	}
 
-    public function testStubbedReturnValue()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+	public function testStubbedReturnValue()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->will($this->returnValue('something'));
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->will($this->returnValue('something'));
 
-        $this->assertEquals('something', $mock->doSomething());
+		$this->assertEquals('something', $mock->doSomething());
 
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturn('something');
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->willReturn('something');
 
-        $this->assertEquals('something', $mock->doSomething());
-    }
+		$this->assertEquals('something', $mock->doSomething());
+	}
 
-    public function testStubbedReturnValueMap()
-    {
-        $map = [
-            ['a', 'b', 'c', 'd'],
-            ['e', 'f', 'g', 'h']
-        ];
+	public function testStubbedReturnValueMap()
+	{
+		$map = [
+			['a', 'b', 'c', 'd'],
+			['e', 'f', 'g', 'h']
+		];
 
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->will($this->returnValueMap($map));
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->will($this->returnValueMap($map));
 
-        $this->assertEquals('d', $mock->doSomething('a', 'b', 'c'));
-        $this->assertEquals('h', $mock->doSomething('e', 'f', 'g'));
-        $this->assertEquals(null, $mock->doSomething('foo', 'bar'));
+		$this->assertEquals('d', $mock->doSomething('a', 'b', 'c'));
+		$this->assertEquals('h', $mock->doSomething('e', 'f', 'g'));
+		$this->assertEquals(null, $mock->doSomething('foo', 'bar'));
 
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturnMap($map);
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->willReturnMap($map);
 
-        $this->assertEquals('d', $mock->doSomething('a', 'b', 'c'));
-        $this->assertEquals('h', $mock->doSomething('e', 'f', 'g'));
-        $this->assertEquals(null, $mock->doSomething('foo', 'bar'));
-    }
+		$this->assertEquals('d', $mock->doSomething('a', 'b', 'c'));
+		$this->assertEquals('h', $mock->doSomething('e', 'f', 'g'));
+		$this->assertEquals(null, $mock->doSomething('foo', 'bar'));
+	}
 
-    public function testStubbedReturnArgument()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+	public function testStubbedReturnArgument()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->will($this->returnArgument(1));
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->will($this->returnArgument(1));
 
-        $this->assertEquals('b', $mock->doSomething('a', 'b'));
+		$this->assertEquals('b', $mock->doSomething('a', 'b'));
 
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturnArgument(1);
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->willReturnArgument(1);
 
-        $this->assertEquals('b', $mock->doSomething('a', 'b'));
-    }
+		$this->assertEquals('b', $mock->doSomething('a', 'b'));
+	}
 
-    public function testFunctionCallback()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['doSomething'])
-                     ->getMock();
+	public function testFunctionCallback()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->setMethods(['doSomething'])
+					 ->getMock();
 
-        $mock->expects($this->once())
-             ->method('doSomething')
-             ->will($this->returnCallback('functionCallback'));
+		$mock->expects($this->once())
+			 ->method('doSomething')
+			 ->will($this->returnCallback('functionCallback'));
 
-        $this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
+		$this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
 
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['doSomething'])
-                     ->getMock();
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->setMethods(['doSomething'])
+					 ->getMock();
 
-        $mock->expects($this->once())
-             ->method('doSomething')
-             ->willReturnCallback('functionCallback');
+		$mock->expects($this->once())
+			 ->method('doSomething')
+			 ->willReturnCallback('functionCallback');
 
-        $this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
-    }
+		$this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
+	}
 
-    public function testStubbedReturnSelf()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+	public function testStubbedReturnSelf()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->will($this->returnSelf());
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->will($this->returnSelf());
 
-        $this->assertEquals($mock, $mock->doSomething());
+		$this->assertEquals($mock, $mock->doSomething());
 
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturnSelf();
-
-        $this->assertEquals($mock, $mock->doSomething());
-    }
-
-    public function testStubbedReturnOnConsecutiveCalls()
-    {
-        $mock = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->willReturnSelf();
+
+		$this->assertEquals($mock, $mock->doSomething());
+	}
+
+	public function testStubbedReturnOnConsecutiveCalls()
+	{
+		$mock = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
 
-        $mock->expects($this->any())
-             ->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();
-
-        $mock->expects($this->any())
-             ->method('doSomething')
-             ->willReturnOnConsecutiveCalls('a', 'b', 'c');
-
-        $this->assertEquals('a', $mock->doSomething());
-        $this->assertEquals('b', $mock->doSomething());
-        $this->assertEquals('c', $mock->doSomething());
-    }
-
-    public function testStaticMethodCallback()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['doSomething'])
-                     ->getMock();
-
-        $mock->expects($this->once())
-             ->method('doSomething')
-             ->will($this->returnCallback(['MethodCallback', 'staticCallback']));
-
-        $this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
-    }
-
-    public function testPublicMethodCallback()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['doSomething'])
-                     ->getMock();
-
-        $mock->expects($this->once())
-             ->method('doSomething')
-             ->will($this->returnCallback([new MethodCallback, 'nonStaticCallback']));
-
-        $this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
-    }
-
-    public function testMockClassOnlyGeneratedOnce()
-    {
-        $mock1 = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
-
-        $mock2 = $this->getMockBuilder(AnInterface::class)
-                     ->getMock();
-
-        $this->assertEquals(get_class($mock1), get_class($mock2));
-    }
-
-    public function testMockClassDifferentForPartialMocks()
-    {
-        $mock1 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->getMock();
-
-        $mock2 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMethods(['doSomething'])
-                      ->getMock();
-
-        $mock3 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMethods(['doSomething'])
-                      ->getMock();
-
-        $mock4 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMethods(['doAnotherThing'])
-                      ->getMock();
-
-        $mock5 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMethods(['doAnotherThing'])
-                      ->getMock();
-
-        $this->assertNotEquals(get_class($mock1), get_class($mock2));
-        $this->assertNotEquals(get_class($mock1), get_class($mock3));
-        $this->assertNotEquals(get_class($mock1), get_class($mock4));
-        $this->assertNotEquals(get_class($mock1), get_class($mock5));
-        $this->assertEquals(get_class($mock2), get_class($mock3));
-        $this->assertNotEquals(get_class($mock2), get_class($mock4));
-        $this->assertNotEquals(get_class($mock2), get_class($mock5));
-        $this->assertEquals(get_class($mock4), get_class($mock5));
-    }
-
-    public function testMockClassStoreOverrulable()
-    {
-        $mock1 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->getMock();
-
-        $mock2 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMockClassName('MyMockClassNameForPartialMockTestClass1')
-                      ->getMock();
-
-        $mock3 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->getMock();
-
-        $mock4 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMethods(['doSomething'])
-                      ->setMockClassName('AnotherMockClassNameForPartialMockTestClass')
-                      ->getMock();
-
-        $mock5 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->setMockClassName('MyMockClassNameForPartialMockTestClass2')
-                      ->getMock();
-
-        $this->assertNotEquals(get_class($mock1), get_class($mock2));
-        $this->assertEquals(get_class($mock1), get_class($mock3));
-        $this->assertNotEquals(get_class($mock1), get_class($mock4));
-        $this->assertNotEquals(get_class($mock2), get_class($mock3));
-        $this->assertNotEquals(get_class($mock2), get_class($mock4));
-        $this->assertNotEquals(get_class($mock2), get_class($mock5));
-        $this->assertNotEquals(get_class($mock3), get_class($mock4));
-        $this->assertNotEquals(get_class($mock3), get_class($mock5));
-        $this->assertNotEquals(get_class($mock4), get_class($mock5));
-    }
-
-    public function testGetMockWithFixedClassNameCanProduceTheSameMockTwice()
-    {
-        $mock = $this->getMockBuilder(stdClass::class)->setMockClassName('FixedName')->getMock();
-        $mock = $this->getMockBuilder(stdClass::class)->setMockClassName('FixedName')->getMock();
-        $this->assertInstanceOf(stdClass::class, $mock);
-    }
-
-    public function testOriginalConstructorSettingConsidered()
-    {
-        $mock1 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->getMock();
-
-        $mock2 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->disableOriginalConstructor()
-                      ->getMock();
-
-        $this->assertTrue($mock1->constructorCalled);
-        $this->assertFalse($mock2->constructorCalled);
-    }
-
-    public function testOriginalCloneSettingConsidered()
-    {
-        $mock1 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->getMock();
-
-        $mock2 = $this->getMockBuilder(PartialMockTestClass::class)
-                      ->disableOriginalClone()
-                      ->getMock();
-
-        $this->assertNotEquals(get_class($mock1), get_class($mock2));
-    }
-
-    public function testGetMockForAbstractClass()
-    {
-        $mock = $this->getMockBuilder(AbstractMockTestClass::class)
-                     ->getMock();
-
-        $mock->expects($this->never())
-             ->method('doSomething');
-    }
-
-    /**
-     * @dataProvider traversableProvider
-     */
-    public function testGetMockForTraversable($type)
-    {
-        $mock = $this->getMockBuilder($type)
-                     ->getMock();
-
-        $this->assertInstanceOf(Traversable::class, $mock);
-    }
-
-    public function testMultipleInterfacesCanBeMockedInSingleObject()
-    {
-        $mock = $this->getMockBuilder([AnInterface::class, AnotherInterface::class])
-                     ->getMock();
-
-        $this->assertInstanceOf(AnInterface::class, $mock);
-        $this->assertInstanceOf(AnotherInterface::class, $mock);
-    }
-
-    public function testGetMockForTrait()
-    {
-        $mock = $this->getMockForTrait(AbstractTrait::class);
-
-        $mock->expects($this->never())
-             ->method('doSomething');
-
-        $parent = get_parent_class($mock);
-        $traits = class_uses($parent, false);
-
-        $this->assertContains(AbstractTrait::class, $traits);
-    }
-
-    public function testClonedMockObjectShouldStillEqualTheOriginal()
-    {
-        $a = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
-
-        $b = clone $a;
-
-        $this->assertEquals($a, $b);
-    }
-
-    public function testMockObjectsConstructedIndepentantlyShouldBeEqual()
-    {
-        $a = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
-
-        $b = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
-
-        $this->assertEquals($a, $b);
-    }
-
-    public function testMockObjectsConstructedIndepentantlyShouldNotBeTheSame()
-    {
-        $a = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
-
-        $b = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
-
-        $this->assertNotSame($a, $b);
-    }
-
-    public function testClonedMockObjectCanBeUsedInPlaceOfOriginalOne()
-    {
-        $x = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
-
-        $y = clone $x;
-
-        $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
-
-        $mock->expects($this->once())
-             ->method('foo')
-             ->with($this->equalTo($x));
-
-        $mock->foo($y);
-    }
+		$mock->expects($this->any())
+			 ->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();
+
+		$mock->expects($this->any())
+			 ->method('doSomething')
+			 ->willReturnOnConsecutiveCalls('a', 'b', 'c');
+
+		$this->assertEquals('a', $mock->doSomething());
+		$this->assertEquals('b', $mock->doSomething());
+		$this->assertEquals('c', $mock->doSomething());
+	}
+
+	public function testStaticMethodCallback()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->setMethods(['doSomething'])
+					 ->getMock();
+
+		$mock->expects($this->once())
+			 ->method('doSomething')
+			 ->will($this->returnCallback(['MethodCallback', 'staticCallback']));
+
+		$this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
+	}
+
+	public function testPublicMethodCallback()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->setMethods(['doSomething'])
+					 ->getMock();
+
+		$mock->expects($this->once())
+			 ->method('doSomething')
+			 ->will($this->returnCallback([new MethodCallback, 'nonStaticCallback']));
+
+		$this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
+	}
+
+	public function testMockClassOnlyGeneratedOnce()
+	{
+		$mock1 = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
+
+		$mock2 = $this->getMockBuilder(AnInterface::class)
+					 ->getMock();
+
+		$this->assertEquals(get_class($mock1), get_class($mock2));
+	}
+
+	public function testMockClassDifferentForPartialMocks()
+	{
+		$mock1 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->getMock();
+
+		$mock2 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->setMethods(['doSomething'])
+					  ->getMock();
+
+		$mock3 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->setMethods(['doSomething'])
+					  ->getMock();
+
+		$mock4 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->setMethods(['doAnotherThing'])
+					  ->getMock();
+
+		$mock5 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->setMethods(['doAnotherThing'])
+					  ->getMock();
+
+		$this->assertNotEquals(get_class($mock1), get_class($mock2));
+		$this->assertNotEquals(get_class($mock1), get_class($mock3));
+		$this->assertNotEquals(get_class($mock1), get_class($mock4));
+		$this->assertNotEquals(get_class($mock1), get_class($mock5));
+		$this->assertEquals(get_class($mock2), get_class($mock3));
+		$this->assertNotEquals(get_class($mock2), get_class($mock4));
+		$this->assertNotEquals(get_class($mock2), get_class($mock5));
+		$this->assertEquals(get_class($mock4), get_class($mock5));
+	}
+
+	public function testMockClassStoreOverrulable()
+	{
+		$mock1 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->getMock();
+
+		$mock2 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->setMockClassName('MyMockClassNameForPartialMockTestClass1')
+					  ->getMock();
+
+		$mock3 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->getMock();
+
+		$mock4 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->setMethods(['doSomething'])
+					  ->setMockClassName('AnotherMockClassNameForPartialMockTestClass')
+					  ->getMock();
+
+		$mock5 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->setMockClassName('MyMockClassNameForPartialMockTestClass2')
+					  ->getMock();
+
+		$this->assertNotEquals(get_class($mock1), get_class($mock2));
+		$this->assertEquals(get_class($mock1), get_class($mock3));
+		$this->assertNotEquals(get_class($mock1), get_class($mock4));
+		$this->assertNotEquals(get_class($mock2), get_class($mock3));
+		$this->assertNotEquals(get_class($mock2), get_class($mock4));
+		$this->assertNotEquals(get_class($mock2), get_class($mock5));
+		$this->assertNotEquals(get_class($mock3), get_class($mock4));
+		$this->assertNotEquals(get_class($mock3), get_class($mock5));
+		$this->assertNotEquals(get_class($mock4), get_class($mock5));
+	}
+
+	public function testGetMockWithFixedClassNameCanProduceTheSameMockTwice()
+	{
+		$mock = $this->getMockBuilder(stdClass::class)->setMockClassName('FixedName')->getMock();
+		$mock = $this->getMockBuilder(stdClass::class)->setMockClassName('FixedName')->getMock();
+		$this->assertInstanceOf(stdClass::class, $mock);
+	}
+
+	public function testOriginalConstructorSettingConsidered()
+	{
+		$mock1 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->getMock();
+
+		$mock2 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->disableOriginalConstructor()
+					  ->getMock();
+
+		$this->assertTrue($mock1->constructorCalled);
+		$this->assertFalse($mock2->constructorCalled);
+	}
+
+	public function testOriginalCloneSettingConsidered()
+	{
+		$mock1 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->getMock();
+
+		$mock2 = $this->getMockBuilder(PartialMockTestClass::class)
+					  ->disableOriginalClone()
+					  ->getMock();
+
+		$this->assertNotEquals(get_class($mock1), get_class($mock2));
+	}
+
+	public function testGetMockForAbstractClass()
+	{
+		$mock = $this->getMockBuilder(AbstractMockTestClass::class)
+					 ->getMock();
+
+		$mock->expects($this->never())
+			 ->method('doSomething');
+	}
+
+	/**
+	 * @dataProvider traversableProvider
+	 */
+	public function testGetMockForTraversable($type)
+	{
+		$mock = $this->getMockBuilder($type)
+					 ->getMock();
+
+		$this->assertInstanceOf(Traversable::class, $mock);
+	}
+
+	public function testMultipleInterfacesCanBeMockedInSingleObject()
+	{
+		$mock = $this->getMockBuilder([AnInterface::class, AnotherInterface::class])
+					 ->getMock();
+
+		$this->assertInstanceOf(AnInterface::class, $mock);
+		$this->assertInstanceOf(AnotherInterface::class, $mock);
+	}
+
+	public function testGetMockForTrait()
+	{
+		$mock = $this->getMockForTrait(AbstractTrait::class);
+
+		$mock->expects($this->never())
+			 ->method('doSomething');
+
+		$parent = get_parent_class($mock);
+		$traits = class_uses($parent, false);
+
+		$this->assertContains(AbstractTrait::class, $traits);
+	}
+
+	public function testClonedMockObjectShouldStillEqualTheOriginal()
+	{
+		$a = $this->getMockBuilder(stdClass::class)
+				  ->getMock();
+
+		$b = clone $a;
+
+		$this->assertEquals($a, $b);
+	}
+
+	public function testMockObjectsConstructedIndepentantlyShouldBeEqual()
+	{
+		$a = $this->getMockBuilder(stdClass::class)
+				  ->getMock();
+
+		$b = $this->getMockBuilder(stdClass::class)
+				  ->getMock();
+
+		$this->assertEquals($a, $b);
+	}
+
+	public function testMockObjectsConstructedIndepentantlyShouldNotBeTheSame()
+	{
+		$a = $this->getMockBuilder(stdClass::class)
+				  ->getMock();
+
+		$b = $this->getMockBuilder(stdClass::class)
+				  ->getMock();
+
+		$this->assertNotSame($a, $b);
+	}
+
+	public function testClonedMockObjectCanBeUsedInPlaceOfOriginalOne()
+	{
+		$x = $this->getMockBuilder(stdClass::class)
+				  ->getMock();
+
+		$y = clone $x;
+
+		$mock = $this->getMockBuilder(stdClass::class)
+					 ->setMethods(['foo'])
+					 ->getMock();
+
+		$mock->expects($this->once())
+			 ->method('foo')
+			 ->with($this->equalTo($x));
+
+		$mock->foo($y);
+	}
 
-    public function testClonedMockObjectIsNotIdenticalToOriginalOne()
-    {
-        $x = $this->getMockBuilder(stdClass::class)
-                  ->getMock();
-
-        $y = clone $x;
-
-        $mock = $this->getMockBuilder(stdClass::class)
-                     ->setMethods(['foo'])
-                     ->getMock();
-
-        $mock->expects($this->once())
-             ->method('foo')
-             ->with($this->logicalNot($this->identicalTo($x)));
-
-        $mock->foo($y);
-    }
-
-    public function testObjectMethodCallWithArgumentCloningEnabled()
-    {
-        $expectedObject = new stdClass;
-
-        $mock = $this->getMockBuilder('SomeClass')
-                     ->setMethods(['doSomethingElse'])
-                     ->enableArgumentCloning()
-                     ->getMock();
-
-        $actualArguments = [];
-
-        $mock->expects($this->any())
-             ->method('doSomethingElse')
-             ->will(
-                 $this->returnCallback(
-                     function () use (&$actualArguments) {
-                         $actualArguments = func_get_args();
-                     }
-                 )
-             );
-
-        $mock->doSomethingElse($expectedObject);
-
-        $this->assertEquals(1, count($actualArguments));
-        $this->assertEquals($expectedObject, $actualArguments[0]);
-        $this->assertNotSame($expectedObject, $actualArguments[0]);
-    }
-
-    public function testObjectMethodCallWithArgumentCloningDisabled()
-    {
-        $expectedObject = new stdClass;
-
-        $mock = $this->getMockBuilder('SomeClass')
-                     ->setMethods(['doSomethingElse'])
-                     ->disableArgumentCloning()
-                     ->getMock();
-
-        $actualArguments = [];
-
-        $mock->expects($this->any())
-             ->method('doSomethingElse')
-             ->will(
-                 $this->returnCallback(
-                     function () use (&$actualArguments) {
-                         $actualArguments = func_get_args();
-                     }
-                 )
-             );
-
-        $mock->doSomethingElse($expectedObject);
-
-        $this->assertEquals(1, count($actualArguments));
-        $this->assertSame($expectedObject, $actualArguments[0]);
-    }
-
-    public function testArgumentCloningOptionGeneratesUniqueMock()
-    {
-        $mockWithCloning = $this->getMockBuilder('SomeClass')
-                                ->setMethods(['doSomethingElse'])
-                                ->enableArgumentCloning()
-                                ->getMock();
-
-        $mockWithoutCloning = $this->getMockBuilder('SomeClass')
-                                   ->setMethods(['doSomethingElse'])
-                                   ->disableArgumentCloning()
-                                   ->getMock();
-
-        $this->assertNotEquals($mockWithCloning, $mockWithoutCloning);
-    }
-
-    public function testVerificationOfMethodNameFailsWithoutParameters()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
-
-        $mock->expects($this->once())
-             ->method('right');
-
-        $mock->wrong();
-
-        try {
-            $mock->__phpunit_verify();
-            $this->fail('Expected exception');
-        } catch (ExpectationFailedException $e) {
-            $this->assertSame(
-                "Expectation failed for method name is equal to <string:right> when invoked 1 time(s).\n"
-                . "Method was expected to be called 1 times, actually called 0 times.\n",
-                $e->getMessage()
-            );
-        }
-
-        $this->resetMockObjects();
-    }
-
-    public function testVerificationOfMethodNameFailsWithParameters()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
-
-        $mock->expects($this->once())
-             ->method('right');
-
-        $mock->wrong();
-
-        try {
-            $mock->__phpunit_verify();
-            $this->fail('Expected exception');
-        } catch (ExpectationFailedException $e) {
-            $this->assertSame(
-                "Expectation failed for method name is equal to <string:right> when invoked 1 time(s).\n"
-                . "Method was expected to be called 1 times, actually called 0 times.\n",
-                $e->getMessage()
-            );
-        }
-
-        $this->resetMockObjects();
-    }
-
-    public function testVerificationOfMethodNameFailsWithWrongParameters()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
-
-        $mock->expects($this->once())
-             ->method('right')
-             ->with(['first', 'second']);
-
-        try {
-            $mock->right(['second']);
-        } catch (ExpectationFailedException $e) {
-            $this->assertSame(
-                "Expectation failed for method name is equal to <string:right> when invoked 1 time(s)\n"
-                . "Parameter 0 for invocation SomeClass::right(Array (...)) does not match expected value.\n"
-                . 'Failed asserting that two arrays are equal.',
-                $e->getMessage()
-            );
-        }
-
-        try {
-            $mock->__phpunit_verify();
-            $this->fail('Expected exception');
-        } catch (ExpectationFailedException $e) {
-            $this->assertSame(
-                "Expectation failed for method name is equal to <string:right> when invoked 1 time(s).\n"
-                . "Parameter 0 for invocation SomeClass::right(Array (...)) does not match expected value.\n"
-                . "Failed asserting that two arrays are equal.\n"
-                . "--- Expected\n"
-                . "+++ Actual\n"
-                . "@@ @@\n"
-                . " Array (\n"
-                . "-    0 => 'first'\n"
-                . "-    1 => 'second'\n"
-                . "+    0 => 'second'\n"
-                . " )\n",
-                $e->getMessage()
-            );
-        }
-
-        $this->resetMockObjects();
-    }
-
-    public function testVerificationOfNeverFailsWithEmptyParameters()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
-
-        $mock->expects($this->never())
-             ->method('right')
-             ->with();
-
-        try {
-            $mock->right();
-            $this->fail('Expected exception');
-        } catch (ExpectationFailedException $e) {
-            $this->assertSame(
-                'SomeClass::right() was not expected to be called.',
-                $e->getMessage()
-            );
-        }
-
-        $this->resetMockObjects();
-    }
-
-    public function testVerificationOfNeverFailsWithAnyParameters()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
-
-        $mock->expects($this->never())
-             ->method('right')
-             ->withAnyParameters();
-
-        try {
-            $mock->right();
-            $this->fail('Expected exception');
-        } catch (ExpectationFailedException $e) {
-            $this->assertSame(
-                'SomeClass::right() was not expected to be called.',
-                $e->getMessage()
-            );
-        }
-
-        $this->resetMockObjects();
-    }
-
-    public function testWithAnythingInsteadOfWithAnyParameters()
-    {
-        $mock = $this->getMockBuilder(SomeClass::class)
-                     ->setMethods(['right', 'wrong'])
-                     ->getMock();
-
-        $mock->expects($this->once())
-             ->method('right')
-             ->with($this->anything());
-
-        try {
-            $mock->right();
-            $this->fail('Expected exception');
-        } catch (ExpectationFailedException $e) {
-            $this->assertSame(
-                "Expectation failed for method name is equal to <string:right> when invoked 1 time(s)\n" .
-                "Parameter count for invocation SomeClass::right() is too low.\n" .
-                'To allow 0 or more parameters with any value, omit ->with() or use ->withAnyParameters() instead.',
-                $e->getMessage()
-            );
-        }
-
-        $this->resetMockObjects();
-    }
-
-    /**
-     * See https://github.com/sebastianbergmann/phpunit-mock-objects/issues/81
-     */
-    public function testMockArgumentsPassedByReference()
-    {
-        $foo = $this->getMockBuilder('MethodCallbackByReference')
-                    ->setMethods(['bar'])
-                    ->disableOriginalConstructor()
-                    ->disableArgumentCloning()
-                    ->getMock();
-
-        $foo->expects($this->any())
-            ->method('bar')
-            ->will($this->returnCallback([$foo, 'callback']));
-
-        $a = $b = $c = 0;
-
-        $foo->bar($a, $b, $c);
-
-        $this->assertEquals(1, $b);
-    }
-
-    /**
-     * See https://github.com/sebastianbergmann/phpunit-mock-objects/issues/81
-     */
-    public function testMockArgumentsPassedByReference2()
-    {
-        $foo = $this->getMockBuilder('MethodCallbackByReference')
-                    ->disableOriginalConstructor()
-                    ->disableArgumentCloning()
-                    ->getMock();
-
-        $foo->expects($this->any())
-            ->method('bar')
-            ->will($this->returnCallback(
-                function (&$a, &$b, $c) {
-                    $b = 1;
-                }
-            ));
-
-        $a = $b = $c = 0;
-
-        $foo->bar($a, $b, $c);
-
-        $this->assertEquals(1, $b);
-    }
-
-    /**
-     * @see https://github.com/sebastianbergmann/phpunit-mock-objects/issues/116
-     */
-    public function testMockArgumentsPassedByReference3()
-    {
-        $foo = $this->getMockBuilder('MethodCallbackByReference')
-                    ->setMethods(['bar'])
-                    ->disableOriginalConstructor()
-                    ->disableArgumentCloning()
-                    ->getMock();
-
-        $a = new stdClass;
-        $b = $c = 0;
-
-        $foo->expects($this->any())
-            ->method('bar')
-            ->with($a, $b, $c)
-            ->will($this->returnCallback([$foo, 'callback']));
-
-        $this->assertNull($foo->bar($a, $b, $c));
-    }
-
-    /**
-     * @see https://github.com/sebastianbergmann/phpunit/issues/796
-     */
-    public function testMockArgumentsPassedByReference4()
-    {
-        $foo = $this->getMockBuilder('MethodCallbackByReference')
-                    ->setMethods(['bar'])
-                    ->disableOriginalConstructor()
-                    ->disableArgumentCloning()
-                    ->getMock();
-
-        $a = new stdClass;
-        $b = $c = 0;
-
-        $foo->expects($this->any())
-            ->method('bar')
-            ->with($this->isInstanceOf(stdClass::class), $b, $c)
-            ->will($this->returnCallback([$foo, 'callback']));
-
-        $this->assertNull($foo->bar($a, $b, $c));
-    }
-
-    /**
-     * @requires extension soap
-     */
-    public function testCreateMockFromWsdl()
-    {
-        $mock = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl', 'WsdlMock');
-
-        $this->assertStringStartsWith(
-            'Mock_WsdlMock_',
-            get_class($mock)
-        );
-    }
-
-    /**
-     * @requires extension soap
-     */
-    public function testCreateNamespacedMockFromWsdl()
-    {
-        $mock = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl', 'My\\Space\\WsdlMock');
-
-        $this->assertStringStartsWith(
-            'Mock_WsdlMock_',
-            get_class($mock)
-        );
-    }
-
-    /**
-     * @requires extension soap
-     */
-    public function testCreateTwoMocksOfOneWsdlFile()
-    {
-        $a = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl');
-        $b = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl');
-
-        $this->assertStringStartsWith('Mock_GoogleSearch_', get_class($a));
-        $this->assertEquals(get_class($a), get_class($b));
-    }
-
-    /**
-     * @see    https://github.com/sebastianbergmann/phpunit-mock-objects/issues/156
-     * @ticket 156
-     */
-    public function testInterfaceWithStaticMethodCanBeStubbed()
-    {
-        $this->assertInstanceOf(
-            InterfaceWithStaticMethod::class,
-            $this->getMockBuilder(InterfaceWithStaticMethod::class)->getMock()
-        );
-    }
-
-    /**
-     * @expectedException PHPUnit_Framework_MockObject_BadMethodCallException
-     */
-    public function testInvokingStubbedStaticMethodRaisesException()
-    {
-        $mock = $this->getMockBuilder(ClassWithStaticMethod::class)->getMock();
-
-        $mock->staticMethod();
-    }
-
-    /**
-     * @see    https://github.com/sebastianbergmann/phpunit-mock-objects/issues/171
-     * @ticket 171
-     */
-    public function testStubForClassThatImplementsSerializableCanBeCreatedWithoutInvokingTheConstructor()
-    {
-        $this->assertInstanceOf(
-            ClassThatImplementsSerializable::class,
-            $this->getMockBuilder(ClassThatImplementsSerializable::class)
-                 ->disableOriginalConstructor()
-                 ->getMock()
-        );
-    }
-
-    public function testGetMockForClassWithSelfTypeHint()
-    {
-        $this->assertInstanceOf(
-            ClassWithSelfTypeHint::class,
-            $this->getMockBuilder(ClassWithSelfTypeHint::class)->getMock()
-        );
-    }
-
-    private function resetMockObjects()
-    {
-        $refl = new ReflectionObject($this);
-        $refl = $refl->getParentClass();
-        $prop = $refl->getProperty('mockObjects');
-        $prop->setAccessible(true);
-        $prop->setValue($this, []);
-    }
-
-    public function testStringableClassDoesNotThrow()
-    {
-        $mock = $this->getMockBuilder(StringableClass::class)->getMock();
-
-        $this->assertInternalType('string', (string) $mock);
-    }
-
-    public function testStringableClassCanBeMocked()
-    {
-        $mock = $this->getMockBuilder(StringableClass::class)->getMock();
-
-        $mock->method('__toString')->willReturn('foo');
-
-        $this->assertSame('foo', (string) $mock);
-    }
-
-    public function traversableProvider()
-    {
-        return [
-          ['Traversable'],
-          ['\Traversable'],
-          ['TraversableMockTestInterface'],
-          [['Traversable']],
-          [['Iterator','Traversable']],
-          [['\Iterator','\Traversable']]
-        ];
-    }
-
-    public function testParameterCallbackConstraintOnlyEvaluatedOnce()
-    {
-        $mock                  = $this->getMockBuilder(Foo::class)->setMethods(['bar'])->getMock();
-        $expectedNumberOfCalls = 1;
-        $callCount             = 0;
-
-        $mock->expects($this->exactly($expectedNumberOfCalls))->method('bar')
-            ->with($this->callback(function ($argument) use (&$callCount) {
-                return $argument === 'call_' . $callCount++;
-            }));
-
-        for ($i = 0; $i < $expectedNumberOfCalls; $i++) {
-            $mock->bar('call_' . $i);
-        }
-    }
+	public function testClonedMockObjectIsNotIdenticalToOriginalOne()
+	{
+		$x = $this->getMockBuilder(stdClass::class)
+				  ->getMock();
+
+		$y = clone $x;
+
+		$mock = $this->getMockBuilder(stdClass::class)
+					 ->setMethods(['foo'])
+					 ->getMock();
+
+		$mock->expects($this->once())
+			 ->method('foo')
+			 ->with($this->logicalNot($this->identicalTo($x)));
+
+		$mock->foo($y);
+	}
+
+	public function testObjectMethodCallWithArgumentCloningEnabled()
+	{
+		$expectedObject = new stdClass;
+
+		$mock = $this->getMockBuilder('SomeClass')
+					 ->setMethods(['doSomethingElse'])
+					 ->enableArgumentCloning()
+					 ->getMock();
+
+		$actualArguments = [];
+
+		$mock->expects($this->any())
+			 ->method('doSomethingElse')
+			 ->will(
+				 $this->returnCallback(
+					 function () use (&$actualArguments) {
+						 $actualArguments = func_get_args();
+					 }
+				 )
+			 );
+
+		$mock->doSomethingElse($expectedObject);
+
+		$this->assertEquals(1, count($actualArguments));
+		$this->assertEquals($expectedObject, $actualArguments[0]);
+		$this->assertNotSame($expectedObject, $actualArguments[0]);
+	}
+
+	public function testObjectMethodCallWithArgumentCloningDisabled()
+	{
+		$expectedObject = new stdClass;
+
+		$mock = $this->getMockBuilder('SomeClass')
+					 ->setMethods(['doSomethingElse'])
+					 ->disableArgumentCloning()
+					 ->getMock();
+
+		$actualArguments = [];
+
+		$mock->expects($this->any())
+			 ->method('doSomethingElse')
+			 ->will(
+				 $this->returnCallback(
+					 function () use (&$actualArguments) {
+						 $actualArguments = func_get_args();
+					 }
+				 )
+			 );
+
+		$mock->doSomethingElse($expectedObject);
+
+		$this->assertEquals(1, count($actualArguments));
+		$this->assertSame($expectedObject, $actualArguments[0]);
+	}
+
+	public function testArgumentCloningOptionGeneratesUniqueMock()
+	{
+		$mockWithCloning = $this->getMockBuilder('SomeClass')
+								->setMethods(['doSomethingElse'])
+								->enableArgumentCloning()
+								->getMock();
+
+		$mockWithoutCloning = $this->getMockBuilder('SomeClass')
+								   ->setMethods(['doSomethingElse'])
+								   ->disableArgumentCloning()
+								   ->getMock();
+
+		$this->assertNotEquals($mockWithCloning, $mockWithoutCloning);
+	}
+
+	public function testVerificationOfMethodNameFailsWithoutParameters()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->setMethods(['right', 'wrong'])
+					 ->getMock();
+
+		$mock->expects($this->once())
+			 ->method('right');
+
+		$mock->wrong();
+
+		try {
+			$mock->__phpunit_verify();
+			$this->fail('Expected exception');
+		} catch (ExpectationFailedException $e) {
+			$this->assertSame(
+				"Expectation failed for method name is equal to <string:right> when invoked 1 time(s).\n"
+				. "Method was expected to be called 1 times, actually called 0 times.\n",
+				$e->getMessage()
+			);
+		}
+
+		$this->resetMockObjects();
+	}
+
+	public function testVerificationOfMethodNameFailsWithParameters()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->setMethods(['right', 'wrong'])
+					 ->getMock();
+
+		$mock->expects($this->once())
+			 ->method('right');
+
+		$mock->wrong();
+
+		try {
+			$mock->__phpunit_verify();
+			$this->fail('Expected exception');
+		} catch (ExpectationFailedException $e) {
+			$this->assertSame(
+				"Expectation failed for method name is equal to <string:right> when invoked 1 time(s).\n"
+				. "Method was expected to be called 1 times, actually called 0 times.\n",
+				$e->getMessage()
+			);
+		}
+
+		$this->resetMockObjects();
+	}
+
+	public function testVerificationOfMethodNameFailsWithWrongParameters()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->setMethods(['right', 'wrong'])
+					 ->getMock();
+
+		$mock->expects($this->once())
+			 ->method('right')
+			 ->with(['first', 'second']);
+
+		try {
+			$mock->right(['second']);
+		} catch (ExpectationFailedException $e) {
+			$this->assertSame(
+				"Expectation failed for method name is equal to <string:right> when invoked 1 time(s)\n"
+				. "Parameter 0 for invocation SomeClass::right(Array (...)) does not match expected value.\n"
+				. 'Failed asserting that two arrays are equal.',
+				$e->getMessage()
+			);
+		}
+
+		try {
+			$mock->__phpunit_verify();
+			$this->fail('Expected exception');
+		} catch (ExpectationFailedException $e) {
+			$this->assertSame(
+				"Expectation failed for method name is equal to <string:right> when invoked 1 time(s).\n"
+				. "Parameter 0 for invocation SomeClass::right(Array (...)) does not match expected value.\n"
+				. "Failed asserting that two arrays are equal.\n"
+				. "--- Expected\n"
+				. "+++ Actual\n"
+				. "@@ @@\n"
+				. " Array (\n"
+				. "-    0 => 'first'\n"
+				. "-    1 => 'second'\n"
+				. "+    0 => 'second'\n"
+				. " )\n",
+				$e->getMessage()
+			);
+		}
+
+		$this->resetMockObjects();
+	}
+
+	public function testVerificationOfNeverFailsWithEmptyParameters()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->setMethods(['right', 'wrong'])
+					 ->getMock();
+
+		$mock->expects($this->never())
+			 ->method('right')
+			 ->with();
+
+		try {
+			$mock->right();
+			$this->fail('Expected exception');
+		} catch (ExpectationFailedException $e) {
+			$this->assertSame(
+				'SomeClass::right() was not expected to be called.',
+				$e->getMessage()
+			);
+		}
+
+		$this->resetMockObjects();
+	}
+
+	public function testVerificationOfNeverFailsWithAnyParameters()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->setMethods(['right', 'wrong'])
+					 ->getMock();
+
+		$mock->expects($this->never())
+			 ->method('right')
+			 ->withAnyParameters();
+
+		try {
+			$mock->right();
+			$this->fail('Expected exception');
+		} catch (ExpectationFailedException $e) {
+			$this->assertSame(
+				'SomeClass::right() was not expected to be called.',
+				$e->getMessage()
+			);
+		}
+
+		$this->resetMockObjects();
+	}
+
+	public function testWithAnythingInsteadOfWithAnyParameters()
+	{
+		$mock = $this->getMockBuilder(SomeClass::class)
+					 ->setMethods(['right', 'wrong'])
+					 ->getMock();
+
+		$mock->expects($this->once())
+			 ->method('right')
+			 ->with($this->anything());
+
+		try {
+			$mock->right();
+			$this->fail('Expected exception');
+		} catch (ExpectationFailedException $e) {
+			$this->assertSame(
+				"Expectation failed for method name is equal to <string:right> when invoked 1 time(s)\n" .
+				"Parameter count for invocation SomeClass::right() is too low.\n" .
+				'To allow 0 or more parameters with any value, omit ->with() or use ->withAnyParameters() instead.',
+				$e->getMessage()
+			);
+		}
+
+		$this->resetMockObjects();
+	}
+
+	/**
+	 * See https://github.com/sebastianbergmann/phpunit-mock-objects/issues/81
+	 */
+	public function testMockArgumentsPassedByReference()
+	{
+		$foo = $this->getMockBuilder('MethodCallbackByReference')
+					->setMethods(['bar'])
+					->disableOriginalConstructor()
+					->disableArgumentCloning()
+					->getMock();
+
+		$foo->expects($this->any())
+			->method('bar')
+			->will($this->returnCallback([$foo, 'callback']));
+
+		$a = $b = $c = 0;
+
+		$foo->bar($a, $b, $c);
+
+		$this->assertEquals(1, $b);
+	}
+
+	/**
+	 * See https://github.com/sebastianbergmann/phpunit-mock-objects/issues/81
+	 */
+	public function testMockArgumentsPassedByReference2()
+	{
+		$foo = $this->getMockBuilder('MethodCallbackByReference')
+					->disableOriginalConstructor()
+					->disableArgumentCloning()
+					->getMock();
+
+		$foo->expects($this->any())
+			->method('bar')
+			->will($this->returnCallback(
+				function (&$a, &$b, $c) {
+					$b = 1;
+				}
+			));
+
+		$a = $b = $c = 0;
+
+		$foo->bar($a, $b, $c);
+
+		$this->assertEquals(1, $b);
+	}
+
+	/**
+	 * @see https://github.com/sebastianbergmann/phpunit-mock-objects/issues/116
+	 */
+	public function testMockArgumentsPassedByReference3()
+	{
+		$foo = $this->getMockBuilder('MethodCallbackByReference')
+					->setMethods(['bar'])
+					->disableOriginalConstructor()
+					->disableArgumentCloning()
+					->getMock();
+
+		$a = new stdClass;
+		$b = $c = 0;
+
+		$foo->expects($this->any())
+			->method('bar')
+			->with($a, $b, $c)
+			->will($this->returnCallback([$foo, 'callback']));
+
+		$this->assertNull($foo->bar($a, $b, $c));
+	}
+
+	/**
+	 * @see https://github.com/sebastianbergmann/phpunit/issues/796
+	 */
+	public function testMockArgumentsPassedByReference4()
+	{
+		$foo = $this->getMockBuilder('MethodCallbackByReference')
+					->setMethods(['bar'])
+					->disableOriginalConstructor()
+					->disableArgumentCloning()
+					->getMock();
+
+		$a = new stdClass;
+		$b = $c = 0;
+
+		$foo->expects($this->any())
+			->method('bar')
+			->with($this->isInstanceOf(stdClass::class), $b, $c)
+			->will($this->returnCallback([$foo, 'callback']));
+
+		$this->assertNull($foo->bar($a, $b, $c));
+	}
+
+	/**
+	 * @requires extension soap
+	 */
+	public function testCreateMockFromWsdl()
+	{
+		$mock = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl', 'WsdlMock');
+
+		$this->assertStringStartsWith(
+			'Mock_WsdlMock_',
+			get_class($mock)
+		);
+	}
+
+	/**
+	 * @requires extension soap
+	 */
+	public function testCreateNamespacedMockFromWsdl()
+	{
+		$mock = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl', 'My\\Space\\WsdlMock');
+
+		$this->assertStringStartsWith(
+			'Mock_WsdlMock_',
+			get_class($mock)
+		);
+	}
+
+	/**
+	 * @requires extension soap
+	 */
+	public function testCreateTwoMocksOfOneWsdlFile()
+	{
+		$a = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl');
+		$b = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl');
+
+		$this->assertStringStartsWith('Mock_GoogleSearch_', get_class($a));
+		$this->assertEquals(get_class($a), get_class($b));
+	}
+
+	/**
+	 * @see    https://github.com/sebastianbergmann/phpunit-mock-objects/issues/156
+	 * @ticket 156
+	 */
+	public function testInterfaceWithStaticMethodCanBeStubbed()
+	{
+		$this->assertInstanceOf(
+			InterfaceWithStaticMethod::class,
+			$this->getMockBuilder(InterfaceWithStaticMethod::class)->getMock()
+		);
+	}
+
+	/**
+	 * @expectedException PHPUnit_Framework_MockObject_BadMethodCallException
+	 */
+	public function testInvokingStubbedStaticMethodRaisesException()
+	{
+		$mock = $this->getMockBuilder(ClassWithStaticMethod::class)->getMock();
+
+		$mock->staticMethod();
+	}
+
+	/**
+	 * @see    https://github.com/sebastianbergmann/phpunit-mock-objects/issues/171
+	 * @ticket 171
+	 */
+	public function testStubForClassThatImplementsSerializableCanBeCreatedWithoutInvokingTheConstructor()
+	{
+		$this->assertInstanceOf(
+			ClassThatImplementsSerializable::class,
+			$this->getMockBuilder(ClassThatImplementsSerializable::class)
+				 ->disableOriginalConstructor()
+				 ->getMock()
+		);
+	}
+
+	public function testGetMockForClassWithSelfTypeHint()
+	{
+		$this->assertInstanceOf(
+			ClassWithSelfTypeHint::class,
+			$this->getMockBuilder(ClassWithSelfTypeHint::class)->getMock()
+		);
+	}
+
+	private function resetMockObjects()
+	{
+		$refl = new ReflectionObject($this);
+		$refl = $refl->getParentClass();
+		$prop = $refl->getProperty('mockObjects');
+		$prop->setAccessible(true);
+		$prop->setValue($this, []);
+	}
+
+	public function testStringableClassDoesNotThrow()
+	{
+		$mock = $this->getMockBuilder(StringableClass::class)->getMock();
+
+		$this->assertInternalType('string', (string) $mock);
+	}
+
+	public function testStringableClassCanBeMocked()
+	{
+		$mock = $this->getMockBuilder(StringableClass::class)->getMock();
+
+		$mock->method('__toString')->willReturn('foo');
+
+		$this->assertSame('foo', (string) $mock);
+	}
+
+	public function traversableProvider()
+	{
+		return [
+		  ['Traversable'],
+		  ['\Traversable'],
+		  ['TraversableMockTestInterface'],
+		  [['Traversable']],
+		  [['Iterator','Traversable']],
+		  [['\Iterator','\Traversable']]
+		];
+	}
+
+	public function testParameterCallbackConstraintOnlyEvaluatedOnce()
+	{
+		$mock                  = $this->getMockBuilder(Foo::class)->setMethods(['bar'])->getMock();
+		$expectedNumberOfCalls = 1;
+		$callCount             = 0;
+
+		$mock->expects($this->exactly($expectedNumberOfCalls))->method('bar')
+			->with($this->callback(function ($argument) use (&$callCount) {
+				return $argument === 'call_' . $callCount++;
+			}));
+
+		for ($i = 0; $i < $expectedNumberOfCalls; $i++) {
+			$mock->bar('call_' . $i);
+		}
+	}
 }

Spacing +14 added lines, -14 removed lines

@@ -589,7 +589,7 @@ 
              ->method('doSomethingElse')
              ->will(
                  $this->returnCallback(
-                     function () use (&$actualArguments) {
+                     function() use (&$actualArguments) {
                          $actualArguments = func_get_args();
                      }
                  )
@@ -617,7 +617,7 @@ 
              ->method('doSomethingElse')
              ->will(
                  $this->returnCallback(
-                     function () use (&$actualArguments) {
+                     function() use (&$actualArguments) {
                          $actualArguments = func_get_args();
                      }
                  )
@@ -799,8 +799,8 @@ 
             $this->fail('Expected exception');
         } catch (ExpectationFailedException $e) {
             $this->assertSame(
-                "Expectation failed for method name is equal to <string:right> when invoked 1 time(s)\n" .
-                "Parameter count for invocation SomeClass::right() is too low.\n" .
+                "Expectation failed for method name is equal to <string:right> when invoked 1 time(s)\n".
+                "Parameter count for invocation SomeClass::right() is too low.\n".
                 'To allow 0 or more parameters with any value, omit ->with() or use ->withAnyParameters() instead.',
                 $e->getMessage()
             );
@@ -844,7 +844,7 @@ 
         $foo->expects($this->any())
             ->method('bar')
             ->will($this->returnCallback(
-                function (&$a, &$b, $c) {
+                function(&$a, &$b, $c) {
                     $b = 1;
                 }
             ));
@@ -905,7 +905,7 @@ 
      */
     public function testCreateMockFromWsdl()
     {
-        $mock = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl', 'WsdlMock');
+        $mock = $this->getMockFromWsdl(__DIR__.'/_fixture/GoogleSearch.wsdl', 'WsdlMock');
 
         $this->assertStringStartsWith(
             'Mock_WsdlMock_',
@@ -918,7 +918,7 @@ 
      */
     public function testCreateNamespacedMockFromWsdl()
     {
-        $mock = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl', 'My\\Space\\WsdlMock');
+        $mock = $this->getMockFromWsdl(__DIR__.'/_fixture/GoogleSearch.wsdl', 'My\\Space\\WsdlMock');
 
         $this->assertStringStartsWith(
             'Mock_WsdlMock_',
@@ -931,8 +931,8 @@ 
      */
     public function testCreateTwoMocksOfOneWsdlFile()
     {
-        $a = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl');
-        $b = $this->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl');
+        $a = $this->getMockFromWsdl(__DIR__.'/_fixture/GoogleSearch.wsdl');
+        $b = $this->getMockFromWsdl(__DIR__.'/_fixture/GoogleSearch.wsdl');
 
         $this->assertStringStartsWith('Mock_GoogleSearch_', get_class($a));
         $this->assertEquals(get_class($a), get_class($b));
@@ -1014,8 +1014,8 @@ 
           ['\Traversable'],
           ['TraversableMockTestInterface'],
           [['Traversable']],
-          [['Iterator','Traversable']],
-          [['\Iterator','\Traversable']]
+          [['Iterator', 'Traversable']],
+          [['\Iterator', '\Traversable']]
         ];
     }
 
@@ -1026,12 +1026,12 @@ 
         $callCount             = 0;
 
         $mock->expects($this->exactly($expectedNumberOfCalls))->method('bar')
-            ->with($this->callback(function ($argument) use (&$callCount) {
-                return $argument === 'call_' . $callCount++;
+            ->with($this->callback(function($argument) use (&$callCount) {
+                return $argument === 'call_'.$callCount++;
             }));
 
         for ($i = 0; $i < $expectedNumberOfCalls; $i++) {
-            $mock->bar('call_' . $i);
+            $mock->bar('call_'.$i);
         }
     }
 }

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

Indentation +7 added lines, -7 removed lines

@@ -1,12 +1,12 @@
 <?php
 class StaticMockTestClass
 {
-    public static function doSomething()
-    {
-    }
+	public static function doSomething()
+	{
+	}
 
-    public static function doSomethingElse()
-    {
-        return static::doSomething();
-    }
+	public static function doSomethingElse()
+	{
+		return static::doSomething();
+	}
 }

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

Indentation +11 added lines, -11 removed lines

@@ -1,18 +1,18 @@
 <?php
 class PartialMockTestClass
 {
-    public $constructorCalled = false;
+	public $constructorCalled = false;
 
-    public function __construct()
-    {
-        $this->constructorCalled = true;
-    }
+	public function __construct()
+	{
+		$this->constructorCalled = true;
+	}
 
-    public function doSomething()
-    {
-    }
+	public function doSomething()
+	{
+	}
 
-    public function doAnotherThing()
-    {
-    }
+	public function doAnotherThing()
+	{
+	}
 }

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

Indentation +1 added lines, -1 removed lines

@@ -1,5 +1,5 @@
 <?php
 interface AnotherInterface
 {
-    public function doSomethingElse();
+	public function doSomethingElse();
 }