chillerlan / php-traits

vendor/phpunit/php-token-stream/src/Token/Stream/CachingFactory.php

Indentation +27 added lines, -27 removed lines

@@ -13,34 +13,34 @@
  */
 class PHP_Token_Stream_CachingFactory
 {
-    /**
-     * @var array
-     */
-    protected static $cache = [];
+	/**
+	 * @var array
+	 */
+	protected static $cache = [];
 
-    /**
-     * @param string $filename
-     *
-     * @return PHP_Token_Stream
-     */
-    public static function get($filename)
-    {
-        if (!isset(self::$cache[$filename])) {
-            self::$cache[$filename] = new PHP_Token_Stream($filename);
-        }
+	/**
+	 * @param string $filename
+	 *
+	 * @return PHP_Token_Stream
+	 */
+	public static function get($filename)
+	{
+		if (!isset(self::$cache[$filename])) {
+			self::$cache[$filename] = new PHP_Token_Stream($filename);
+		}
 
-        return self::$cache[$filename];
-    }
+		return self::$cache[$filename];
+	}
 
-    /**
-     * @param string $filename
-     */
-    public static function clear($filename = null)
-    {
-        if (is_string($filename)) {
-            unset(self::$cache[$filename]);
-        } else {
-            self::$cache = [];
-        }
-    }
+	/**
+	 * @param string $filename
+	 */
+	public static function clear($filename = null)
+	{
+		if (is_string($filename)) {
+			unset(self::$cache[$filename]);
+		} else {
+			self::$cache = [];
+		}
+	}
 }

vendor/phpunit/php-text-template/src/Template.php

Indentation +116 added lines, -116 removed lines

@@ -15,121 +15,121 @@
  */
 class Text_Template
 {
-    /**
-     * @var string
-     */
-    protected $template = '';
-
-    /**
-     * @var string
-     */
-    protected $openDelimiter = '{';
-
-    /**
-     * @var string
-     */
-    protected $closeDelimiter = '}';
-
-    /**
-     * @var array
-     */
-    protected $values = array();
-
-    /**
-     * Constructor.
-     *
-     * @param  string                   $file
-     * @throws InvalidArgumentException
-     */
-    public function __construct($file = '', $openDelimiter = '{', $closeDelimiter = '}')
-    {
-        $this->setFile($file);
-        $this->openDelimiter  = $openDelimiter;
-        $this->closeDelimiter = $closeDelimiter;
-    }
-
-    /**
-     * Sets the template file.
-     *
-     * @param  string                   $file
-     * @throws InvalidArgumentException
-     */
-    public function setFile($file)
-    {
-        $distFile = $file . '.dist';
-
-        if (file_exists($file)) {
-            $this->template = file_get_contents($file);
-        }
-
-        else if (file_exists($distFile)) {
-            $this->template = file_get_contents($distFile);
-        }
-
-        else {
-            throw new InvalidArgumentException(
-              'Template file could not be loaded.'
-            );
-        }
-    }
-
-    /**
-     * Sets one or more template variables.
-     *
-     * @param array $values
-     * @param bool  $merge
-     */
-    public function setVar(array $values, $merge = TRUE)
-    {
-        if (!$merge || empty($this->values)) {
-            $this->values = $values;
-        } else {
-            $this->values = array_merge($this->values, $values);
-        }
-    }
-
-    /**
-     * Renders the template and returns the result.
-     *
-     * @return string
-     */
-    public function render()
-    {
-        $keys = array();
-
-        foreach ($this->values as $key => $value) {
-            $keys[] = $this->openDelimiter . $key . $this->closeDelimiter;
-        }
-
-        return str_replace($keys, $this->values, $this->template);
-    }
-
-    /**
-     * Renders the template and writes the result to a file.
-     *
-     * @param string $target
-     */
-    public function renderTo($target)
-    {
-        $fp = @fopen($target, 'wt');
-
-        if ($fp) {
-            fwrite($fp, $this->render());
-            fclose($fp);
-        } else {
-            $error = error_get_last();
-
-            throw new RuntimeException(
-              sprintf(
-                'Could not write to %s: %s',
-                $target,
-                substr(
-                  $error['message'],
-                  strpos($error['message'], ':') + 2
-                )
-              )
-            );
-        }
-    }
+	/**
+	 * @var string
+	 */
+	protected $template = '';
+
+	/**
+	 * @var string
+	 */
+	protected $openDelimiter = '{';
+
+	/**
+	 * @var string
+	 */
+	protected $closeDelimiter = '}';
+
+	/**
+	 * @var array
+	 */
+	protected $values = array();
+
+	/**
+	 * Constructor.
+	 *
+	 * @param  string                   $file
+	 * @throws InvalidArgumentException
+	 */
+	public function __construct($file = '', $openDelimiter = '{', $closeDelimiter = '}')
+	{
+		$this->setFile($file);
+		$this->openDelimiter  = $openDelimiter;
+		$this->closeDelimiter = $closeDelimiter;
+	}
+
+	/**
+	 * Sets the template file.
+	 *
+	 * @param  string                   $file
+	 * @throws InvalidArgumentException
+	 */
+	public function setFile($file)
+	{
+		$distFile = $file . '.dist';
+
+		if (file_exists($file)) {
+			$this->template = file_get_contents($file);
+		}
+
+		else if (file_exists($distFile)) {
+			$this->template = file_get_contents($distFile);
+		}
+
+		else {
+			throw new InvalidArgumentException(
+			  'Template file could not be loaded.'
+			);
+		}
+	}
+
+	/**
+	 * Sets one or more template variables.
+	 *
+	 * @param array $values
+	 * @param bool  $merge
+	 */
+	public function setVar(array $values, $merge = TRUE)
+	{
+		if (!$merge || empty($this->values)) {
+			$this->values = $values;
+		} else {
+			$this->values = array_merge($this->values, $values);
+		}
+	}
+
+	/**
+	 * Renders the template and returns the result.
+	 *
+	 * @return string
+	 */
+	public function render()
+	{
+		$keys = array();
+
+		foreach ($this->values as $key => $value) {
+			$keys[] = $this->openDelimiter . $key . $this->closeDelimiter;
+		}
+
+		return str_replace($keys, $this->values, $this->template);
+	}
+
+	/**
+	 * Renders the template and writes the result to a file.
+	 *
+	 * @param string $target
+	 */
+	public function renderTo($target)
+	{
+		$fp = @fopen($target, 'wt');
+
+		if ($fp) {
+			fwrite($fp, $this->render());
+			fclose($fp);
+		} else {
+			$error = error_get_last();
+
+			throw new RuntimeException(
+			  sprintf(
+				'Could not write to %s: %s',
+				$target,
+				substr(
+				  $error['message'],
+				  strpos($error['message'], ':') + 2
+				)
+			  )
+			);
+		}
+	}
 }
 

Spacing +2 added lines, -2 removed lines

@@ -56,7 +56,7 @@ 
      */
     public function setFile($file)
     {
-        $distFile = $file . '.dist';
+        $distFile = $file.'.dist';
 
         if (file_exists($file)) {
             $this->template = file_get_contents($file);
@@ -98,7 +98,7 @@ 
         $keys = array();
 
         foreach ($this->values as $key => $value) {
-            $keys[] = $this->openDelimiter . $key . $this->closeDelimiter;
+            $keys[] = $this->openDelimiter.$key.$this->closeDelimiter;
         }
 
         return str_replace($keys, $this->values, $this->template);

Braces +2 added lines, -6 removed lines

@@ -60,13 +60,9 @@
 
         if (file_exists($file)) {
             $this->template = file_get_contents($file);
-        }
-
-        else if (file_exists($distFile)) {
+        } else if (file_exists($distFile)) {
             $this->template = file_get_contents($distFile);
-        }
-
-        else {
+        } else {
             throw new InvalidArgumentException(
               'Template file could not be loaded.'
             );

vendor/phpunit/phpunit/tests/Util/GetoptTest.php

Indentation +197 added lines, -197 removed lines

@@ -15,201 +15,201 @@
 
 class GetoptTest extends TestCase
 {
-    public function testItIncludeTheLongOptionsAfterTheArgument()
-    {
-        $args = [
-            'command',
-            'myArgument',
-            '--colors',
-        ];
-        $actual = Getopt::getopt($args, '', ['colors==']);
-
-        $expected = [
-            [
-                [
-                    '--colors',
-                    null,
-                ],
-            ],
-            [
-                'myArgument',
-            ],
-        ];
-
-        $this->assertEquals($expected, $actual);
-    }
-
-    public function testItIncludeTheShortOptionsAfterTheArgument()
-    {
-        $args = [
-            'command',
-            'myArgument',
-            '-v',
-        ];
-        $actual = Getopt::getopt($args, 'v');
-
-        $expected = [
-            [
-                [
-                    'v',
-                    null,
-                ],
-            ],
-            [
-                'myArgument',
-            ],
-        ];
-
-        $this->assertEquals($expected, $actual);
-    }
-
-    public function testShortOptionUnrecognizedException()
-    {
-        $args = [
-            'command',
-            'myArgument',
-            '-v',
-        ];
-
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('unrecognized option -- v');
-
-        Getopt::getopt($args, '');
-    }
-
-    public function testShortOptionRequiresAnArgumentException()
-    {
-        $args = [
-            'command',
-            'myArgument',
-            '-f',
-        ];
-
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('option requires an argument -- f');
-
-        Getopt::getopt($args, 'f:');
-    }
-
-    public function testShortOptionHandleAnOptionalValue()
-    {
-        $args = [
-            'command',
-            'myArgument',
-            '-f',
-        ];
-        $actual   = Getopt::getopt($args, 'f::');
-        $expected = [
-            [
-                [
-                    'f',
-                    null,
-                ],
-            ],
-            [
-                'myArgument',
-            ],
-        ];
-        $this->assertEquals($expected, $actual);
-    }
-
-    public function testLongOptionIsAmbiguousException()
-    {
-        $args = [
-            'command',
-            '--col',
-        ];
-
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('option --col is ambiguous');
-
-        Getopt::getopt($args, '', ['columns', 'colors']);
-    }
-
-    public function testLongOptionUnrecognizedException()
-    {
-        // the exception 'unrecognized option --option' is not thrown
-        // if the there are not defined extended options
-        $args = [
-            'command',
-            '--foo',
-        ];
-
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('unrecognized option --foo');
-
-        Getopt::getopt($args, '', ['colors']);
-    }
-
-    public function testLongOptionRequiresAnArgumentException()
-    {
-        $args = [
-            'command',
-            '--foo',
-        ];
-
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('option --foo requires an argument');
-
-        Getopt::getopt($args, '', ['foo=']);
-    }
-
-    public function testLongOptionDoesNotAllowAnArgumentException()
-    {
-        $args = [
-            'command',
-            '--foo=bar',
-        ];
-
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage("option --foo doesn't allow an argument");
-
-        Getopt::getopt($args, '', ['foo']);
-    }
-
-    public function testItHandlesLongParametesWithValues()
-    {
-        $command = 'command parameter-0 --exec parameter-1 --conf config.xml --optn parameter-2 --optn=content-of-o parameter-n';
-        $args    = \explode(' ', $command);
-        unset($args[0]);
-        $expected = [
-            [
-                ['--exec', null],
-                ['--conf', 'config.xml'],
-                ['--optn', null],
-                ['--optn', 'content-of-o'],
-            ],
-            [
-                'parameter-0',
-                'parameter-1',
-                'parameter-2',
-                'parameter-n',
-            ],
-        ];
-        $actual = Getopt::getopt($args, '', ['exec', 'conf=', 'optn==']);
-        $this->assertEquals($expected, $actual);
-    }
-
-    public function testItHandlesShortParametesWithValues()
-    {
-        $command = 'command parameter-0 -x parameter-1 -c config.xml -o parameter-2 -ocontent-of-o parameter-n';
-        $args    = \explode(' ', $command);
-        unset($args[0]);
-        $expected = [
-            [
-                ['x', null],
-                ['c', 'config.xml'],
-                ['o', null],
-                ['o', 'content-of-o'],
-            ],
-            [
-                'parameter-0',
-                'parameter-1',
-                'parameter-2',
-                'parameter-n',
-            ],
-        ];
-        $actual = Getopt::getopt($args, 'xc:o::');
-        $this->assertEquals($expected, $actual);
-    }
+	public function testItIncludeTheLongOptionsAfterTheArgument()
+	{
+		$args = [
+			'command',
+			'myArgument',
+			'--colors',
+		];
+		$actual = Getopt::getopt($args, '', ['colors==']);
+
+		$expected = [
+			[
+				[
+					'--colors',
+					null,
+				],
+			],
+			[
+				'myArgument',
+			],
+		];
+
+		$this->assertEquals($expected, $actual);
+	}
+
+	public function testItIncludeTheShortOptionsAfterTheArgument()
+	{
+		$args = [
+			'command',
+			'myArgument',
+			'-v',
+		];
+		$actual = Getopt::getopt($args, 'v');
+
+		$expected = [
+			[
+				[
+					'v',
+					null,
+				],
+			],
+			[
+				'myArgument',
+			],
+		];
+
+		$this->assertEquals($expected, $actual);
+	}
+
+	public function testShortOptionUnrecognizedException()
+	{
+		$args = [
+			'command',
+			'myArgument',
+			'-v',
+		];
+
+		$this->expectException(Exception::class);
+		$this->expectExceptionMessage('unrecognized option -- v');
+
+		Getopt::getopt($args, '');
+	}
+
+	public function testShortOptionRequiresAnArgumentException()
+	{
+		$args = [
+			'command',
+			'myArgument',
+			'-f',
+		];
+
+		$this->expectException(Exception::class);
+		$this->expectExceptionMessage('option requires an argument -- f');
+
+		Getopt::getopt($args, 'f:');
+	}
+
+	public function testShortOptionHandleAnOptionalValue()
+	{
+		$args = [
+			'command',
+			'myArgument',
+			'-f',
+		];
+		$actual   = Getopt::getopt($args, 'f::');
+		$expected = [
+			[
+				[
+					'f',
+					null,
+				],
+			],
+			[
+				'myArgument',
+			],
+		];
+		$this->assertEquals($expected, $actual);
+	}
+
+	public function testLongOptionIsAmbiguousException()
+	{
+		$args = [
+			'command',
+			'--col',
+		];
+
+		$this->expectException(Exception::class);
+		$this->expectExceptionMessage('option --col is ambiguous');
+
+		Getopt::getopt($args, '', ['columns', 'colors']);
+	}
+
+	public function testLongOptionUnrecognizedException()
+	{
+		// the exception 'unrecognized option --option' is not thrown
+		// if the there are not defined extended options
+		$args = [
+			'command',
+			'--foo',
+		];
+
+		$this->expectException(Exception::class);
+		$this->expectExceptionMessage('unrecognized option --foo');
+
+		Getopt::getopt($args, '', ['colors']);
+	}
+
+	public function testLongOptionRequiresAnArgumentException()
+	{
+		$args = [
+			'command',
+			'--foo',
+		];
+
+		$this->expectException(Exception::class);
+		$this->expectExceptionMessage('option --foo requires an argument');
+
+		Getopt::getopt($args, '', ['foo=']);
+	}
+
+	public function testLongOptionDoesNotAllowAnArgumentException()
+	{
+		$args = [
+			'command',
+			'--foo=bar',
+		];
+
+		$this->expectException(Exception::class);
+		$this->expectExceptionMessage("option --foo doesn't allow an argument");
+
+		Getopt::getopt($args, '', ['foo']);
+	}
+
+	public function testItHandlesLongParametesWithValues()
+	{
+		$command = 'command parameter-0 --exec parameter-1 --conf config.xml --optn parameter-2 --optn=content-of-o parameter-n';
+		$args    = \explode(' ', $command);
+		unset($args[0]);
+		$expected = [
+			[
+				['--exec', null],
+				['--conf', 'config.xml'],
+				['--optn', null],
+				['--optn', 'content-of-o'],
+			],
+			[
+				'parameter-0',
+				'parameter-1',
+				'parameter-2',
+				'parameter-n',
+			],
+		];
+		$actual = Getopt::getopt($args, '', ['exec', 'conf=', 'optn==']);
+		$this->assertEquals($expected, $actual);
+	}
+
+	public function testItHandlesShortParametesWithValues()
+	{
+		$command = 'command parameter-0 -x parameter-1 -c config.xml -o parameter-2 -ocontent-of-o parameter-n';
+		$args    = \explode(' ', $command);
+		unset($args[0]);
+		$expected = [
+			[
+				['x', null],
+				['c', 'config.xml'],
+				['o', null],
+				['o', 'content-of-o'],
+			],
+			[
+				'parameter-0',
+				'parameter-1',
+				'parameter-2',
+				'parameter-n',
+			],
+		];
+		$actual = Getopt::getopt($args, 'xc:o::');
+		$this->assertEquals($expected, $actual);
+	}
 }

vendor/phpunit/phpunit/tests/Util/RegularExpressionTest.php

Indentation +31 added lines, -31 removed lines

@@ -14,38 +14,38 @@
 
 class RegularExpressionTest extends TestCase
 {
-    public function validRegexpProvider()
-    {
-        return [
-          ['#valid regexp#', 'valid regexp', 1],
-          [';val.*xp;', 'valid regexp', 1],
-          ['/val.*xp/i', 'VALID REGEXP', 1],
-          ['/a val.*p/','valid regexp', 0],
-        ];
-    }
+	public function validRegexpProvider()
+	{
+		return [
+		  ['#valid regexp#', 'valid regexp', 1],
+		  [';val.*xp;', 'valid regexp', 1],
+		  ['/val.*xp/i', 'VALID REGEXP', 1],
+		  ['/a val.*p/','valid regexp', 0],
+		];
+	}
 
-    public function invalidRegexpProvider()
-    {
-        return [
-          ['valid regexp', 'valid regexp'],
-          [';val.*xp', 'valid regexp'],
-          ['val.*xp/i', 'VALID REGEXP'],
-        ];
-    }
+	public function invalidRegexpProvider()
+	{
+		return [
+		  ['valid regexp', 'valid regexp'],
+		  [';val.*xp', 'valid regexp'],
+		  ['val.*xp/i', 'VALID REGEXP'],
+		];
+	}
 
-    /**
-     * @dataProvider validRegexpProvider
-     */
-    public function testValidRegex($pattern, $subject, $return)
-    {
-        $this->assertEquals($return, RegularExpression::safeMatch($pattern, $subject));
-    }
+	/**
+	 * @dataProvider validRegexpProvider
+	 */
+	public function testValidRegex($pattern, $subject, $return)
+	{
+		$this->assertEquals($return, RegularExpression::safeMatch($pattern, $subject));
+	}
 
-    /**
-     * @dataProvider invalidRegexpProvider
-     */
-    public function testInvalidRegex($pattern, $subject)
-    {
-        $this->assertFalse(RegularExpression::safeMatch($pattern, $subject));
-    }
+	/**
+	 * @dataProvider invalidRegexpProvider
+	 */
+	public function testInvalidRegex($pattern, $subject)
+	{
+		$this->assertFalse(RegularExpression::safeMatch($pattern, $subject));
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -20,7 +20,7 @@
           ['#valid regexp#', 'valid regexp', 1],
           [';val.*xp;', 'valid regexp', 1],
           ['/val.*xp/i', 'VALID REGEXP', 1],
-          ['/a val.*p/','valid regexp', 0],
+          ['/a val.*p/', 'valid regexp', 0],
         ];
     }
 

vendor/phpunit/phpunit/tests/Util/TestDox/NamePrettifierTest.php

Indentation +48 added lines, -48 removed lines

@@ -14,60 +14,60 @@
 
 class NamePrettifierTest extends TestCase
 {
-    /**
-     * @var NamePrettifier
-     */
-    private $namePrettifier;
+	/**
+	 * @var NamePrettifier
+	 */
+	private $namePrettifier;
 
-    protected function setUp()
-    {
-        $this->namePrettifier = new NamePrettifier;
-    }
+	protected function setUp()
+	{
+		$this->namePrettifier = new NamePrettifier;
+	}
 
-    public function testTitleHasSensibleDefaults()
-    {
-        $this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('FooTest'));
-        $this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('TestFoo'));
-        $this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('TestFooTest'));
-        $this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('Test\FooTest'));
-    }
+	public function testTitleHasSensibleDefaults()
+	{
+		$this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('FooTest'));
+		$this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('TestFoo'));
+		$this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('TestFooTest'));
+		$this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('Test\FooTest'));
+	}
 
-    public function testCaterForUserDefinedSuffix()
-    {
-        $this->namePrettifier->setSuffix('TestCase');
-        $this->namePrettifier->setPrefix(null);
+	public function testCaterForUserDefinedSuffix()
+	{
+		$this->namePrettifier->setSuffix('TestCase');
+		$this->namePrettifier->setPrefix(null);
 
-        $this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('FooTestCase'));
-        $this->assertEquals('TestFoo', $this->namePrettifier->prettifyTestClass('TestFoo'));
-        $this->assertEquals('FooTest', $this->namePrettifier->prettifyTestClass('FooTest'));
-    }
+		$this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('FooTestCase'));
+		$this->assertEquals('TestFoo', $this->namePrettifier->prettifyTestClass('TestFoo'));
+		$this->assertEquals('FooTest', $this->namePrettifier->prettifyTestClass('FooTest'));
+	}
 
-    public function testCaterForUserDefinedPrefix()
-    {
-        $this->namePrettifier->setSuffix(null);
-        $this->namePrettifier->setPrefix('XXX');
+	public function testCaterForUserDefinedPrefix()
+	{
+		$this->namePrettifier->setSuffix(null);
+		$this->namePrettifier->setPrefix('XXX');
 
-        $this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('XXXFoo'));
-        $this->assertEquals('TestXXX', $this->namePrettifier->prettifyTestClass('TestXXX'));
-        $this->assertEquals('XXX', $this->namePrettifier->prettifyTestClass('XXXXXX'));
-    }
+		$this->assertEquals('Foo', $this->namePrettifier->prettifyTestClass('XXXFoo'));
+		$this->assertEquals('TestXXX', $this->namePrettifier->prettifyTestClass('TestXXX'));
+		$this->assertEquals('XXX', $this->namePrettifier->prettifyTestClass('XXXXXX'));
+	}
 
-    public function testTestNameIsConvertedToASentence()
-    {
-        $this->assertEquals('This is a test', $this->namePrettifier->prettifyTestMethod('testThisIsATest'));
-        $this->assertEquals('This is a test', $this->namePrettifier->prettifyTestMethod('testThisIsATest2'));
-        $this->assertEquals('This is a test', $this->namePrettifier->prettifyTestMethod('this_is_a_test'));
-        $this->assertEquals('Foo for bar is 0', $this->namePrettifier->prettifyTestMethod('testFooForBarIs0'));
-        $this->assertEquals('Foo for baz is 1', $this->namePrettifier->prettifyTestMethod('testFooForBazIs1'));
-        $this->assertEquals('', $this->namePrettifier->prettifyTestMethod('test'));
-    }
+	public function testTestNameIsConvertedToASentence()
+	{
+		$this->assertEquals('This is a test', $this->namePrettifier->prettifyTestMethod('testThisIsATest'));
+		$this->assertEquals('This is a test', $this->namePrettifier->prettifyTestMethod('testThisIsATest2'));
+		$this->assertEquals('This is a test', $this->namePrettifier->prettifyTestMethod('this_is_a_test'));
+		$this->assertEquals('Foo for bar is 0', $this->namePrettifier->prettifyTestMethod('testFooForBarIs0'));
+		$this->assertEquals('Foo for baz is 1', $this->namePrettifier->prettifyTestMethod('testFooForBazIs1'));
+		$this->assertEquals('', $this->namePrettifier->prettifyTestMethod('test'));
+	}
 
-    /**
-     * @ticket 224
-     */
-    public function testTestNameIsNotGroupedWhenNotInSequence()
-    {
-        $this->assertEquals('Sets redirect header on 301', $this->namePrettifier->prettifyTestMethod('testSetsRedirectHeaderOn301'));
-        $this->assertEquals('Sets redirect header on 302', $this->namePrettifier->prettifyTestMethod('testSetsRedirectHeaderOn302'));
-    }
+	/**
+	 * @ticket 224
+	 */
+	public function testTestNameIsNotGroupedWhenNotInSequence()
+	{
+		$this->assertEquals('Sets redirect header on 301', $this->namePrettifier->prettifyTestMethod('testSetsRedirectHeaderOn301'));
+		$this->assertEquals('Sets redirect header on 302', $this->namePrettifier->prettifyTestMethod('testSetsRedirectHeaderOn302'));
+	}
 }

vendor/phpunit/phpunit/tests/Util/GlobalStateTest.php

Indentation +18 added lines, -18 removed lines

@@ -14,23 +14,23 @@
 
 class GlobalStateTest extends TestCase
 {
-    public function testIncludedFilesAsStringSkipsVfsProtocols()
-    {
-        $dir   = __DIR__;
-        $files = [
-            'phpunit', // The 0 index is not used
-            $dir . '/ConfigurationTest.php',
-            $dir . '/GlobalStateTest.php',
-            'vfs://' . $dir . '/RegexTest.php',
-            'phpvfs53e46260465c7://' . $dir . '/TestTest.php',
-            'file://' . $dir . '/XmlTest.php'
-        ];
+	public function testIncludedFilesAsStringSkipsVfsProtocols()
+	{
+		$dir   = __DIR__;
+		$files = [
+			'phpunit', // The 0 index is not used
+			$dir . '/ConfigurationTest.php',
+			$dir . '/GlobalStateTest.php',
+			'vfs://' . $dir . '/RegexTest.php',
+			'phpvfs53e46260465c7://' . $dir . '/TestTest.php',
+			'file://' . $dir . '/XmlTest.php'
+		];
 
-        $this->assertEquals(
-            "require_once '" . $dir . "/ConfigurationTest.php';\n" .
-            "require_once '" . $dir . "/GlobalStateTest.php';\n" .
-            "require_once 'file://" . $dir . "/XmlTest.php';\n",
-            GlobalState::processIncludedFilesAsString($files)
-        );
-    }
+		$this->assertEquals(
+			"require_once '" . $dir . "/ConfigurationTest.php';\n" .
+			"require_once '" . $dir . "/GlobalStateTest.php';\n" .
+			"require_once 'file://" . $dir . "/XmlTest.php';\n",
+			GlobalState::processIncludedFilesAsString($files)
+		);
+	}
 }

Spacing +8 added lines, -8 removed lines

@@ -19,17 +19,17 @@
         $dir   = __DIR__;
         $files = [
             'phpunit', // The 0 index is not used
-            $dir . '/ConfigurationTest.php',
-            $dir . '/GlobalStateTest.php',
-            'vfs://' . $dir . '/RegexTest.php',
-            'phpvfs53e46260465c7://' . $dir . '/TestTest.php',
-            'file://' . $dir . '/XmlTest.php'
+            $dir.'/ConfigurationTest.php',
+            $dir.'/GlobalStateTest.php',
+            'vfs://'.$dir.'/RegexTest.php',
+            'phpvfs53e46260465c7://'.$dir.'/TestTest.php',
+            'file://'.$dir.'/XmlTest.php'
         ];
 
         $this->assertEquals(
-            "require_once '" . $dir . "/ConfigurationTest.php';\n" .
-            "require_once '" . $dir . "/GlobalStateTest.php';\n" .
-            "require_once 'file://" . $dir . "/XmlTest.php';\n",
+            "require_once '".$dir."/ConfigurationTest.php';\n".
+            "require_once '".$dir."/GlobalStateTest.php';\n".
+            "require_once 'file://".$dir."/XmlTest.php';\n",
             GlobalState::processIncludedFilesAsString($files)
         );
     }

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

Indentation +948 added lines, -948 removed lines

@@ -18,985 +18,985 @@
 
 class TestTest extends TestCase
 {
-    /**
-     * @todo Split up in separate tests
-     */
-    public function testGetExpectedException()
-    {
-        $this->assertArraySubset(
-            ['class' => 'FooBarBaz', 'code' => null, 'message' => ''],
-            Test::getExpectedException(\ExceptionTest::class, 'testOne')
-        );
-
-        $this->assertArraySubset(
-            ['class' => 'Foo_Bar_Baz', 'code' => null, 'message' => ''],
-            Test::getExpectedException(\ExceptionTest::class, 'testTwo')
-        );
-
-        $this->assertArraySubset(
-            ['class' => \Foo\Bar\Baz::class, 'code' => null, 'message' => ''],
-            Test::getExpectedException(\ExceptionTest::class, 'testThree')
-        );
-
-        $this->assertArraySubset(
-            ['class' => 'ほげ', 'code' => null, 'message' => ''],
-            Test::getExpectedException(\ExceptionTest::class, 'testFour')
-        );
-
-        $this->assertArraySubset(
-            ['class' => 'Class', 'code' => 1234, 'message' => 'Message'],
-            Test::getExpectedException(\ExceptionTest::class, 'testFive')
-        );
-
-        $this->assertArraySubset(
-            ['class' => 'Class', 'code' => 1234, 'message' => 'Message'],
-            Test::getExpectedException(\ExceptionTest::class, 'testSix')
-        );
-
-        $this->assertArraySubset(
-            ['class' => 'Class', 'code' => 'ExceptionCode', 'message' => 'Message'],
-            Test::getExpectedException(\ExceptionTest::class, 'testSeven')
-        );
-
-        $this->assertArraySubset(
-            ['class' => 'Class', 'code' => 0, 'message' => 'Message'],
-            Test::getExpectedException(\ExceptionTest::class, 'testEight')
-        );
-
-        $this->assertArraySubset(
-            ['class' => 'Class', 'code' => \ExceptionTest::ERROR_CODE, 'message' => \ExceptionTest::ERROR_MESSAGE],
-            Test::getExpectedException(\ExceptionTest::class, 'testNine')
-        );
-
-        $this->assertArraySubset(
-            ['class' => 'Class', 'code' => null, 'message' => ''],
-            Test::getExpectedException(\ExceptionTest::class, 'testSingleLine')
-        );
-
-        $this->assertArraySubset(
-            ['class' => 'Class', 'code' => \My\Space\ExceptionNamespaceTest::ERROR_CODE, 'message' => \My\Space\ExceptionNamespaceTest::ERROR_MESSAGE],
-            Test::getExpectedException(\My\Space\ExceptionNamespaceTest::class, 'testConstants')
-        );
-
-        // Ensure the Class::CONST expression is only evaluated when the constant really exists
-        $this->assertArraySubset(
-            ['class' => 'Class', 'code' => 'ExceptionTest::UNKNOWN_CODE_CONSTANT', 'message' => 'ExceptionTest::UNKNOWN_MESSAGE_CONSTANT'],
-            Test::getExpectedException(\ExceptionTest::class, 'testUnknownConstants')
-        );
-
-        $this->assertArraySubset(
-            ['class' => 'Class', 'code' => 'My\Space\ExceptionNamespaceTest::UNKNOWN_CODE_CONSTANT', 'message' => 'My\Space\ExceptionNamespaceTest::UNKNOWN_MESSAGE_CONSTANT'],
-            Test::getExpectedException(\My\Space\ExceptionNamespaceTest::class, 'testUnknownConstants')
-        );
-    }
-
-    public function testGetExpectedRegExp()
-    {
-        $this->assertArraySubset(
-            ['message_regex' => '#regex#'],
-            Test::getExpectedException(\ExceptionTest::class, 'testWithRegexMessage')
-        );
-
-        $this->assertArraySubset(
-            ['message_regex' => '#regex#'],
-            Test::getExpectedException(\ExceptionTest::class, 'testWithRegexMessageFromClassConstant')
-        );
-
-        $this->assertArraySubset(
-            ['message_regex' => 'ExceptionTest::UNKNOWN_MESSAGE_REGEX_CONSTANT'],
-            Test::getExpectedException(\ExceptionTest::class, 'testWithUnknowRegexMessageFromClassConstant')
-        );
-    }
-
-    /**
-     * @dataProvider requirementsProvider
-     */
-    public function testGetRequirements($test, $result)
-    {
-        $this->assertEquals(
-            $result,
-            Test::getRequirements(\RequirementsTest::class, $test)
-        );
-    }
-
-    public function requirementsProvider()
-    {
-        return [
-            ['testOne',    []],
-            ['testTwo',    ['PHPUnit'    => ['version' => '1.0', 'operator' => '']]],
-            ['testThree',  ['PHP'        => ['version' => '2.0', 'operator' => '']]],
-            ['testFour',   [
-                'PHPUnit'    => ['version' => '2.0', 'operator' => ''],
-                'PHP'        => ['version' => '1.0', 'operator' => ''],
-            ]],
-            ['testFive',   ['PHP'        => ['version' => '5.4.0RC6', 'operator' => '']]],
-            ['testSix',    ['PHP'        => ['version' => '5.4.0-alpha1', 'operator' => '']]],
-            ['testSeven',  ['PHP'        => ['version' => '5.4.0beta2', 'operator' => '']]],
-            ['testEight',  ['PHP'        => ['version' => '5.4-dev', 'operator' => '']]],
-            ['testNine',   ['functions'  => ['testFunc']]],
-            ['testTen',    ['extensions' => ['testExt']]],
-            ['testEleven', [
-                'OS'         => 'SunOS',
-                'OSFAMILY'   => 'Solaris',
-            ]],
-            [
-                'testSpace',
-                [
-                    'extensions' => ['spl'],
-                    'OS'         => '.*',
-                ],
-            ],
-            [
-                'testAllPossibleRequirements',
-                [
-                    'PHP'       => ['version' => '99-dev', 'operator' => ''],
-                    'PHPUnit'   => ['version' => '9-dev', 'operator' => ''],
-                    'OS'        => 'DOESNOTEXIST',
-                    'functions' => [
-                        'testFuncOne',
-                        'testFuncTwo',
-                    ],
-                    'extensions' => [
-                        'testExtOne',
-                        'testExtTwo',
-                        'testExtThree',
-                    ],
-                    'extension_versions' => [
-                        'testExtThree' => ['version' => '2.0', 'operator' => ''],
-                    ],
-                ],
-            ],
-            ['testSpecificExtensionVersion',
-                [
-                    'extension_versions' => ['testExt' => ['version' => '1.8.0', 'operator' => '']],
-                    'extensions'         => ['testExt']
-                ]
-            ],
-            ['testPHPVersionOperatorLessThan',
-                [
-                    'PHP' => ['version' => '5.4', 'operator' => '<']
-                ]
-            ],
-            ['testPHPVersionOperatorLessThanEquals',
-                [
-                    'PHP' => ['version' => '5.4', 'operator' => '<=']
-                ]
-            ],
-            ['testPHPVersionOperatorGreaterThan',
-                [
-                    'PHP' => ['version' => '99', 'operator' => '>']
-                ]
-            ],
-            ['testPHPVersionOperatorGreaterThanEquals',
-                [
-                    'PHP' => ['version' => '99', 'operator' => '>=']
-                ]
-            ],
-            ['testPHPVersionOperatorEquals',
-                [
-                    'PHP' => ['version' => '5.4', 'operator' => '=']
-                ]
-            ],
-            ['testPHPVersionOperatorDoubleEquals',
-                [
-                    'PHP' => ['version' => '5.4', 'operator' => '==']
-                ]
-            ],
-            ['testPHPVersionOperatorBangEquals',
-                [
-                    'PHP' => ['version' => '99', 'operator' => '!=']
-                ]
-            ],
-            ['testPHPVersionOperatorNotEquals',
-                [
-                    'PHP' => ['version' => '99', 'operator' => '<>']
-                ]
-            ],
-            ['testPHPVersionOperatorNoSpace',
-                [
-                    'PHP' => ['version' => '99', 'operator' => '>=']
-                ]
-            ],
-            ['testPHPUnitVersionOperatorLessThan',
-                [
-                    'PHPUnit' => ['version' => '1.0', 'operator' => '<']
-                ]
-            ],
-            ['testPHPUnitVersionOperatorLessThanEquals',
-                [
-                    'PHPUnit' => ['version' => '1.0', 'operator' => '<=']
-                ]
-            ],
-            ['testPHPUnitVersionOperatorGreaterThan',
-                [
-                    'PHPUnit' => ['version' => '99', 'operator' => '>']
-                ]
-            ],
-            ['testPHPUnitVersionOperatorGreaterThanEquals',
-                [
-                    'PHPUnit' => ['version' => '99', 'operator' => '>=']
-                ]
-            ],
-            ['testPHPUnitVersionOperatorEquals',
-                [
-                    'PHPUnit' => ['version' => '1.0', 'operator' => '=']
-                ]
-            ],
-            ['testPHPUnitVersionOperatorDoubleEquals',
-                [
-                    'PHPUnit' => ['version' => '1.0', 'operator' => '==']
-                ]
-            ],
-            ['testPHPUnitVersionOperatorBangEquals',
-                [
-                    'PHPUnit' => ['version' => '99', 'operator' => '!=']
-                ]
-            ],
-            ['testPHPUnitVersionOperatorNotEquals',
-                [
-                    'PHPUnit' => ['version' => '99', 'operator' => '<>']
-                ]
-            ],
-            ['testPHPUnitVersionOperatorNoSpace',
-                [
-                    'PHPUnit' => ['version' => '99', 'operator' => '>=']
-                ]
-            ],
-            ['testExtensionVersionOperatorLessThanEquals',
-                [
-                    'extensions'         => ['testExtOne'],
-                    'extension_versions' => ['testExtOne' => ['version' => '1.0', 'operator' => '<=']]
-                ]
-            ],
-            ['testExtensionVersionOperatorGreaterThan',
-                [
-                    'extensions'         => ['testExtOne'],
-                    'extension_versions' => ['testExtOne' => ['version' => '99', 'operator' => '>']]
-                ]
-            ],
-            ['testExtensionVersionOperatorGreaterThanEquals',
-                [
-                    'extensions'         => ['testExtOne'],
-                    'extension_versions' => ['testExtOne' => ['version' => '99', 'operator' => '>=']]
-                ]
-            ],
-            ['testExtensionVersionOperatorEquals',
-                [
-                    'extensions'         => ['testExtOne'],
-                    'extension_versions' => ['testExtOne' => ['version' => '1.0', 'operator' => '=']]
-                ]
-            ],
-            ['testExtensionVersionOperatorDoubleEquals',
-                [
-                    'extensions'         => ['testExtOne'],
-                    'extension_versions' => ['testExtOne' => ['version' => '1.0', 'operator' => '==']]
-                ]
-            ],
-            ['testExtensionVersionOperatorBangEquals',
-                [
-                    'extensions'         => ['testExtOne'],
-                    'extension_versions' => ['testExtOne' => ['version' => '99', 'operator' => '!=']]
-                ]
-            ],
-            ['testExtensionVersionOperatorNotEquals',
-                [
-                    'extensions'         => ['testExtOne'],
-                    'extension_versions' => ['testExtOne' => ['version' => '99', 'operator' => '<>']]
-                ]
-            ],
-            ['testExtensionVersionOperatorNoSpace',
-                [
-                    'extensions'         => ['testExtOne'],
-                    'extension_versions' => ['testExtOne' => ['version' => '99', 'operator' => '>=']]
-                ]
-            ]
-        ];
-    }
-
-    /**
-     * @dataProvider requirementsWithVersionConstraintsProvider
-     */
-    public function testGetRequirementsWithVersionConstraints($test, array $result)
-    {
-        $requirements = Test::getRequirements(\RequirementsTest::class, $test);
-        foreach ($result as $type => $expected_requirement) {
-            $this->assertArrayHasKey(
-                "{$type}_constraint",
-                $requirements
-            );
-            $this->assertArrayHasKey(
-                'constraint',
-                $requirements["{$type}_constraint"]
-            );
-            $this->assertInstanceOf(
-                VersionConstraint::class,
-                $requirements["{$type}_constraint"]['constraint']
-            );
-            $this->assertSame(
-                $expected_requirement['constraint'],
-                $requirements["{$type}_constraint"]['constraint']->asString()
-            );
-        }
-    }
-
-    public function requirementsWithVersionConstraintsProvider()
-    {
-        return [
-            [
-                'testVersionConstraintTildeMajor',
-                [
-                    'PHP' => [
-                        'constraint' => '~1.0'
-                    ],
-                    'PHPUnit' => [
-                        'constraint' => '~2.0'
-                    ]
-                ]
-            ],
-            [
-                'testVersionConstraintCaretMajor',
-                [
-                    'PHP' => [
-                        'constraint' => '^1.0'
-                    ],
-                    'PHPUnit' => [
-                        'constraint' => '^2.0'
-                    ]
-                ]
-            ],
-            [
-                'testVersionConstraintTildeMinor',
-                [
-                    'PHP' => [
-                        'constraint' => '~3.4.7'
-                    ],
-                    'PHPUnit' => [
-                        'constraint' => '~4.7.1'
-                    ]
-                ]
-            ],
-            [
-                'testVersionConstraintCaretMinor',
-                [
-                    'PHP' => [
-                        'constraint' => '^7.0.17'
-                    ],
-                    'PHPUnit' => [
-                        'constraint' => '^4.7.1'
-                    ]
-                ]
-            ],
-            [
-                'testVersionConstraintCaretOr',
-                [
-                    'PHP' => [
-                        'constraint' => '^5.6 || ^7.0'
-                    ],
-                    'PHPUnit' => [
-                        'constraint' => '^5.0 || ^6.0'
-                    ]
-                ]
-            ],
-            [
-                'testVersionConstraintTildeOr',
-                [
-                    'PHP' => [
-                        'constraint' => '~5.6.22 || ~7.0.17'
-                    ],
-                    'PHPUnit' => [
-                        'constraint' => '^5.0.5 || ^6.0.6'
-                    ]
-                ]
-            ],
-            [
-                'testVersionConstraintTildeOrCaret',
-                [
-                    'PHP' => [
-                        'constraint' => '~5.6.22 || ^7.0'
-                    ],
-                    'PHPUnit' => [
-                        'constraint' => '~5.6.22 || ^7.0'
-                    ]
-                ]
-            ],
-            [
-                'testVersionConstraintCaretOrTilde',
-                [
-                    'PHP' => [
-                        'constraint' => '^5.6 || ~7.0.17'
-                    ],
-                    'PHPUnit' => [
-                        'constraint' => '^5.6 || ~7.0.17'
-                    ]
-                ]
-            ],
-            [
-                'testVersionConstraintRegexpIgnoresWhitespace',
-                [
-                    'PHP' => [
-                        'constraint' => '~5.6.22 || ~7.0.17'
-                    ],
-                    'PHPUnit' => [
-                        'constraint' => '~5.6.22 || ~7.0.17'
-                    ]
-                ]
-            ]
-        ];
-    }
-
-    /**
-     * @dataProvider requirementsWithInvalidVersionConstraintsThrowsExceptionProvider
-     */
-    public function testGetRequirementsWithInvalidVersionConstraintsThrowsException($test)
-    {
-        $this->expectException(Warning::class);
-        Test::getRequirements(\RequirementsTest::class, $test);
-    }
-
-    public function requirementsWithInvalidVersionConstraintsThrowsExceptionProvider()
-    {
-        return [
-            ['testVersionConstraintInvalidPhpConstraint'],
-            ['testVersionConstraintInvalidPhpUnitConstraint']
-        ];
-    }
-
-    public function testGetRequirementsMergesClassAndMethodDocBlocks()
-    {
-        $expectedAnnotations = [
-            'PHP'       => ['version' => '5.4', 'operator' => ''],
-            'PHPUnit'   => ['version' => '3.7', 'operator' => ''],
-            'OS'        => 'WINNT',
-            'functions' => [
-              'testFuncClass',
-              'testFuncMethod',
-            ],
-            'extensions' => [
-              'testExtClass',
-              'testExtMethod',
-            ]
-        ];
-
-        $this->assertEquals(
-            $expectedAnnotations,
-            Test::getRequirements(\RequirementsClassDocBlockTest::class, 'testMethod')
-        );
-    }
-
-    /**
-     * @dataProvider missingRequirementsProvider
-     */
-    public function testGetMissingRequirements($test, $result)
-    {
-        $this->assertEquals(
-            $result,
-            Test::getMissingRequirements(\RequirementsTest::class, $test)
-        );
-    }
-
-    public function missingRequirementsProvider()
-    {
-        return [
-            ['testOne',            []],
-            ['testNine',           ['Function testFunc is required.']],
-            ['testTen',            ['Extension testExt is required.']],
-            ['testAlwaysSkip',     ['PHPUnit >= 1111111 is required.']],
-            ['testAlwaysSkip2',    ['PHP >= 9999999 is required.']],
-            ['testAlwaysSkip3',    ['Operating system matching /DOESNOTEXIST/i is required.']],
-            ['testAllPossibleRequirements', [
-              'PHP >= 99-dev is required.',
-              'PHPUnit >= 9-dev is required.',
-              'Operating system matching /DOESNOTEXIST/i is required.',
-              'Function testFuncOne is required.',
-              'Function testFuncTwo is required.',
-              'Extension testExtOne is required.',
-              'Extension testExtTwo is required.',
-              'Extension testExtThree >= 2.0 is required.',
-            ]],
-            ['testPHPVersionOperatorLessThan', ['PHP < 5.4 is required.']],
-            ['testPHPVersionOperatorLessThanEquals', ['PHP <= 5.4 is required.']],
-            ['testPHPVersionOperatorGreaterThan', ['PHP > 99 is required.']],
-            ['testPHPVersionOperatorGreaterThanEquals', ['PHP >= 99 is required.']],
-            ['testPHPVersionOperatorNoSpace', ['PHP >= 99 is required.']],
-            ['testPHPVersionOperatorEquals', ['PHP = 5.4 is required.']],
-            ['testPHPVersionOperatorDoubleEquals', ['PHP == 5.4 is required.']],
-            ['testPHPUnitVersionOperatorLessThan', ['PHPUnit < 1.0 is required.']],
-            ['testPHPUnitVersionOperatorLessThanEquals', ['PHPUnit <= 1.0 is required.']],
-            ['testPHPUnitVersionOperatorGreaterThan', ['PHPUnit > 99 is required.']],
-            ['testPHPUnitVersionOperatorGreaterThanEquals', ['PHPUnit >= 99 is required.']],
-            ['testPHPUnitVersionOperatorEquals', ['PHPUnit = 1.0 is required.']],
-            ['testPHPUnitVersionOperatorDoubleEquals', ['PHPUnit == 1.0 is required.']],
-            ['testPHPUnitVersionOperatorNoSpace', ['PHPUnit >= 99 is required.']],
-            ['testExtensionVersionOperatorLessThan', ['Extension testExtOne < 1.0 is required.']],
-            ['testExtensionVersionOperatorLessThanEquals', ['Extension testExtOne <= 1.0 is required.']],
-            ['testExtensionVersionOperatorGreaterThan', ['Extension testExtOne > 99 is required.']],
-            ['testExtensionVersionOperatorGreaterThanEquals', ['Extension testExtOne >= 99 is required.']],
-            ['testExtensionVersionOperatorEquals', ['Extension testExtOne = 1.0 is required.']],
-            ['testExtensionVersionOperatorDoubleEquals', ['Extension testExtOne == 1.0 is required.']],
-            ['testExtensionVersionOperatorNoSpace', ['Extension testExtOne >= 99 is required.']],
-            ['testVersionConstraintTildeMajor', [
-                'PHP version does not match the required constraint ~1.0.',
-                'PHPUnit version does not match the required constraint ~2.0.'
-            ]],
-            ['testVersionConstraintCaretMajor', [
-                'PHP version does not match the required constraint ^1.0.',
-                'PHPUnit version does not match the required constraint ^2.0.'
-            ]]
-        ];
-    }
-
-    /**
-     * @todo   This test does not really test functionality of \PHPUnit\Util\Test
-     */
-    public function testGetProvidedDataRegEx()
-    {
-        $result = \preg_match(Test::REGEX_DATA_PROVIDER, '@dataProvider method', $matches);
-        $this->assertEquals(1, $result);
-        $this->assertEquals('method', $matches[1]);
-
-        $result = \preg_match(Test::REGEX_DATA_PROVIDER, '@dataProvider class::method', $matches);
-        $this->assertEquals(1, $result);
-        $this->assertEquals('class::method', $matches[1]);
-
-        $result = \preg_match(Test::REGEX_DATA_PROVIDER, '@dataProvider namespace\class::method', $matches);
-        $this->assertEquals(1, $result);
-        $this->assertEquals('namespace\class::method', $matches[1]);
-
-        $result = \preg_match(Test::REGEX_DATA_PROVIDER, '@dataProvider namespace\namespace\class::method', $matches);
-        $this->assertEquals(1, $result);
-        $this->assertEquals('namespace\namespace\class::method', $matches[1]);
-
-        $result = \preg_match(Test::REGEX_DATA_PROVIDER, '@dataProvider メソッド', $matches);
-        $this->assertEquals(1, $result);
-        $this->assertEquals('メソッド', $matches[1]);
-    }
-
-    /**
-     * Check if all data providers are being merged.
-     */
-    public function testMultipleDataProviders()
-    {
-        $dataSets = Test::getProvidedData(\MultipleDataProviderTest::class, 'testOne');
-
-        $this->assertCount(9, $dataSets);
-
-        $aCount = 0;
-        $bCount = 0;
-        $cCount = 0;
-
-        for ($i = 0; $i < 9; $i++) {
-            $aCount += $dataSets[$i][0] != null ? 1 : 0;
-            $bCount += $dataSets[$i][1] != null ? 1 : 0;
-            $cCount += $dataSets[$i][2] != null ? 1 : 0;
-        }
-
-        $this->assertEquals(3, $aCount);
-        $this->assertEquals(3, $bCount);
-        $this->assertEquals(3, $cCount);
-    }
-
-    public function testMultipleYieldIteratorDataProviders()
-    {
-        $dataSets = Test::getProvidedData(\MultipleDataProviderTest::class, 'testTwo');
-
-        $this->assertEquals(9, \count($dataSets));
-
-        $aCount = 0;
-        $bCount = 0;
-        $cCount = 0;
-
-        for ($i = 0; $i < 9; $i++) {
-            $aCount += $dataSets[$i][0] != null ? 1 : 0;
-            $bCount += $dataSets[$i][1] != null ? 1 : 0;
-            $cCount += $dataSets[$i][2] != null ? 1 : 0;
-        }
-
-        $this->assertEquals(3, $aCount);
-        $this->assertEquals(3, $bCount);
-        $this->assertEquals(3, $cCount);
-    }
-
-    public function testWithVariousIterableDataProviders()
-    {
-        $dataSets = Test::getProvidedData(\VariousIterableDataProviderTest::class, 'test');
-
-        $this->assertEquals([
-            ['A'],
-            ['B'],
-            ['C'],
-            ['D'],
-            ['E'],
-            ['F'],
-            ['G'],
-            ['H'],
-            ['I'],
-        ], $dataSets);
-    }
-
-    public function testTestWithEmptyAnnotation()
-    {
-        $result = Test::getDataFromTestWithAnnotation("/**\n * @anotherAnnotation\n */");
-        $this->assertNull($result);
-    }
-
-    public function testTestWithSimpleCase()
-    {
-        $result = Test::getDataFromTestWithAnnotation('/**
+	/**
+	 * @todo Split up in separate tests
+	 */
+	public function testGetExpectedException()
+	{
+		$this->assertArraySubset(
+			['class' => 'FooBarBaz', 'code' => null, 'message' => ''],
+			Test::getExpectedException(\ExceptionTest::class, 'testOne')
+		);
+
+		$this->assertArraySubset(
+			['class' => 'Foo_Bar_Baz', 'code' => null, 'message' => ''],
+			Test::getExpectedException(\ExceptionTest::class, 'testTwo')
+		);
+
+		$this->assertArraySubset(
+			['class' => \Foo\Bar\Baz::class, 'code' => null, 'message' => ''],
+			Test::getExpectedException(\ExceptionTest::class, 'testThree')
+		);
+
+		$this->assertArraySubset(
+			['class' => 'ほげ', 'code' => null, 'message' => ''],
+			Test::getExpectedException(\ExceptionTest::class, 'testFour')
+		);
+
+		$this->assertArraySubset(
+			['class' => 'Class', 'code' => 1234, 'message' => 'Message'],
+			Test::getExpectedException(\ExceptionTest::class, 'testFive')
+		);
+
+		$this->assertArraySubset(
+			['class' => 'Class', 'code' => 1234, 'message' => 'Message'],
+			Test::getExpectedException(\ExceptionTest::class, 'testSix')
+		);
+
+		$this->assertArraySubset(
+			['class' => 'Class', 'code' => 'ExceptionCode', 'message' => 'Message'],
+			Test::getExpectedException(\ExceptionTest::class, 'testSeven')
+		);
+
+		$this->assertArraySubset(
+			['class' => 'Class', 'code' => 0, 'message' => 'Message'],
+			Test::getExpectedException(\ExceptionTest::class, 'testEight')
+		);
+
+		$this->assertArraySubset(
+			['class' => 'Class', 'code' => \ExceptionTest::ERROR_CODE, 'message' => \ExceptionTest::ERROR_MESSAGE],
+			Test::getExpectedException(\ExceptionTest::class, 'testNine')
+		);
+
+		$this->assertArraySubset(
+			['class' => 'Class', 'code' => null, 'message' => ''],
+			Test::getExpectedException(\ExceptionTest::class, 'testSingleLine')
+		);
+
+		$this->assertArraySubset(
+			['class' => 'Class', 'code' => \My\Space\ExceptionNamespaceTest::ERROR_CODE, 'message' => \My\Space\ExceptionNamespaceTest::ERROR_MESSAGE],
+			Test::getExpectedException(\My\Space\ExceptionNamespaceTest::class, 'testConstants')
+		);
+
+		// Ensure the Class::CONST expression is only evaluated when the constant really exists
+		$this->assertArraySubset(
+			['class' => 'Class', 'code' => 'ExceptionTest::UNKNOWN_CODE_CONSTANT', 'message' => 'ExceptionTest::UNKNOWN_MESSAGE_CONSTANT'],
+			Test::getExpectedException(\ExceptionTest::class, 'testUnknownConstants')
+		);
+
+		$this->assertArraySubset(
+			['class' => 'Class', 'code' => 'My\Space\ExceptionNamespaceTest::UNKNOWN_CODE_CONSTANT', 'message' => 'My\Space\ExceptionNamespaceTest::UNKNOWN_MESSAGE_CONSTANT'],
+			Test::getExpectedException(\My\Space\ExceptionNamespaceTest::class, 'testUnknownConstants')
+		);
+	}
+
+	public function testGetExpectedRegExp()
+	{
+		$this->assertArraySubset(
+			['message_regex' => '#regex#'],
+			Test::getExpectedException(\ExceptionTest::class, 'testWithRegexMessage')
+		);
+
+		$this->assertArraySubset(
+			['message_regex' => '#regex#'],
+			Test::getExpectedException(\ExceptionTest::class, 'testWithRegexMessageFromClassConstant')
+		);
+
+		$this->assertArraySubset(
+			['message_regex' => 'ExceptionTest::UNKNOWN_MESSAGE_REGEX_CONSTANT'],
+			Test::getExpectedException(\ExceptionTest::class, 'testWithUnknowRegexMessageFromClassConstant')
+		);
+	}
+
+	/**
+	 * @dataProvider requirementsProvider
+	 */
+	public function testGetRequirements($test, $result)
+	{
+		$this->assertEquals(
+			$result,
+			Test::getRequirements(\RequirementsTest::class, $test)
+		);
+	}
+
+	public function requirementsProvider()
+	{
+		return [
+			['testOne',    []],
+			['testTwo',    ['PHPUnit'    => ['version' => '1.0', 'operator' => '']]],
+			['testThree',  ['PHP'        => ['version' => '2.0', 'operator' => '']]],
+			['testFour',   [
+				'PHPUnit'    => ['version' => '2.0', 'operator' => ''],
+				'PHP'        => ['version' => '1.0', 'operator' => ''],
+			]],
+			['testFive',   ['PHP'        => ['version' => '5.4.0RC6', 'operator' => '']]],
+			['testSix',    ['PHP'        => ['version' => '5.4.0-alpha1', 'operator' => '']]],
+			['testSeven',  ['PHP'        => ['version' => '5.4.0beta2', 'operator' => '']]],
+			['testEight',  ['PHP'        => ['version' => '5.4-dev', 'operator' => '']]],
+			['testNine',   ['functions'  => ['testFunc']]],
+			['testTen',    ['extensions' => ['testExt']]],
+			['testEleven', [
+				'OS'         => 'SunOS',
+				'OSFAMILY'   => 'Solaris',
+			]],
+			[
+				'testSpace',
+				[
+					'extensions' => ['spl'],
+					'OS'         => '.*',
+				],
+			],
+			[
+				'testAllPossibleRequirements',
+				[
+					'PHP'       => ['version' => '99-dev', 'operator' => ''],
+					'PHPUnit'   => ['version' => '9-dev', 'operator' => ''],
+					'OS'        => 'DOESNOTEXIST',
+					'functions' => [
+						'testFuncOne',
+						'testFuncTwo',
+					],
+					'extensions' => [
+						'testExtOne',
+						'testExtTwo',
+						'testExtThree',
+					],
+					'extension_versions' => [
+						'testExtThree' => ['version' => '2.0', 'operator' => ''],
+					],
+				],
+			],
+			['testSpecificExtensionVersion',
+				[
+					'extension_versions' => ['testExt' => ['version' => '1.8.0', 'operator' => '']],
+					'extensions'         => ['testExt']
+				]
+			],
+			['testPHPVersionOperatorLessThan',
+				[
+					'PHP' => ['version' => '5.4', 'operator' => '<']
+				]
+			],
+			['testPHPVersionOperatorLessThanEquals',
+				[
+					'PHP' => ['version' => '5.4', 'operator' => '<=']
+				]
+			],
+			['testPHPVersionOperatorGreaterThan',
+				[
+					'PHP' => ['version' => '99', 'operator' => '>']
+				]
+			],
+			['testPHPVersionOperatorGreaterThanEquals',
+				[
+					'PHP' => ['version' => '99', 'operator' => '>=']
+				]
+			],
+			['testPHPVersionOperatorEquals',
+				[
+					'PHP' => ['version' => '5.4', 'operator' => '=']
+				]
+			],
+			['testPHPVersionOperatorDoubleEquals',
+				[
+					'PHP' => ['version' => '5.4', 'operator' => '==']
+				]
+			],
+			['testPHPVersionOperatorBangEquals',
+				[
+					'PHP' => ['version' => '99', 'operator' => '!=']
+				]
+			],
+			['testPHPVersionOperatorNotEquals',
+				[
+					'PHP' => ['version' => '99', 'operator' => '<>']
+				]
+			],
+			['testPHPVersionOperatorNoSpace',
+				[
+					'PHP' => ['version' => '99', 'operator' => '>=']
+				]
+			],
+			['testPHPUnitVersionOperatorLessThan',
+				[
+					'PHPUnit' => ['version' => '1.0', 'operator' => '<']
+				]
+			],
+			['testPHPUnitVersionOperatorLessThanEquals',
+				[
+					'PHPUnit' => ['version' => '1.0', 'operator' => '<=']
+				]
+			],
+			['testPHPUnitVersionOperatorGreaterThan',
+				[
+					'PHPUnit' => ['version' => '99', 'operator' => '>']
+				]
+			],
+			['testPHPUnitVersionOperatorGreaterThanEquals',
+				[
+					'PHPUnit' => ['version' => '99', 'operator' => '>=']
+				]
+			],
+			['testPHPUnitVersionOperatorEquals',
+				[
+					'PHPUnit' => ['version' => '1.0', 'operator' => '=']
+				]
+			],
+			['testPHPUnitVersionOperatorDoubleEquals',
+				[
+					'PHPUnit' => ['version' => '1.0', 'operator' => '==']
+				]
+			],
+			['testPHPUnitVersionOperatorBangEquals',
+				[
+					'PHPUnit' => ['version' => '99', 'operator' => '!=']
+				]
+			],
+			['testPHPUnitVersionOperatorNotEquals',
+				[
+					'PHPUnit' => ['version' => '99', 'operator' => '<>']
+				]
+			],
+			['testPHPUnitVersionOperatorNoSpace',
+				[
+					'PHPUnit' => ['version' => '99', 'operator' => '>=']
+				]
+			],
+			['testExtensionVersionOperatorLessThanEquals',
+				[
+					'extensions'         => ['testExtOne'],
+					'extension_versions' => ['testExtOne' => ['version' => '1.0', 'operator' => '<=']]
+				]
+			],
+			['testExtensionVersionOperatorGreaterThan',
+				[
+					'extensions'         => ['testExtOne'],
+					'extension_versions' => ['testExtOne' => ['version' => '99', 'operator' => '>']]
+				]
+			],
+			['testExtensionVersionOperatorGreaterThanEquals',
+				[
+					'extensions'         => ['testExtOne'],
+					'extension_versions' => ['testExtOne' => ['version' => '99', 'operator' => '>=']]
+				]
+			],
+			['testExtensionVersionOperatorEquals',
+				[
+					'extensions'         => ['testExtOne'],
+					'extension_versions' => ['testExtOne' => ['version' => '1.0', 'operator' => '=']]
+				]
+			],
+			['testExtensionVersionOperatorDoubleEquals',
+				[
+					'extensions'         => ['testExtOne'],
+					'extension_versions' => ['testExtOne' => ['version' => '1.0', 'operator' => '==']]
+				]
+			],
+			['testExtensionVersionOperatorBangEquals',
+				[
+					'extensions'         => ['testExtOne'],
+					'extension_versions' => ['testExtOne' => ['version' => '99', 'operator' => '!=']]
+				]
+			],
+			['testExtensionVersionOperatorNotEquals',
+				[
+					'extensions'         => ['testExtOne'],
+					'extension_versions' => ['testExtOne' => ['version' => '99', 'operator' => '<>']]
+				]
+			],
+			['testExtensionVersionOperatorNoSpace',
+				[
+					'extensions'         => ['testExtOne'],
+					'extension_versions' => ['testExtOne' => ['version' => '99', 'operator' => '>=']]
+				]
+			]
+		];
+	}
+
+	/**
+	 * @dataProvider requirementsWithVersionConstraintsProvider
+	 */
+	public function testGetRequirementsWithVersionConstraints($test, array $result)
+	{
+		$requirements = Test::getRequirements(\RequirementsTest::class, $test);
+		foreach ($result as $type => $expected_requirement) {
+			$this->assertArrayHasKey(
+				"{$type}_constraint",
+				$requirements
+			);
+			$this->assertArrayHasKey(
+				'constraint',
+				$requirements["{$type}_constraint"]
+			);
+			$this->assertInstanceOf(
+				VersionConstraint::class,
+				$requirements["{$type}_constraint"]['constraint']
+			);
+			$this->assertSame(
+				$expected_requirement['constraint'],
+				$requirements["{$type}_constraint"]['constraint']->asString()
+			);
+		}
+	}
+
+	public function requirementsWithVersionConstraintsProvider()
+	{
+		return [
+			[
+				'testVersionConstraintTildeMajor',
+				[
+					'PHP' => [
+						'constraint' => '~1.0'
+					],
+					'PHPUnit' => [
+						'constraint' => '~2.0'
+					]
+				]
+			],
+			[
+				'testVersionConstraintCaretMajor',
+				[
+					'PHP' => [
+						'constraint' => '^1.0'
+					],
+					'PHPUnit' => [
+						'constraint' => '^2.0'
+					]
+				]
+			],
+			[
+				'testVersionConstraintTildeMinor',
+				[
+					'PHP' => [
+						'constraint' => '~3.4.7'
+					],
+					'PHPUnit' => [
+						'constraint' => '~4.7.1'
+					]
+				]
+			],
+			[
+				'testVersionConstraintCaretMinor',
+				[
+					'PHP' => [
+						'constraint' => '^7.0.17'
+					],
+					'PHPUnit' => [
+						'constraint' => '^4.7.1'
+					]
+				]
+			],
+			[
+				'testVersionConstraintCaretOr',
+				[
+					'PHP' => [
+						'constraint' => '^5.6 || ^7.0'
+					],
+					'PHPUnit' => [
+						'constraint' => '^5.0 || ^6.0'
+					]
+				]
+			],
+			[
+				'testVersionConstraintTildeOr',
+				[
+					'PHP' => [
+						'constraint' => '~5.6.22 || ~7.0.17'
+					],
+					'PHPUnit' => [
+						'constraint' => '^5.0.5 || ^6.0.6'
+					]
+				]
+			],
+			[
+				'testVersionConstraintTildeOrCaret',
+				[
+					'PHP' => [
+						'constraint' => '~5.6.22 || ^7.0'
+					],
+					'PHPUnit' => [
+						'constraint' => '~5.6.22 || ^7.0'
+					]
+				]
+			],
+			[
+				'testVersionConstraintCaretOrTilde',
+				[
+					'PHP' => [
+						'constraint' => '^5.6 || ~7.0.17'
+					],
+					'PHPUnit' => [
+						'constraint' => '^5.6 || ~7.0.17'
+					]
+				]
+			],
+			[
+				'testVersionConstraintRegexpIgnoresWhitespace',
+				[
+					'PHP' => [
+						'constraint' => '~5.6.22 || ~7.0.17'
+					],
+					'PHPUnit' => [
+						'constraint' => '~5.6.22 || ~7.0.17'
+					]
+				]
+			]
+		];
+	}
+
+	/**
+	 * @dataProvider requirementsWithInvalidVersionConstraintsThrowsExceptionProvider
+	 */
+	public function testGetRequirementsWithInvalidVersionConstraintsThrowsException($test)
+	{
+		$this->expectException(Warning::class);
+		Test::getRequirements(\RequirementsTest::class, $test);
+	}
+
+	public function requirementsWithInvalidVersionConstraintsThrowsExceptionProvider()
+	{
+		return [
+			['testVersionConstraintInvalidPhpConstraint'],
+			['testVersionConstraintInvalidPhpUnitConstraint']
+		];
+	}
+
+	public function testGetRequirementsMergesClassAndMethodDocBlocks()
+	{
+		$expectedAnnotations = [
+			'PHP'       => ['version' => '5.4', 'operator' => ''],
+			'PHPUnit'   => ['version' => '3.7', 'operator' => ''],
+			'OS'        => 'WINNT',
+			'functions' => [
+			  'testFuncClass',
+			  'testFuncMethod',
+			],
+			'extensions' => [
+			  'testExtClass',
+			  'testExtMethod',
+			]
+		];
+
+		$this->assertEquals(
+			$expectedAnnotations,
+			Test::getRequirements(\RequirementsClassDocBlockTest::class, 'testMethod')
+		);
+	}
+
+	/**
+	 * @dataProvider missingRequirementsProvider
+	 */
+	public function testGetMissingRequirements($test, $result)
+	{
+		$this->assertEquals(
+			$result,
+			Test::getMissingRequirements(\RequirementsTest::class, $test)
+		);
+	}
+
+	public function missingRequirementsProvider()
+	{
+		return [
+			['testOne',            []],
+			['testNine',           ['Function testFunc is required.']],
+			['testTen',            ['Extension testExt is required.']],
+			['testAlwaysSkip',     ['PHPUnit >= 1111111 is required.']],
+			['testAlwaysSkip2',    ['PHP >= 9999999 is required.']],
+			['testAlwaysSkip3',    ['Operating system matching /DOESNOTEXIST/i is required.']],
+			['testAllPossibleRequirements', [
+			  'PHP >= 99-dev is required.',
+			  'PHPUnit >= 9-dev is required.',
+			  'Operating system matching /DOESNOTEXIST/i is required.',
+			  'Function testFuncOne is required.',
+			  'Function testFuncTwo is required.',
+			  'Extension testExtOne is required.',
+			  'Extension testExtTwo is required.',
+			  'Extension testExtThree >= 2.0 is required.',
+			]],
+			['testPHPVersionOperatorLessThan', ['PHP < 5.4 is required.']],
+			['testPHPVersionOperatorLessThanEquals', ['PHP <= 5.4 is required.']],
+			['testPHPVersionOperatorGreaterThan', ['PHP > 99 is required.']],
+			['testPHPVersionOperatorGreaterThanEquals', ['PHP >= 99 is required.']],
+			['testPHPVersionOperatorNoSpace', ['PHP >= 99 is required.']],
+			['testPHPVersionOperatorEquals', ['PHP = 5.4 is required.']],
+			['testPHPVersionOperatorDoubleEquals', ['PHP == 5.4 is required.']],
+			['testPHPUnitVersionOperatorLessThan', ['PHPUnit < 1.0 is required.']],
+			['testPHPUnitVersionOperatorLessThanEquals', ['PHPUnit <= 1.0 is required.']],
+			['testPHPUnitVersionOperatorGreaterThan', ['PHPUnit > 99 is required.']],
+			['testPHPUnitVersionOperatorGreaterThanEquals', ['PHPUnit >= 99 is required.']],
+			['testPHPUnitVersionOperatorEquals', ['PHPUnit = 1.0 is required.']],
+			['testPHPUnitVersionOperatorDoubleEquals', ['PHPUnit == 1.0 is required.']],
+			['testPHPUnitVersionOperatorNoSpace', ['PHPUnit >= 99 is required.']],
+			['testExtensionVersionOperatorLessThan', ['Extension testExtOne < 1.0 is required.']],
+			['testExtensionVersionOperatorLessThanEquals', ['Extension testExtOne <= 1.0 is required.']],
+			['testExtensionVersionOperatorGreaterThan', ['Extension testExtOne > 99 is required.']],
+			['testExtensionVersionOperatorGreaterThanEquals', ['Extension testExtOne >= 99 is required.']],
+			['testExtensionVersionOperatorEquals', ['Extension testExtOne = 1.0 is required.']],
+			['testExtensionVersionOperatorDoubleEquals', ['Extension testExtOne == 1.0 is required.']],
+			['testExtensionVersionOperatorNoSpace', ['Extension testExtOne >= 99 is required.']],
+			['testVersionConstraintTildeMajor', [
+				'PHP version does not match the required constraint ~1.0.',
+				'PHPUnit version does not match the required constraint ~2.0.'
+			]],
+			['testVersionConstraintCaretMajor', [
+				'PHP version does not match the required constraint ^1.0.',
+				'PHPUnit version does not match the required constraint ^2.0.'
+			]]
+		];
+	}
+
+	/**
+	 * @todo   This test does not really test functionality of \PHPUnit\Util\Test
+	 */
+	public function testGetProvidedDataRegEx()
+	{
+		$result = \preg_match(Test::REGEX_DATA_PROVIDER, '@dataProvider method', $matches);
+		$this->assertEquals(1, $result);
+		$this->assertEquals('method', $matches[1]);
+
+		$result = \preg_match(Test::REGEX_DATA_PROVIDER, '@dataProvider class::method', $matches);
+		$this->assertEquals(1, $result);
+		$this->assertEquals('class::method', $matches[1]);
+
+		$result = \preg_match(Test::REGEX_DATA_PROVIDER, '@dataProvider namespace\class::method', $matches);
+		$this->assertEquals(1, $result);
+		$this->assertEquals('namespace\class::method', $matches[1]);
+
+		$result = \preg_match(Test::REGEX_DATA_PROVIDER, '@dataProvider namespace\namespace\class::method', $matches);
+		$this->assertEquals(1, $result);
+		$this->assertEquals('namespace\namespace\class::method', $matches[1]);
+
+		$result = \preg_match(Test::REGEX_DATA_PROVIDER, '@dataProvider メソッド', $matches);
+		$this->assertEquals(1, $result);
+		$this->assertEquals('メソッド', $matches[1]);
+	}
+
+	/**
+	 * Check if all data providers are being merged.
+	 */
+	public function testMultipleDataProviders()
+	{
+		$dataSets = Test::getProvidedData(\MultipleDataProviderTest::class, 'testOne');
+
+		$this->assertCount(9, $dataSets);
+
+		$aCount = 0;
+		$bCount = 0;
+		$cCount = 0;
+
+		for ($i = 0; $i < 9; $i++) {
+			$aCount += $dataSets[$i][0] != null ? 1 : 0;
+			$bCount += $dataSets[$i][1] != null ? 1 : 0;
+			$cCount += $dataSets[$i][2] != null ? 1 : 0;
+		}
+
+		$this->assertEquals(3, $aCount);
+		$this->assertEquals(3, $bCount);
+		$this->assertEquals(3, $cCount);
+	}
+
+	public function testMultipleYieldIteratorDataProviders()
+	{
+		$dataSets = Test::getProvidedData(\MultipleDataProviderTest::class, 'testTwo');
+
+		$this->assertEquals(9, \count($dataSets));
+
+		$aCount = 0;
+		$bCount = 0;
+		$cCount = 0;
+
+		for ($i = 0; $i < 9; $i++) {
+			$aCount += $dataSets[$i][0] != null ? 1 : 0;
+			$bCount += $dataSets[$i][1] != null ? 1 : 0;
+			$cCount += $dataSets[$i][2] != null ? 1 : 0;
+		}
+
+		$this->assertEquals(3, $aCount);
+		$this->assertEquals(3, $bCount);
+		$this->assertEquals(3, $cCount);
+	}
+
+	public function testWithVariousIterableDataProviders()
+	{
+		$dataSets = Test::getProvidedData(\VariousIterableDataProviderTest::class, 'test');
+
+		$this->assertEquals([
+			['A'],
+			['B'],
+			['C'],
+			['D'],
+			['E'],
+			['F'],
+			['G'],
+			['H'],
+			['I'],
+		], $dataSets);
+	}
+
+	public function testTestWithEmptyAnnotation()
+	{
+		$result = Test::getDataFromTestWithAnnotation("/**\n * @anotherAnnotation\n */");
+		$this->assertNull($result);
+	}
+
+	public function testTestWithSimpleCase()
+	{
+		$result = Test::getDataFromTestWithAnnotation('/**
                                                                      * @testWith [1]
                                                                      */');
-        $this->assertEquals([[1]], $result);
-    }
+		$this->assertEquals([[1]], $result);
+	}
 
-    public function testTestWithMultiLineMultiParameterCase()
-    {
-        $result = Test::getDataFromTestWithAnnotation('/**
+	public function testTestWithMultiLineMultiParameterCase()
+	{
+		$result = Test::getDataFromTestWithAnnotation('/**
                                                                      * @testWith [1, 2]
                                                                      * [3, 4]
                                                                      */');
-        $this->assertEquals([[1, 2], [3, 4]], $result);
-    }
+		$this->assertEquals([[1, 2], [3, 4]], $result);
+	}
 
-    public function testTestWithVariousTypes()
-    {
-        $result = Test::getDataFromTestWithAnnotation('/**
+	public function testTestWithVariousTypes()
+	{
+		$result = Test::getDataFromTestWithAnnotation('/**
             * @testWith ["ab"]
             *           [true]
             *           [null]
          */');
-        $this->assertEquals([['ab'], [true], [null]], $result);
-    }
+		$this->assertEquals([['ab'], [true], [null]], $result);
+	}
 
-    public function testTestWithAnnotationAfter()
-    {
-        $result = Test::getDataFromTestWithAnnotation('/**
+	public function testTestWithAnnotationAfter()
+	{
+		$result = Test::getDataFromTestWithAnnotation('/**
                                                                      * @testWith [1]
                                                                      *           [2]
                                                                      * @annotation
                                                                      */');
-        $this->assertEquals([[1], [2]], $result);
-    }
+		$this->assertEquals([[1], [2]], $result);
+	}
 
-    public function testTestWithSimpleTextAfter()
-    {
-        $result = Test::getDataFromTestWithAnnotation('/**
+	public function testTestWithSimpleTextAfter()
+	{
+		$result = Test::getDataFromTestWithAnnotation('/**
                                                                      * @testWith [1]
                                                                      *           [2]
                                                                      * blah blah
                                                                      */');
-        $this->assertEquals([[1], [2]], $result);
-    }
+		$this->assertEquals([[1], [2]], $result);
+	}
 
-    public function testTestWithCharacterEscape()
-    {
-        $result = Test::getDataFromTestWithAnnotation('/**
+	public function testTestWithCharacterEscape()
+	{
+		$result = Test::getDataFromTestWithAnnotation('/**
                                                                      * @testWith ["\"", "\""]
                                                                      */');
-        $this->assertEquals([['"', '"']], $result);
-    }
+		$this->assertEquals([['"', '"']], $result);
+	}
 
-    public function testTestWithThrowsProperExceptionIfDatasetCannotBeParsed()
-    {
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessageRegExp('/^The dataset for the @testWith annotation cannot be parsed:/');
+	public function testTestWithThrowsProperExceptionIfDatasetCannotBeParsed()
+	{
+		$this->expectException(Exception::class);
+		$this->expectExceptionMessageRegExp('/^The dataset for the @testWith annotation cannot be parsed:/');
 
-        Test::getDataFromTestWithAnnotation('/**
+		Test::getDataFromTestWithAnnotation('/**
                                                            * @testWith [s]
                                                            */');
-    }
+	}
 
-    public function testTestWithThrowsProperExceptionIfMultiLineDatasetCannotBeParsed()
-    {
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessageRegExp('/^The dataset for the @testWith annotation cannot be parsed:/');
+	public function testTestWithThrowsProperExceptionIfMultiLineDatasetCannotBeParsed()
+	{
+		$this->expectException(Exception::class);
+		$this->expectExceptionMessageRegExp('/^The dataset for the @testWith annotation cannot be parsed:/');
 
-        Test::getDataFromTestWithAnnotation('/**
+		Test::getDataFromTestWithAnnotation('/**
                                                            * @testWith ["valid"]
                                                            *           [invalid]
                                                            */');
-    }
-
-    /**
-     * @todo Not sure what this test tests (name is misleading at least)
-     */
-    public function testParseAnnotation()
-    {
-        $this->assertEquals(
-            ['Foo', 'ほげ'],
-            Test::getDependencies(\get_class($this), 'methodForTestParseAnnotation')
-        );
-    }
-
-    /**
-     * @depends Foo
-     * @depends ほげ
-     *
-     * @todo Remove fixture from test class
-     */
-    public function methodForTestParseAnnotation()
-    {
-    }
-
-    public function testParseAnnotationThatIsOnlyOneLine()
-    {
-        $this->assertEquals(
-            ['Bar'],
-            Test::getDependencies(\get_class($this), 'methodForTestParseAnnotationThatIsOnlyOneLine')
-        );
-    }
-
-    /** @depends Bar */
-    public function methodForTestParseAnnotationThatIsOnlyOneLine()
-    {
-        // TODO Remove fixture from test class
-    }
-
-    /**
-     * @dataProvider getLinesToBeCoveredProvider
-     */
-    public function testGetLinesToBeCovered($test, $lines)
-    {
-        if (\strpos($test, 'Namespace') === 0) {
-            $expected = [
-              TEST_FILES_PATH . 'NamespaceCoveredClass.php' => $lines
-            ];
-        } elseif ($test === 'CoverageNoneTest') {
-            $expected = [];
-        } elseif ($test === 'CoverageNothingTest') {
-            $expected = false;
-        } elseif ($test === 'CoverageFunctionTest') {
-            $expected = [
-              TEST_FILES_PATH . 'CoveredFunction.php' => $lines
-            ];
-        } else {
-            $expected = [TEST_FILES_PATH . 'CoveredClass.php' => $lines];
-        }
-
-        $this->assertEquals(
-            $expected,
-            Test::getLinesToBeCovered(
-                $test,
-                'testSomething'
-            )
-        );
-    }
-
-    public function testGetLinesToBeCovered2()
-    {
-        $this->expectException(CodeCoverageException::class);
-
-        Test::getLinesToBeCovered(
-            'NotExistingCoveredElementTest',
-            'testOne'
-        );
-    }
-
-    public function testGetLinesToBeCovered3()
-    {
-        $this->expectException(CodeCoverageException::class);
-
-        Test::getLinesToBeCovered(
-            'NotExistingCoveredElementTest',
-            'testTwo'
-        );
-    }
-
-    public function testGetLinesToBeCovered4()
-    {
-        $this->expectException(CodeCoverageException::class);
-
-        Test::getLinesToBeCovered(
-            'NotExistingCoveredElementTest',
-            'testThree'
-        );
-    }
-
-    public function testGetLinesToBeCoveredSkipsNonExistentMethods()
-    {
-        $this->assertSame(
-            [],
-            Test::getLinesToBeCovered(
-                'NotExistingCoveredElementTest',
-                'methodDoesNotExist'
-            )
-        );
-    }
-
-    public function testTwoCoversDefaultClassAnnoationsAreNotAllowed()
-    {
-        $this->expectException(CodeCoverageException::class);
-
-        Test::getLinesToBeCovered(
-            'CoverageTwoDefaultClassAnnotations',
-            'testSomething'
-        );
-    }
-
-    public function testFunctionParenthesesAreAllowed()
-    {
-        $this->assertSame(
-            [TEST_FILES_PATH . 'CoveredFunction.php' => \range(2, 4)],
-            Test::getLinesToBeCovered(
-                'CoverageFunctionParenthesesTest',
-                'testSomething'
-            )
-        );
-    }
-
-    public function testFunctionParenthesesAreAllowedWithWhitespace()
-    {
-        $this->assertSame(
-            [TEST_FILES_PATH . 'CoveredFunction.php' => \range(2, 4)],
-            Test::getLinesToBeCovered(
-                'CoverageFunctionParenthesesWhitespaceTest',
-                'testSomething'
-            )
-        );
-    }
-
-    public function testMethodParenthesesAreAllowed()
-    {
-        $this->assertSame(
-            [TEST_FILES_PATH . 'CoveredClass.php' => \range(31, 35)],
-            Test::getLinesToBeCovered(
-                'CoverageMethodParenthesesTest',
-                'testSomething'
-            )
-        );
-    }
-
-    public function testMethodParenthesesAreAllowedWithWhitespace()
-    {
-        $this->assertSame(
-            [TEST_FILES_PATH . 'CoveredClass.php' => \range(31, 35)],
-            Test::getLinesToBeCovered(
-                'CoverageMethodParenthesesWhitespaceTest',
-                'testSomething'
-            )
-        );
-    }
-
-    public function testNamespacedFunctionCanBeCoveredOrUsed()
-    {
-        $this->assertEquals(
-            [
-                TEST_FILES_PATH . 'NamespaceCoveredFunction.php' => \range(4, 7)
-            ],
-            Test::getLinesToBeCovered(
-                \CoverageNamespacedFunctionTest::class,
-                'testFunc'
-            )
-        );
-    }
-
-    public function getLinesToBeCoveredProvider()
-    {
-        return [
-          [
-            'CoverageNoneTest',
-            []
-          ],
-          [
-            'CoverageClassExtendedTest',
-            \array_merge(\range(19, 36), \range(2, 17))
-          ],
-          [
-            'CoverageClassTest',
-            \range(19, 36)
-          ],
-          [
-            'CoverageMethodTest',
-            \range(31, 35)
-          ],
-          [
-            'CoverageMethodOneLineAnnotationTest',
-            \range(31, 35)
-          ],
-          [
-            'CoverageNotPrivateTest',
-            \array_merge(\range(25, 29), \range(31, 35))
-          ],
-          [
-            'CoverageNotProtectedTest',
-            \array_merge(\range(21, 23), \range(31, 35))
-          ],
-          [
-            'CoverageNotPublicTest',
-            \array_merge(\range(21, 23), \range(25, 29))
-          ],
-          [
-            'CoveragePrivateTest',
-            \range(21, 23)
-          ],
-          [
-            'CoverageProtectedTest',
-            \range(25, 29)
-          ],
-          [
-            'CoveragePublicTest',
-            \range(31, 35)
-          ],
-          [
-            'CoverageFunctionTest',
-            \range(2, 4)
-          ],
-          [
-            'NamespaceCoverageClassExtendedTest',
-            \array_merge(\range(21, 38), \range(4, 19))
-          ],
-          [
-            'NamespaceCoverageClassTest',
-            \range(21, 38)
-          ],
-          [
-            'NamespaceCoverageMethodTest',
-            \range(33, 37)
-          ],
-          [
-            'NamespaceCoverageNotPrivateTest',
-            \array_merge(\range(27, 31), \range(33, 37))
-          ],
-          [
-            'NamespaceCoverageNotProtectedTest',
-            \array_merge(\range(23, 25), \range(33, 37))
-          ],
-          [
-            'NamespaceCoverageNotPublicTest',
-            \array_merge(\range(23, 25), \range(27, 31))
-          ],
-          [
-            'NamespaceCoveragePrivateTest',
-            \range(23, 25)
-          ],
-          [
-            'NamespaceCoverageProtectedTest',
-            \range(27, 31)
-          ],
-          [
-            'NamespaceCoveragePublicTest',
-            \range(33, 37)
-          ],
-          [
-            'NamespaceCoverageCoversClassTest',
-            \array_merge(\range(23, 25), \range(27, 31), \range(33, 37), \range(6, 8), \range(10, 13), \range(15, 18))
-          ],
-          [
-            'NamespaceCoverageCoversClassPublicTest',
-            \range(33, 37)
-          ],
-          [
-            'CoverageNothingTest',
-            false
-          ]
-        ];
-    }
-
-    public function testParseTestMethodAnnotationsIncorporatesTraits()
-    {
-        $result = Test::parseTestMethodAnnotations(\ParseTestMethodAnnotationsMock::class);
-
-        $this->assertArrayHasKey('class', $result);
-        $this->assertArrayHasKey('method', $result);
-        $this->assertArrayHasKey('theClassAnnotation', $result['class']);
-        $this->assertArrayHasKey('theTraitAnnotation', $result['class']);
-    }
+	}
+
+	/**
+	 * @todo Not sure what this test tests (name is misleading at least)
+	 */
+	public function testParseAnnotation()
+	{
+		$this->assertEquals(
+			['Foo', 'ほげ'],
+			Test::getDependencies(\get_class($this), 'methodForTestParseAnnotation')
+		);
+	}
+
+	/**
+	 * @depends Foo
+	 * @depends ほげ
+	 *
+	 * @todo Remove fixture from test class
+	 */
+	public function methodForTestParseAnnotation()
+	{
+	}
+
+	public function testParseAnnotationThatIsOnlyOneLine()
+	{
+		$this->assertEquals(
+			['Bar'],
+			Test::getDependencies(\get_class($this), 'methodForTestParseAnnotationThatIsOnlyOneLine')
+		);
+	}
+
+	/** @depends Bar */
+	public function methodForTestParseAnnotationThatIsOnlyOneLine()
+	{
+		// TODO Remove fixture from test class
+	}
+
+	/**
+	 * @dataProvider getLinesToBeCoveredProvider
+	 */
+	public function testGetLinesToBeCovered($test, $lines)
+	{
+		if (\strpos($test, 'Namespace') === 0) {
+			$expected = [
+			  TEST_FILES_PATH . 'NamespaceCoveredClass.php' => $lines
+			];
+		} elseif ($test === 'CoverageNoneTest') {
+			$expected = [];
+		} elseif ($test === 'CoverageNothingTest') {
+			$expected = false;
+		} elseif ($test === 'CoverageFunctionTest') {
+			$expected = [
+			  TEST_FILES_PATH . 'CoveredFunction.php' => $lines
+			];
+		} else {
+			$expected = [TEST_FILES_PATH . 'CoveredClass.php' => $lines];
+		}
+
+		$this->assertEquals(
+			$expected,
+			Test::getLinesToBeCovered(
+				$test,
+				'testSomething'
+			)
+		);
+	}
+
+	public function testGetLinesToBeCovered2()
+	{
+		$this->expectException(CodeCoverageException::class);
+
+		Test::getLinesToBeCovered(
+			'NotExistingCoveredElementTest',
+			'testOne'
+		);
+	}
+
+	public function testGetLinesToBeCovered3()
+	{
+		$this->expectException(CodeCoverageException::class);
+
+		Test::getLinesToBeCovered(
+			'NotExistingCoveredElementTest',
+			'testTwo'
+		);
+	}
+
+	public function testGetLinesToBeCovered4()
+	{
+		$this->expectException(CodeCoverageException::class);
+
+		Test::getLinesToBeCovered(
+			'NotExistingCoveredElementTest',
+			'testThree'
+		);
+	}
+
+	public function testGetLinesToBeCoveredSkipsNonExistentMethods()
+	{
+		$this->assertSame(
+			[],
+			Test::getLinesToBeCovered(
+				'NotExistingCoveredElementTest',
+				'methodDoesNotExist'
+			)
+		);
+	}
+
+	public function testTwoCoversDefaultClassAnnoationsAreNotAllowed()
+	{
+		$this->expectException(CodeCoverageException::class);
+
+		Test::getLinesToBeCovered(
+			'CoverageTwoDefaultClassAnnotations',
+			'testSomething'
+		);
+	}
+
+	public function testFunctionParenthesesAreAllowed()
+	{
+		$this->assertSame(
+			[TEST_FILES_PATH . 'CoveredFunction.php' => \range(2, 4)],
+			Test::getLinesToBeCovered(
+				'CoverageFunctionParenthesesTest',
+				'testSomething'
+			)
+		);
+	}
+
+	public function testFunctionParenthesesAreAllowedWithWhitespace()
+	{
+		$this->assertSame(
+			[TEST_FILES_PATH . 'CoveredFunction.php' => \range(2, 4)],
+			Test::getLinesToBeCovered(
+				'CoverageFunctionParenthesesWhitespaceTest',
+				'testSomething'
+			)
+		);
+	}
+
+	public function testMethodParenthesesAreAllowed()
+	{
+		$this->assertSame(
+			[TEST_FILES_PATH . 'CoveredClass.php' => \range(31, 35)],
+			Test::getLinesToBeCovered(
+				'CoverageMethodParenthesesTest',
+				'testSomething'
+			)
+		);
+	}
+
+	public function testMethodParenthesesAreAllowedWithWhitespace()
+	{
+		$this->assertSame(
+			[TEST_FILES_PATH . 'CoveredClass.php' => \range(31, 35)],
+			Test::getLinesToBeCovered(
+				'CoverageMethodParenthesesWhitespaceTest',
+				'testSomething'
+			)
+		);
+	}
+
+	public function testNamespacedFunctionCanBeCoveredOrUsed()
+	{
+		$this->assertEquals(
+			[
+				TEST_FILES_PATH . 'NamespaceCoveredFunction.php' => \range(4, 7)
+			],
+			Test::getLinesToBeCovered(
+				\CoverageNamespacedFunctionTest::class,
+				'testFunc'
+			)
+		);
+	}
+
+	public function getLinesToBeCoveredProvider()
+	{
+		return [
+		  [
+			'CoverageNoneTest',
+			[]
+		  ],
+		  [
+			'CoverageClassExtendedTest',
+			\array_merge(\range(19, 36), \range(2, 17))
+		  ],
+		  [
+			'CoverageClassTest',
+			\range(19, 36)
+		  ],
+		  [
+			'CoverageMethodTest',
+			\range(31, 35)
+		  ],
+		  [
+			'CoverageMethodOneLineAnnotationTest',
+			\range(31, 35)
+		  ],
+		  [
+			'CoverageNotPrivateTest',
+			\array_merge(\range(25, 29), \range(31, 35))
+		  ],
+		  [
+			'CoverageNotProtectedTest',
+			\array_merge(\range(21, 23), \range(31, 35))
+		  ],
+		  [
+			'CoverageNotPublicTest',
+			\array_merge(\range(21, 23), \range(25, 29))
+		  ],
+		  [
+			'CoveragePrivateTest',
+			\range(21, 23)
+		  ],
+		  [
+			'CoverageProtectedTest',
+			\range(25, 29)
+		  ],
+		  [
+			'CoveragePublicTest',
+			\range(31, 35)
+		  ],
+		  [
+			'CoverageFunctionTest',
+			\range(2, 4)
+		  ],
+		  [
+			'NamespaceCoverageClassExtendedTest',
+			\array_merge(\range(21, 38), \range(4, 19))
+		  ],
+		  [
+			'NamespaceCoverageClassTest',
+			\range(21, 38)
+		  ],
+		  [
+			'NamespaceCoverageMethodTest',
+			\range(33, 37)
+		  ],
+		  [
+			'NamespaceCoverageNotPrivateTest',
+			\array_merge(\range(27, 31), \range(33, 37))
+		  ],
+		  [
+			'NamespaceCoverageNotProtectedTest',
+			\array_merge(\range(23, 25), \range(33, 37))
+		  ],
+		  [
+			'NamespaceCoverageNotPublicTest',
+			\array_merge(\range(23, 25), \range(27, 31))
+		  ],
+		  [
+			'NamespaceCoveragePrivateTest',
+			\range(23, 25)
+		  ],
+		  [
+			'NamespaceCoverageProtectedTest',
+			\range(27, 31)
+		  ],
+		  [
+			'NamespaceCoveragePublicTest',
+			\range(33, 37)
+		  ],
+		  [
+			'NamespaceCoverageCoversClassTest',
+			\array_merge(\range(23, 25), \range(27, 31), \range(33, 37), \range(6, 8), \range(10, 13), \range(15, 18))
+		  ],
+		  [
+			'NamespaceCoverageCoversClassPublicTest',
+			\range(33, 37)
+		  ],
+		  [
+			'CoverageNothingTest',
+			false
+		  ]
+		];
+	}
+
+	public function testParseTestMethodAnnotationsIncorporatesTraits()
+	{
+		$result = Test::parseTestMethodAnnotations(\ParseTestMethodAnnotationsMock::class);
+
+		$this->assertArrayHasKey('class', $result);
+		$this->assertArrayHasKey('method', $result);
+		$this->assertArrayHasKey('theClassAnnotation', $result['class']);
+		$this->assertArrayHasKey('theTraitAnnotation', $result['class']);
+	}
 }

Spacing +24 added lines, -24 removed lines

@@ -122,19 +122,19 @@ 
     public function requirementsProvider()
     {
         return [
-            ['testOne',    []],
-            ['testTwo',    ['PHPUnit'    => ['version' => '1.0', 'operator' => '']]],
-            ['testThree',  ['PHP'        => ['version' => '2.0', 'operator' => '']]],
-            ['testFour',   [
+            ['testOne', []],
+            ['testTwo', ['PHPUnit'    => ['version' => '1.0', 'operator' => '']]],
+            ['testThree', ['PHP'        => ['version' => '2.0', 'operator' => '']]],
+            ['testFour', [
                 'PHPUnit'    => ['version' => '2.0', 'operator' => ''],
                 'PHP'        => ['version' => '1.0', 'operator' => ''],
             ]],
-            ['testFive',   ['PHP'        => ['version' => '5.4.0RC6', 'operator' => '']]],
-            ['testSix',    ['PHP'        => ['version' => '5.4.0-alpha1', 'operator' => '']]],
-            ['testSeven',  ['PHP'        => ['version' => '5.4.0beta2', 'operator' => '']]],
-            ['testEight',  ['PHP'        => ['version' => '5.4-dev', 'operator' => '']]],
-            ['testNine',   ['functions'  => ['testFunc']]],
-            ['testTen',    ['extensions' => ['testExt']]],
+            ['testFive', ['PHP'        => ['version' => '5.4.0RC6', 'operator' => '']]],
+            ['testSix', ['PHP'        => ['version' => '5.4.0-alpha1', 'operator' => '']]],
+            ['testSeven', ['PHP'        => ['version' => '5.4.0beta2', 'operator' => '']]],
+            ['testEight', ['PHP'        => ['version' => '5.4-dev', 'operator' => '']]],
+            ['testNine', ['functions'  => ['testFunc']]],
+            ['testTen', ['extensions' => ['testExt']]],
             ['testEleven', [
                 'OS'         => 'SunOS',
                 'OSFAMILY'   => 'Solaris',
@@ -497,12 +497,12 @@ 
     public function missingRequirementsProvider()
     {
         return [
-            ['testOne',            []],
-            ['testNine',           ['Function testFunc is required.']],
-            ['testTen',            ['Extension testExt is required.']],
-            ['testAlwaysSkip',     ['PHPUnit >= 1111111 is required.']],
-            ['testAlwaysSkip2',    ['PHP >= 9999999 is required.']],
-            ['testAlwaysSkip3',    ['Operating system matching /DOESNOTEXIST/i is required.']],
+            ['testOne', []],
+            ['testNine', ['Function testFunc is required.']],
+            ['testTen', ['Extension testExt is required.']],
+            ['testAlwaysSkip', ['PHPUnit >= 1111111 is required.']],
+            ['testAlwaysSkip2', ['PHP >= 9999999 is required.']],
+            ['testAlwaysSkip3', ['Operating system matching /DOESNOTEXIST/i is required.']],
             ['testAllPossibleRequirements', [
               'PHP >= 99-dev is required.',
               'PHPUnit >= 9-dev is required.',
@@ -757,7 +757,7 @@ 
     {
         if (\strpos($test, 'Namespace') === 0) {
             $expected = [
-              TEST_FILES_PATH . 'NamespaceCoveredClass.php' => $lines
+              TEST_FILES_PATH.'NamespaceCoveredClass.php' => $lines
             ];
         } elseif ($test === 'CoverageNoneTest') {
             $expected = [];
@@ -765,10 +765,10 @@ 
             $expected = false;
         } elseif ($test === 'CoverageFunctionTest') {
             $expected = [
-              TEST_FILES_PATH . 'CoveredFunction.php' => $lines
+              TEST_FILES_PATH.'CoveredFunction.php' => $lines
             ];
         } else {
-            $expected = [TEST_FILES_PATH . 'CoveredClass.php' => $lines];
+            $expected = [TEST_FILES_PATH.'CoveredClass.php' => $lines];
         }
 
         $this->assertEquals(
@@ -834,7 +834,7 @@ 
     public function testFunctionParenthesesAreAllowed()
     {
         $this->assertSame(
-            [TEST_FILES_PATH . 'CoveredFunction.php' => \range(2, 4)],
+            [TEST_FILES_PATH.'CoveredFunction.php' => \range(2, 4)],
             Test::getLinesToBeCovered(
                 'CoverageFunctionParenthesesTest',
                 'testSomething'
@@ -845,7 +845,7 @@ 
     public function testFunctionParenthesesAreAllowedWithWhitespace()
     {
         $this->assertSame(
-            [TEST_FILES_PATH . 'CoveredFunction.php' => \range(2, 4)],
+            [TEST_FILES_PATH.'CoveredFunction.php' => \range(2, 4)],
             Test::getLinesToBeCovered(
                 'CoverageFunctionParenthesesWhitespaceTest',
                 'testSomething'
@@ -856,7 +856,7 @@ 
     public function testMethodParenthesesAreAllowed()
     {
         $this->assertSame(
-            [TEST_FILES_PATH . 'CoveredClass.php' => \range(31, 35)],
+            [TEST_FILES_PATH.'CoveredClass.php' => \range(31, 35)],
             Test::getLinesToBeCovered(
                 'CoverageMethodParenthesesTest',
                 'testSomething'
@@ -867,7 +867,7 @@ 
     public function testMethodParenthesesAreAllowedWithWhitespace()
     {
         $this->assertSame(
-            [TEST_FILES_PATH . 'CoveredClass.php' => \range(31, 35)],
+            [TEST_FILES_PATH.'CoveredClass.php' => \range(31, 35)],
             Test::getLinesToBeCovered(
                 'CoverageMethodParenthesesWhitespaceTest',
                 'testSomething'
@@ -879,7 +879,7 @@ 
     {
         $this->assertEquals(
             [
-                TEST_FILES_PATH . 'NamespaceCoveredFunction.php' => \range(4, 7)
+                TEST_FILES_PATH.'NamespaceCoveredFunction.php' => \range(4, 7)
             ],
             Test::getLinesToBeCovered(
                 \CoverageNamespacedFunctionTest::class,

vendor/phpunit/phpunit/tests/Util/XmlTest.php

Indentation +99 added lines, -99 removed lines

@@ -15,103 +15,103 @@
 
 class XmlTest extends TestCase
 {
-    /**
-     * @dataProvider charProvider
-     */
-    public function testPrepareString($char)
-    {
-        $e = null;
-
-        $escapedString = Xml::prepareString($char);
-        $xml           = "<?xml version='1.0' encoding='UTF-8' ?><tag>$escapedString</tag>";
-        $dom           = new \DOMDocument('1.0', 'UTF-8');
-
-        try {
-            $dom->loadXML($xml);
-        } catch (Exception $e) {
-        }
-
-        $this->assertNull($e, \sprintf(
-            'PHPUnit_Util_XML::prepareString("\x%02x") should not crash DomDocument',
-            \ord($char)
-        ));
-    }
-
-    public function charProvider()
-    {
-        $data = [];
-
-        for ($i = 0; $i < 256; $i++) {
-            $data[] = [\chr($i)];
-        }
-
-        return $data;
-    }
-
-    public function testLoadEmptyString()
-    {
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('Could not load XML from empty string');
-
-        Xml::load('');
-    }
-
-    public function testLoadArray()
-    {
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('Could not load XML from array');
-
-        Xml::load([1, 2, 3]);
-    }
-
-    public function testLoadBoolean()
-    {
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('Could not load XML from boolean');
-
-        Xml::load(false);
-    }
-
-    public function testNestedXmlToVariable()
-    {
-        $xml = '<array><element key="a"><array><element key="b"><string>foo</string></element></array></element><element key="c"><string>bar</string></element></array>';
-        $dom = new \DOMDocument;
-        $dom->loadXML($xml);
-
-        $expected = [
-            'a' => [
-                'b' => 'foo',
-            ],
-            'c' => 'bar',
-        ];
-
-        $actual = Xml::xmlToVariable($dom->documentElement);
-
-        $this->assertSame($expected, $actual);
-    }
-
-    public function testXmlToVariableCanHandleMultipleOfTheSameArgumentType()
-    {
-        $xml = '<object class="SampleClass"><arguments><string>a</string><string>b</string><string>c</string></arguments></object>';
-        $dom = new \DOMDocument();
-        $dom->loadXML($xml);
-
-        $expected = ['a' => 'a', 'b' => 'b', 'c' => 'c'];
-
-        $actual = Xml::xmlToVariable($dom->documentElement);
-
-        $this->assertSame($expected, (array) $actual);
-    }
-
-    public function testXmlToVariableCanConstructObjectsWithConstructorArgumentsRecursively()
-    {
-        $xml = '<object class="Exception"><arguments><string>one</string><integer>0</integer><object class="Exception"><arguments><string>two</string></arguments></object></arguments></object>';
-        $dom = new \DOMDocument();
-        $dom->loadXML($xml);
-
-        $actual = Xml::xmlToVariable($dom->documentElement);
-
-        $this->assertEquals('one', $actual->getMessage());
-        $this->assertEquals('two', $actual->getPrevious()->getMessage());
-    }
+	/**
+	 * @dataProvider charProvider
+	 */
+	public function testPrepareString($char)
+	{
+		$e = null;
+
+		$escapedString = Xml::prepareString($char);
+		$xml           = "<?xml version='1.0' encoding='UTF-8' ?><tag>$escapedString</tag>";
+		$dom           = new \DOMDocument('1.0', 'UTF-8');
+
+		try {
+			$dom->loadXML($xml);
+		} catch (Exception $e) {
+		}
+
+		$this->assertNull($e, \sprintf(
+			'PHPUnit_Util_XML::prepareString("\x%02x") should not crash DomDocument',
+			\ord($char)
+		));
+	}
+
+	public function charProvider()
+	{
+		$data = [];
+
+		for ($i = 0; $i < 256; $i++) {
+			$data[] = [\chr($i)];
+		}
+
+		return $data;
+	}
+
+	public function testLoadEmptyString()
+	{
+		$this->expectException(Exception::class);
+		$this->expectExceptionMessage('Could not load XML from empty string');
+
+		Xml::load('');
+	}
+
+	public function testLoadArray()
+	{
+		$this->expectException(Exception::class);
+		$this->expectExceptionMessage('Could not load XML from array');
+
+		Xml::load([1, 2, 3]);
+	}
+
+	public function testLoadBoolean()
+	{
+		$this->expectException(Exception::class);
+		$this->expectExceptionMessage('Could not load XML from boolean');
+
+		Xml::load(false);
+	}
+
+	public function testNestedXmlToVariable()
+	{
+		$xml = '<array><element key="a"><array><element key="b"><string>foo</string></element></array></element><element key="c"><string>bar</string></element></array>';
+		$dom = new \DOMDocument;
+		$dom->loadXML($xml);
+
+		$expected = [
+			'a' => [
+				'b' => 'foo',
+			],
+			'c' => 'bar',
+		];
+
+		$actual = Xml::xmlToVariable($dom->documentElement);
+
+		$this->assertSame($expected, $actual);
+	}
+
+	public function testXmlToVariableCanHandleMultipleOfTheSameArgumentType()
+	{
+		$xml = '<object class="SampleClass"><arguments><string>a</string><string>b</string><string>c</string></arguments></object>';
+		$dom = new \DOMDocument();
+		$dom->loadXML($xml);
+
+		$expected = ['a' => 'a', 'b' => 'b', 'c' => 'c'];
+
+		$actual = Xml::xmlToVariable($dom->documentElement);
+
+		$this->assertSame($expected, (array) $actual);
+	}
+
+	public function testXmlToVariableCanConstructObjectsWithConstructorArgumentsRecursively()
+	{
+		$xml = '<object class="Exception"><arguments><string>one</string><integer>0</integer><object class="Exception"><arguments><string>two</string></arguments></object></arguments></object>';
+		$dom = new \DOMDocument();
+		$dom->loadXML($xml);
+
+		$actual = Xml::xmlToVariable($dom->documentElement);
+
+		$this->assertEquals('one', $actual->getMessage());
+		$this->assertEquals('two', $actual->getPrevious()->getMessage());
+	}
 }

vendor/phpunit/phpunit/tests/Util/PHP/AbstractPhpProcessTest.php

Indentation +79 added lines, -79 removed lines

@@ -15,110 +15,110 @@
 
 class AbstractPhpProcessTest extends TestCase
 {
-    /**
-     * @var AbstractPhpProcess|\PHPUnit_Framework_MockObject_MockObject
-     */
-    private $phpProcess;
+	/**
+	 * @var AbstractPhpProcess|\PHPUnit_Framework_MockObject_MockObject
+	 */
+	private $phpProcess;
 
-    protected function setUp()
-    {
-        $this->phpProcess = $this->getMockForAbstractClass(AbstractPhpProcess::class);
-    }
+	protected function setUp()
+	{
+		$this->phpProcess = $this->getMockForAbstractClass(AbstractPhpProcess::class);
+	}
 
-    public function testShouldNotUseStderrRedirectionByDefault()
-    {
-        $this->assertFalse($this->phpProcess->useStderrRedirection());
-    }
+	public function testShouldNotUseStderrRedirectionByDefault()
+	{
+		$this->assertFalse($this->phpProcess->useStderrRedirection());
+	}
 
-    public function testShouldDefinedIfUseStderrRedirection()
-    {
-        $this->phpProcess->setUseStderrRedirection(true);
+	public function testShouldDefinedIfUseStderrRedirection()
+	{
+		$this->phpProcess->setUseStderrRedirection(true);
 
-        $this->assertTrue($this->phpProcess->useStderrRedirection());
-    }
+		$this->assertTrue($this->phpProcess->useStderrRedirection());
+	}
 
-    public function testShouldDefinedIfDoNotUseStderrRedirection()
-    {
-        $this->phpProcess->setUseStderrRedirection(false);
+	public function testShouldDefinedIfDoNotUseStderrRedirection()
+	{
+		$this->phpProcess->setUseStderrRedirection(false);
 
-        $this->assertFalse($this->phpProcess->useStderrRedirection());
-    }
+		$this->assertFalse($this->phpProcess->useStderrRedirection());
+	}
 
-    public function testShouldThrowsExceptionWhenStderrRedirectionVariableIsNotABoolean()
-    {
-        $this->expectException(Exception::class);
+	public function testShouldThrowsExceptionWhenStderrRedirectionVariableIsNotABoolean()
+	{
+		$this->expectException(Exception::class);
 
-        $this->phpProcess->setUseStderrRedirection(null);
-    }
+		$this->phpProcess->setUseStderrRedirection(null);
+	}
 
-    public function testShouldUseGivenSettingsToCreateCommand()
-    {
-        $settings = [
-            'allow_url_fopen=1',
-            'auto_append_file=',
-            'display_errors=1',
-        ];
+	public function testShouldUseGivenSettingsToCreateCommand()
+	{
+		$settings = [
+			'allow_url_fopen=1',
+			'auto_append_file=',
+			'display_errors=1',
+		];
 
-        $expectedCommandFormat  = '%s -d allow_url_fopen=1 -d auto_append_file= -d display_errors=1';
-        $actualCommand          = $this->phpProcess->getCommand($settings);
+		$expectedCommandFormat  = '%s -d allow_url_fopen=1 -d auto_append_file= -d display_errors=1';
+		$actualCommand          = $this->phpProcess->getCommand($settings);
 
-        $this->assertStringMatchesFormat($expectedCommandFormat, $actualCommand);
-    }
+		$this->assertStringMatchesFormat($expectedCommandFormat, $actualCommand);
+	}
 
-    public function testShouldRedirectStderrToStdoutWhenDefined()
-    {
-        $this->phpProcess->setUseStderrRedirection(true);
+	public function testShouldRedirectStderrToStdoutWhenDefined()
+	{
+		$this->phpProcess->setUseStderrRedirection(true);
 
-        $expectedCommandFormat  = '%s 2>&1';
-        $actualCommand          = $this->phpProcess->getCommand([]);
+		$expectedCommandFormat  = '%s 2>&1';
+		$actualCommand          = $this->phpProcess->getCommand([]);
 
-        $this->assertStringMatchesFormat($expectedCommandFormat, $actualCommand);
-    }
+		$this->assertStringMatchesFormat($expectedCommandFormat, $actualCommand);
+	}
 
-    public function testShouldUseArgsToCreateCommand()
-    {
-        $this->phpProcess->setArgs('foo=bar');
+	public function testShouldUseArgsToCreateCommand()
+	{
+		$this->phpProcess->setArgs('foo=bar');
 
-        $expectedCommandFormat  = '%s -- foo=bar';
-        $actualCommand          = $this->phpProcess->getCommand([]);
+		$expectedCommandFormat  = '%s -- foo=bar';
+		$actualCommand          = $this->phpProcess->getCommand([]);
 
-        $this->assertStringMatchesFormat($expectedCommandFormat, $actualCommand);
-    }
+		$this->assertStringMatchesFormat($expectedCommandFormat, $actualCommand);
+	}
 
-    public function testShouldHaveFileToCreateCommand()
-    {
-        $argumentEscapingCharacter = DIRECTORY_SEPARATOR === '\\' ? '"' : '\'';
-        $expectedCommandFormat     = \sprintf('%%s -%%c %1$sfile.php%1$s', $argumentEscapingCharacter);
-        $actualCommand             = $this->phpProcess->getCommand([], 'file.php');
+	public function testShouldHaveFileToCreateCommand()
+	{
+		$argumentEscapingCharacter = DIRECTORY_SEPARATOR === '\\' ? '"' : '\'';
+		$expectedCommandFormat     = \sprintf('%%s -%%c %1$sfile.php%1$s', $argumentEscapingCharacter);
+		$actualCommand             = $this->phpProcess->getCommand([], 'file.php');
 
-        $this->assertStringMatchesFormat($expectedCommandFormat, $actualCommand);
-    }
+		$this->assertStringMatchesFormat($expectedCommandFormat, $actualCommand);
+	}
 
-    public function testStdinGetterAndSetter()
-    {
-        $this->phpProcess->setStdin('foo');
+	public function testStdinGetterAndSetter()
+	{
+		$this->phpProcess->setStdin('foo');
 
-        $this->assertEquals('foo', $this->phpProcess->getStdin());
-    }
+		$this->assertEquals('foo', $this->phpProcess->getStdin());
+	}
 
-    public function testArgsGetterAndSetter()
-    {
-        $this->phpProcess->setArgs('foo=bar');
+	public function testArgsGetterAndSetter()
+	{
+		$this->phpProcess->setArgs('foo=bar');
 
-        $this->assertEquals('foo=bar', $this->phpProcess->getArgs());
-    }
+		$this->assertEquals('foo=bar', $this->phpProcess->getArgs());
+	}
 
-    public function testEnvGetterAndSetter()
-    {
-        $this->phpProcess->setEnv(['foo' => 'bar']);
+	public function testEnvGetterAndSetter()
+	{
+		$this->phpProcess->setEnv(['foo' => 'bar']);
 
-        $this->assertEquals(['foo' => 'bar'], $this->phpProcess->getEnv());
-    }
+		$this->assertEquals(['foo' => 'bar'], $this->phpProcess->getEnv());
+	}
 
-    public function testTimeoutGetterAndSetter()
-    {
-        $this->phpProcess->setTimeout(30);
+	public function testTimeoutGetterAndSetter()
+	{
+		$this->phpProcess->setTimeout(30);
 
-        $this->assertEquals(30, $this->phpProcess->getTimeout());
-    }
+		$this->assertEquals(30, $this->phpProcess->getTimeout());
+	}
 }