chillerlan / php-traits

vendor/phpunit/phpunit/tests/bootstrap.php

Indentation +1 added lines, -1 removed lines

@@ -1,6 +1,6 @@
 <?php
 if (!defined('TEST_FILES_PATH')) {
-    define('TEST_FILES_PATH', __DIR__ . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR);
+	define('TEST_FILES_PATH', __DIR__ . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR);
 }
 
 ini_set('precision', 14);

Spacing +21 added lines, -21 removed lines

@@ -1,30 +1,30 @@
 <?php
 if (!defined('TEST_FILES_PATH')) {
-    define('TEST_FILES_PATH', __DIR__ . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR);
+    define('TEST_FILES_PATH', __DIR__.DIRECTORY_SEPARATOR.'_files'.DIRECTORY_SEPARATOR);
 }
 
 ini_set('precision', 14);
 ini_set('serialize_precision', 14);
 
-require_once __DIR__ . '/../vendor/autoload.php';
+require_once __DIR__.'/../vendor/autoload.php';
 
 // TODO: Figure out why (some of) these are required (the classes should be autoloaded instead)
-require_once TEST_FILES_PATH . 'BeforeAndAfterTest.php';
-require_once TEST_FILES_PATH . 'BeforeClassAndAfterClassTest.php';
-require_once TEST_FILES_PATH . 'TestWithTest.php';
-require_once TEST_FILES_PATH . 'BeforeClassWithOnlyDataProviderTest.php';
-require_once TEST_FILES_PATH . 'DataProviderSkippedTest.php';
-require_once TEST_FILES_PATH . 'DataProviderDependencyTest.php';
-require_once TEST_FILES_PATH . 'DataProviderIncompleteTest.php';
-require_once TEST_FILES_PATH . 'InheritedTestCase.php';
-require_once TEST_FILES_PATH . 'NoTestCaseClass.php';
-require_once TEST_FILES_PATH . 'NoTestCases.php';
-require_once TEST_FILES_PATH . 'NotPublicTestCase.php';
-require_once TEST_FILES_PATH . 'NotVoidTestCase.php';
-require_once TEST_FILES_PATH . 'OverrideTestCase.php';
-require_once TEST_FILES_PATH . 'RequirementsClassBeforeClassHookTest.php';
-require_once TEST_FILES_PATH . 'NoArgTestCaseTest.php';
-require_once TEST_FILES_PATH . 'Singleton.php';
-require_once TEST_FILES_PATH . 'Mockable.php';
-require_once TEST_FILES_PATH . 'CoverageNamespacedFunctionTest.php';
-require_once TEST_FILES_PATH . 'NamespaceCoveredFunction.php';
+require_once TEST_FILES_PATH.'BeforeAndAfterTest.php';
+require_once TEST_FILES_PATH.'BeforeClassAndAfterClassTest.php';
+require_once TEST_FILES_PATH.'TestWithTest.php';
+require_once TEST_FILES_PATH.'BeforeClassWithOnlyDataProviderTest.php';
+require_once TEST_FILES_PATH.'DataProviderSkippedTest.php';
+require_once TEST_FILES_PATH.'DataProviderDependencyTest.php';
+require_once TEST_FILES_PATH.'DataProviderIncompleteTest.php';
+require_once TEST_FILES_PATH.'InheritedTestCase.php';
+require_once TEST_FILES_PATH.'NoTestCaseClass.php';
+require_once TEST_FILES_PATH.'NoTestCases.php';
+require_once TEST_FILES_PATH.'NotPublicTestCase.php';
+require_once TEST_FILES_PATH.'NotVoidTestCase.php';
+require_once TEST_FILES_PATH.'OverrideTestCase.php';
+require_once TEST_FILES_PATH.'RequirementsClassBeforeClassHookTest.php';
+require_once TEST_FILES_PATH.'NoArgTestCaseTest.php';
+require_once TEST_FILES_PATH.'Singleton.php';
+require_once TEST_FILES_PATH.'Mockable.php';
+require_once TEST_FILES_PATH.'CoverageNamespacedFunctionTest.php';
+require_once TEST_FILES_PATH.'NamespaceCoveredFunction.php';

vendor/phpunit/phpunit/tests/Framework/BaseTestListenerTest.php

Indentation +13 added lines, -13 removed lines

@@ -12,21 +12,21 @@
 
 class BaseTestListenerTest extends TestCase
 {
-    /**
-     * @var TestResult
-     */
-    private $result;
+	/**
+	 * @var TestResult
+	 */
+	private $result;
 
-    public function testEndEventsAreCounted()
-    {
-        $this->result = new TestResult;
-        $listener     = new \BaseTestListenerSample;
+	public function testEndEventsAreCounted()
+	{
+		$this->result = new TestResult;
+		$listener     = new \BaseTestListenerSample;
 
-        $this->result->addListener($listener);
+		$this->result->addListener($listener);
 
-        $test = new \Success;
-        $test->run($this->result);
+		$test = new \Success;
+		$test->run($this->result);
 
-        $this->assertEquals(1, $listener->endCount);
-    }
+		$this->assertEquals(1, $listener->endCount);
+	}
 }

vendor/phpunit/phpunit/tests/Framework/ConstraintTest.php

Indentation +2043 added lines, -2043 removed lines

@@ -18,614 +18,614 @@ 
 
 class ConstraintTest extends TestCase
 {
-    public function testConstraintArrayHasKey()
-    {
-        $constraint = Assert::arrayHasKey(0);
-
-        $this->assertFalse($constraint->evaluate([], '', true));
-        $this->assertEquals('has the key 0', $constraint->toString());
-        $this->assertCount(1, $constraint);
-
-        try {
-            $constraint->evaluate([]);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+	public function testConstraintArrayHasKey()
+	{
+		$constraint = Assert::arrayHasKey(0);
+
+		$this->assertFalse($constraint->evaluate([], '', true));
+		$this->assertEquals('has the key 0', $constraint->toString());
+		$this->assertCount(1, $constraint);
+
+		try {
+			$constraint->evaluate([]);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that an array has the key 0.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintArrayHasKey2()
-    {
-        $constraint = Assert::arrayHasKey(0);
+	public function testConstraintArrayHasKey2()
+	{
+		$constraint = Assert::arrayHasKey(0);
 
-        try {
-            $constraint->evaluate([], 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate([], 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message\nFailed asserting that an array has the key 0.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintArrayNotHasKey()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::arrayHasKey(0)
-        );
+	public function testConstraintArrayNotHasKey()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::arrayHasKey(0)
+		);
 
-        $this->assertFalse($constraint->evaluate([0 => 1], '', true));
-        $this->assertEquals('does not have the key 0', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate([0 => 1], '', true));
+		$this->assertEquals('does not have the key 0', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate([0 => 1]);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate([0 => 1]);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that an array does not have the key 0.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintArrayNotHasKey2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::arrayHasKey(0)
-        );
+	public function testConstraintArrayNotHasKey2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::arrayHasKey(0)
+		);
 
-        try {
-            $constraint->evaluate([0], 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate([0], 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that an array does not have the key 0.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsReadable()
-    {
-        $constraint = Assert::isReadable();
+	public function testConstraintIsReadable()
+	{
+		$constraint = Assert::isReadable();
 
-        $this->assertFalse($constraint->evaluate('foo', '', true));
-        $this->assertEquals('is readable', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate('foo', '', true));
+		$this->assertEquals('is readable', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('foo');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('foo');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that "foo" is readable.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsWritable()
-    {
-        $constraint = Assert::isWritable();
+	public function testConstraintIsWritable()
+	{
+		$constraint = Assert::isWritable();
 
-        $this->assertFalse($constraint->evaluate('foo', '', true));
-        $this->assertEquals('is writable', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate('foo', '', true));
+		$this->assertEquals('is writable', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('foo');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('foo');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that "foo" is writable.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintDirectoryExists()
-    {
-        $constraint = Assert::directoryExists();
+	public function testConstraintDirectoryExists()
+	{
+		$constraint = Assert::directoryExists();
 
-        $this->assertFalse($constraint->evaluate('foo', '', true));
-        $this->assertEquals('directory exists', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate('foo', '', true));
+		$this->assertEquals('directory exists', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('foo');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('foo');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that directory "foo" exists.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintFileExists()
-    {
-        $constraint = Assert::fileExists();
+	public function testConstraintFileExists()
+	{
+		$constraint = Assert::fileExists();
 
-        $this->assertFalse($constraint->evaluate('foo', '', true));
-        $this->assertEquals('file exists', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate('foo', '', true));
+		$this->assertEquals('file exists', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('foo');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('foo');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that file "foo" exists.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintFileExists2()
-    {
-        $constraint = Assert::fileExists();
+	public function testConstraintFileExists2()
+	{
+		$constraint = Assert::fileExists();
 
-        try {
-            $constraint->evaluate('foo', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('foo', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that file "foo" exists.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintFileNotExists()
-    {
-        $file = \dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'ClassWithNonPublicAttributes.php';
+	public function testConstraintFileNotExists()
+	{
+		$file = \dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'ClassWithNonPublicAttributes.php';
 
-        $constraint = Assert::logicalNot(
-            Assert::fileExists()
-        );
+		$constraint = Assert::logicalNot(
+			Assert::fileExists()
+		);
 
-        $this->assertFalse($constraint->evaluate($file, '', true));
-        $this->assertEquals('file does not exist', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate($file, '', true));
+		$this->assertEquals('file does not exist', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate($file);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate($file);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that file "$file" does not exist.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintFileNotExists2()
-    {
-        $file = \dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'ClassWithNonPublicAttributes.php';
+	public function testConstraintFileNotExists2()
+	{
+		$file = \dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'ClassWithNonPublicAttributes.php';
 
-        $constraint = Assert::logicalNot(
-            Assert::fileExists()
-        );
+		$constraint = Assert::logicalNot(
+			Assert::fileExists()
+		);
 
-        try {
-            $constraint->evaluate($file, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate($file, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that file "$file" does not exist.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintGreaterThan()
-    {
-        $constraint = Assert::greaterThan(1);
+	public function testConstraintGreaterThan()
+	{
+		$constraint = Assert::greaterThan(1);
 
-        $this->assertFalse($constraint->evaluate(0, '', true));
-        $this->assertTrue($constraint->evaluate(2, '', true));
-        $this->assertEquals('is greater than 1', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate(0, '', true));
+		$this->assertTrue($constraint->evaluate(2, '', true));
+		$this->assertEquals('is greater than 1', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(0);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(0);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 0 is greater than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintGreaterThan2()
-    {
-        $constraint = Assert::greaterThan(1);
+	public function testConstraintGreaterThan2()
+	{
+		$constraint = Assert::greaterThan(1);
 
-        try {
-            $constraint->evaluate(0, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(0, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 0 is greater than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintNotGreaterThan()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::greaterThan(1)
-        );
+	public function testConstraintNotGreaterThan()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::greaterThan(1)
+		);
 
-        $this->assertTrue($constraint->evaluate(1, '', true));
-        $this->assertEquals('is not greater than 1', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(1, '', true));
+		$this->assertEquals('is not greater than 1', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(2);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(2);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 2 is not greater than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintNotGreaterThan2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::greaterThan(1)
-        );
+	public function testConstraintNotGreaterThan2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::greaterThan(1)
+		);
 
-        try {
-            $constraint->evaluate(2, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(2, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 2 is not greater than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintGreaterThanOrEqual()
-    {
-        $constraint = Assert::greaterThanOrEqual(1);
+	public function testConstraintGreaterThanOrEqual()
+	{
+		$constraint = Assert::greaterThanOrEqual(1);
 
-        $this->assertTrue($constraint->evaluate(1, '', true));
-        $this->assertFalse($constraint->evaluate(0, '', true));
-        $this->assertEquals('is equal to 1 or is greater than 1', $constraint->toString());
-        $this->assertCount(2, $constraint);
+		$this->assertTrue($constraint->evaluate(1, '', true));
+		$this->assertFalse($constraint->evaluate(0, '', true));
+		$this->assertEquals('is equal to 1 or is greater than 1', $constraint->toString());
+		$this->assertCount(2, $constraint);
 
-        try {
-            $constraint->evaluate(0);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(0);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 0 is equal to 1 or is greater than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintGreaterThanOrEqual2()
-    {
-        $constraint = Assert::greaterThanOrEqual(1);
+	public function testConstraintGreaterThanOrEqual2()
+	{
+		$constraint = Assert::greaterThanOrEqual(1);
 
-        try {
-            $constraint->evaluate(0, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(0, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 0 is equal to 1 or is greater than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintNotGreaterThanOrEqual()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::greaterThanOrEqual(1)
-        );
+	public function testConstraintNotGreaterThanOrEqual()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::greaterThanOrEqual(1)
+		);
 
-        $this->assertFalse($constraint->evaluate(1, '', true));
-        $this->assertEquals('not( is equal to 1 or is greater than 1 )', $constraint->toString());
-        $this->assertCount(2, $constraint);
+		$this->assertFalse($constraint->evaluate(1, '', true));
+		$this->assertEquals('not( is equal to 1 or is greater than 1 )', $constraint->toString());
+		$this->assertCount(2, $constraint);
 
-        try {
-            $constraint->evaluate(1);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(1);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that not( 1 is equal to 1 or is greater than 1 ).
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintNotGreaterThanOrEqual2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::greaterThanOrEqual(1)
-        );
+	public function testConstraintNotGreaterThanOrEqual2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::greaterThanOrEqual(1)
+		);
 
-        try {
-            $constraint->evaluate(1, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(1, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that not( 1 is equal to 1 or is greater than 1 ).
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsAnything()
-    {
-        $constraint = Assert::anything();
+	public function testConstraintIsAnything()
+	{
+		$constraint = Assert::anything();
 
-        $this->assertTrue($constraint->evaluate(null, '', true));
-        $this->assertNull($constraint->evaluate(null));
-        $this->assertEquals('is anything', $constraint->toString());
-        $this->assertCount(0, $constraint);
-    }
+		$this->assertTrue($constraint->evaluate(null, '', true));
+		$this->assertNull($constraint->evaluate(null));
+		$this->assertEquals('is anything', $constraint->toString());
+		$this->assertCount(0, $constraint);
+	}
 
-    public function testConstraintNotIsAnything()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::anything()
-        );
+	public function testConstraintNotIsAnything()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::anything()
+		);
 
-        $this->assertFalse($constraint->evaluate(null, '', true));
-        $this->assertEquals('is not anything', $constraint->toString());
-        $this->assertCount(0, $constraint);
+		$this->assertFalse($constraint->evaluate(null, '', true));
+		$this->assertEquals('is not anything', $constraint->toString());
+		$this->assertCount(0, $constraint);
 
-        try {
-            $constraint->evaluate(null);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(null);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that null is not anything.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsEqual()
-    {
-        $constraint = Assert::equalTo(1);
+	public function testConstraintIsEqual()
+	{
+		$constraint = Assert::equalTo(1);
 
-        $this->assertTrue($constraint->evaluate(1, '', true));
-        $this->assertFalse($constraint->evaluate(0, '', true));
-        $this->assertEquals('is equal to 1', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(1, '', true));
+		$this->assertFalse($constraint->evaluate(0, '', true));
+		$this->assertEquals('is equal to 1', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(0);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(0);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 0 matches expected 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
-
-            return;
-        }
-
-        $this->fail();
-    }
-
-    public function isEqualProvider()
-    {
-        $a      = new \stdClass;
-        $a->foo = 'bar';
-        $b      = new \stdClass;
-        $ahash  = \spl_object_hash($a);
-        $bhash  = \spl_object_hash($b);
-
-        $c               = new \stdClass;
-        $c->foo          = 'bar';
-        $c->int          = 1;
-        $c->array        = [0, [1], [2], 3];
-        $c->related      = new \stdClass;
-        $c->related->foo = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk";
-        $c->self         = $c;
-        $c->c            = $c;
-        $d               = new \stdClass;
-        $d->foo          = 'bar';
-        $d->int          = 2;
-        $d->array        = [0, [4], [2], 3];
-        $d->related      = new \stdClass;
-        $d->related->foo = "a\np\nc\nd\ne\nf\ng\nh\ni\nw\nk";
-        $d->self         = $d;
-        $d->c            = $c;
-
-        $storage1 = new \SplObjectStorage;
-        $storage1->attach($a);
-        $storage1->attach($b);
-        $storage2 = new \SplObjectStorage;
-        $storage2->attach($b);
-        $storage1hash = \spl_object_hash($storage1);
-        $storage2hash = \spl_object_hash($storage2);
-
-        $dom1                     = new \DOMDocument;
-        $dom1->preserveWhiteSpace = false;
-        $dom1->loadXML('<root></root>');
-        $dom2                     = new \DOMDocument;
-        $dom2->preserveWhiteSpace = false;
-        $dom2->loadXML('<root><foo/></root>');
-
-        $data = [
-            [1, 0, <<<EOF
+				,
+				TestFailure::exceptionToString($e)
+			);
+
+			return;
+		}
+
+		$this->fail();
+	}
+
+	public function isEqualProvider()
+	{
+		$a      = new \stdClass;
+		$a->foo = 'bar';
+		$b      = new \stdClass;
+		$ahash  = \spl_object_hash($a);
+		$bhash  = \spl_object_hash($b);
+
+		$c               = new \stdClass;
+		$c->foo          = 'bar';
+		$c->int          = 1;
+		$c->array        = [0, [1], [2], 3];
+		$c->related      = new \stdClass;
+		$c->related->foo = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk";
+		$c->self         = $c;
+		$c->c            = $c;
+		$d               = new \stdClass;
+		$d->foo          = 'bar';
+		$d->int          = 2;
+		$d->array        = [0, [4], [2], 3];
+		$d->related      = new \stdClass;
+		$d->related->foo = "a\np\nc\nd\ne\nf\ng\nh\ni\nw\nk";
+		$d->self         = $d;
+		$d->c            = $c;
+
+		$storage1 = new \SplObjectStorage;
+		$storage1->attach($a);
+		$storage1->attach($b);
+		$storage2 = new \SplObjectStorage;
+		$storage2->attach($b);
+		$storage1hash = \spl_object_hash($storage1);
+		$storage2hash = \spl_object_hash($storage2);
+
+		$dom1                     = new \DOMDocument;
+		$dom1->preserveWhiteSpace = false;
+		$dom1->loadXML('<root></root>');
+		$dom2                     = new \DOMDocument;
+		$dom2->preserveWhiteSpace = false;
+		$dom2->loadXML('<root><foo/></root>');
+
+		$data = [
+			[1, 0, <<<EOF
 Failed asserting that 0 matches expected 1.
 
 EOF
-            ],
-            [1.1, 0, <<<EOF
+			],
+			[1.1, 0, <<<EOF
 Failed asserting that 0 matches expected 1.1.
 
 EOF
-            ],
-            ['a', 'b', <<<EOF
+			],
+			['a', 'b', <<<EOF
 Failed asserting that two strings are equal.
 --- Expected
 +++ Actual
@@ -634,8 +634,8 @@ 
 +'b'
 
 EOF
-            ],
-            ["a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk", "a\np\nc\nd\ne\nf\ng\nh\ni\nw\nk", <<<EOF
+			],
+			["a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk", "a\np\nc\nd\ne\nf\ng\nh\ni\nw\nk", <<<EOF
 Failed asserting that two strings are equal.
 --- Expected
 +++ Actual
@@ -648,18 +648,18 @@ 
 +w\\n
 
 EOF
-            ],
-            [1, [0], <<<EOF
+			],
+			[1, [0], <<<EOF
 Array (...) does not match expected type "integer".
 
 EOF
-            ],
-            [[0], 1, <<<EOF
+			],
+			[[0], 1, <<<EOF
 1 does not match expected type "array".
 
 EOF
-            ],
-            [[0], [1], <<<EOF
+			],
+			[[0], [1], <<<EOF
 Failed asserting that two arrays are equal.
 --- Expected
 +++ Actual
@@ -669,8 +669,8 @@ 
 +    0 => 1
 
 EOF
-            ],
-            [[true], ['true'], <<<EOF
+			],
+			[[true], ['true'], <<<EOF
 Failed asserting that two arrays are equal.
 --- Expected
 +++ Actual
@@ -680,8 +680,8 @@ 
 +    0 => 'true'
 
 EOF
-            ],
-            [[0, [1], [2], 3], [0, [4], [2], 3], <<<EOF
+			],
+			[[0, [1], [2], 3], [0, [4], [2], 3], <<<EOF
 Failed asserting that two arrays are equal.
 --- Expected
 +++ Actual
@@ -693,18 +693,18 @@ 
 +        0 => 4
 
 EOF
-            ],
-            [$a, [0], <<<EOF
+			],
+			[$a, [0], <<<EOF
 Array (...) does not match expected type "object".
 
 EOF
-            ],
-            [[0], $a, <<<EOF
+			],
+			[[0], $a, <<<EOF
 stdClass Object (...) does not match expected type "array".
 
 EOF
-            ],
-            [$a, $b, <<<EOF
+			],
+			[$a, $b, <<<EOF
 Failed asserting that two objects are equal.
 --- Expected
 +++ Actual
@@ -713,8 +713,8 @@ 
 -    'foo' => 'bar'
 
 EOF
-            ],
-            [$c, $d, <<<EOF
+			],
+			[$c, $d, <<<EOF
 Failed asserting that two objects are equal.
 --- Expected
 +++ Actual
@@ -736,8 +736,8 @@ 
 +        w\\n
 
 EOF
-            ],
-            [$dom1, $dom2, <<<EOF
+			],
+			[$dom1, $dom2, <<<EOF
 Failed asserting that two DOM documents are equal.
 --- Expected
 +++ Actual
@@ -749,11 +749,11 @@ 
 +</root>
 
 EOF
-            ],
-            [
-              new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/New_York')),
-              new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/Chicago')),
-              <<<EOF
+			],
+			[
+			  new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/New_York')),
+			  new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/Chicago')),
+			  <<<EOF
 Failed asserting that two DateTime objects are equal.
 --- Expected
 +++ Actual
@@ -762,11 +762,11 @@ 
 +2013-03-29T04:13:35.000000-0500
 
 EOF
-            ],
-        ];
+			],
+		];
 
-        if (PHP_MAJOR_VERSION < 7) {
-            $data[] = [$storage1, $storage2, <<<EOF
+		if (PHP_MAJOR_VERSION < 7) {
+			$data[] = [$storage1, $storage2, <<<EOF
 Failed asserting that two objects are equal.
 --- Expected
 +++ Actual
@@ -783,9 +783,9 @@ 
 +    '$bhash' => Array &0 (
 
 EOF
-            ];
-        } else {
-            $data[] = [$storage1, $storage2, <<<EOF
+			];
+		} else {
+			$data[] = [$storage1, $storage2, <<<EOF
 Failed asserting that two objects are equal.
 --- Expected
 +++ Actual
@@ -802,152 +802,152 @@ 
 +    '$bhash' => Array &0 (
 
 EOF
-            ];
-        }
-
-        return $data;
-    }
-
-    /**
-     * @dataProvider isEqualProvider
-     */
-    public function testConstraintIsEqual2($expected, $actual, $message)
-    {
-        $constraint = Assert::equalTo($expected);
-
-        try {
-            $constraint->evaluate($actual, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                "custom message\n$message",
-                $this->trimnl(TestFailure::exceptionToString($e))
-            );
-
-            return;
-        }
-
-        $this->fail();
-    }
-
-    public function testConstraintIsNotEqual()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::equalTo(1)
-        );
-
-        $this->assertTrue($constraint->evaluate(0, '', true));
-        $this->assertFalse($constraint->evaluate(1, '', true));
-        $this->assertEquals('is not equal to 1', $constraint->toString());
-        $this->assertCount(1, $constraint);
-
-        try {
-            $constraint->evaluate(1);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+			];
+		}
+
+		return $data;
+	}
+
+	/**
+	 * @dataProvider isEqualProvider
+	 */
+	public function testConstraintIsEqual2($expected, $actual, $message)
+	{
+		$constraint = Assert::equalTo($expected);
+
+		try {
+			$constraint->evaluate($actual, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				"custom message\n$message",
+				$this->trimnl(TestFailure::exceptionToString($e))
+			);
+
+			return;
+		}
+
+		$this->fail();
+	}
+
+	public function testConstraintIsNotEqual()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::equalTo(1)
+		);
+
+		$this->assertTrue($constraint->evaluate(0, '', true));
+		$this->assertFalse($constraint->evaluate(1, '', true));
+		$this->assertEquals('is not equal to 1', $constraint->toString());
+		$this->assertCount(1, $constraint);
+
+		try {
+			$constraint->evaluate(1);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 1 is not equal to 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsNotEqual2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::equalTo(1)
-        );
+	public function testConstraintIsNotEqual2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::equalTo(1)
+		);
 
-        try {
-            $constraint->evaluate(1, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(1, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 1 is not equal to 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsIdentical()
-    {
-        $a = new \stdClass;
-        $b = new \stdClass;
+	public function testConstraintIsIdentical()
+	{
+		$a = new \stdClass;
+		$b = new \stdClass;
 
-        $constraint = Assert::identicalTo($a);
+		$constraint = Assert::identicalTo($a);
 
-        $this->assertFalse($constraint->evaluate($b, '', true));
-        $this->assertTrue($constraint->evaluate($a, '', true));
-        $this->assertEquals('is identical to an object of class "stdClass"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate($b, '', true));
+		$this->assertTrue($constraint->evaluate($a, '', true));
+		$this->assertEquals('is identical to an object of class "stdClass"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate($b);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate($b);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that two variables reference the same object.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsIdentical2()
-    {
-        $a = new \stdClass;
-        $b = new \stdClass;
+	public function testConstraintIsIdentical2()
+	{
+		$a = new \stdClass;
+		$b = new \stdClass;
 
-        $constraint = Assert::identicalTo($a);
+		$constraint = Assert::identicalTo($a);
 
-        try {
-            $constraint->evaluate($b, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate($b, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that two variables reference the same object.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsIdentical3()
-    {
-        $constraint = Assert::identicalTo('a');
+	public function testConstraintIsIdentical3()
+	{
+		$constraint = Assert::identicalTo('a');
 
-        try {
-            $constraint->evaluate('b', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('b', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that two strings are identical.
 --- Expected
@@ -957,2055 +957,2055 @@ 
 +'b'
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsNotIdentical()
-    {
-        $a = new \stdClass;
-        $b = new \stdClass;
+	public function testConstraintIsNotIdentical()
+	{
+		$a = new \stdClass;
+		$b = new \stdClass;
 
-        $constraint = Assert::logicalNot(
-            Assert::identicalTo($a)
-        );
+		$constraint = Assert::logicalNot(
+			Assert::identicalTo($a)
+		);
 
-        $this->assertTrue($constraint->evaluate($b, '', true));
-        $this->assertFalse($constraint->evaluate($a, '', true));
-        $this->assertEquals('is not identical to an object of class "stdClass"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate($b, '', true));
+		$this->assertFalse($constraint->evaluate($a, '', true));
+		$this->assertEquals('is not identical to an object of class "stdClass"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate($a);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate($a);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that two variables don't reference the same object.
 
 EOF
-                ,
-                $this->trimnl(TestFailure::exceptionToString($e))
-            );
+				,
+				$this->trimnl(TestFailure::exceptionToString($e))
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsNotIdentical2()
-    {
-        $a = new \stdClass;
+	public function testConstraintIsNotIdentical2()
+	{
+		$a = new \stdClass;
 
-        $constraint = Assert::logicalNot(
-            Assert::identicalTo($a)
-        );
+		$constraint = Assert::logicalNot(
+			Assert::identicalTo($a)
+		);
 
-        try {
-            $constraint->evaluate($a, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate($a, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that two variables don't reference the same object.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsNotIdentical3()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::identicalTo('a')
-        );
+	public function testConstraintIsNotIdentical3()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::identicalTo('a')
+		);
 
-        try {
-            $constraint->evaluate('a', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('a', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that two strings are not identical.
 
 EOF
-                ,
-                $this->trimnl(TestFailure::exceptionToString($e))
-            );
+				,
+				$this->trimnl(TestFailure::exceptionToString($e))
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsInstanceOf()
-    {
-        $constraint = Assert::isInstanceOf(\Exception::class);
+	public function testConstraintIsInstanceOf()
+	{
+		$constraint = Assert::isInstanceOf(\Exception::class);
 
-        $this->assertFalse($constraint->evaluate(new \stdClass, '', true));
-        $this->assertTrue($constraint->evaluate(new \Exception, '', true));
-        $this->assertEquals('is instance of class "Exception"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate(new \stdClass, '', true));
+		$this->assertTrue($constraint->evaluate(new \Exception, '', true));
+		$this->assertEquals('is instance of class "Exception"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        $interfaceConstraint = Assert::isInstanceOf(\Countable::class);
-        $this->assertFalse($interfaceConstraint->evaluate(new \stdClass, '', true));
-        $this->assertTrue($interfaceConstraint->evaluate(new \ArrayObject, '', true));
-        $this->assertEquals('is instance of interface "Countable"', $interfaceConstraint->toString());
+		$interfaceConstraint = Assert::isInstanceOf(\Countable::class);
+		$this->assertFalse($interfaceConstraint->evaluate(new \stdClass, '', true));
+		$this->assertTrue($interfaceConstraint->evaluate(new \ArrayObject, '', true));
+		$this->assertEquals('is instance of interface "Countable"', $interfaceConstraint->toString());
 
-        try {
-            $constraint->evaluate(new \stdClass);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \stdClass);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that stdClass Object () is an instance of class "Exception".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsInstanceOf2()
-    {
-        $constraint = Assert::isInstanceOf(\Exception::class);
+	public function testConstraintIsInstanceOf2()
+	{
+		$constraint = Assert::isInstanceOf(\Exception::class);
 
-        try {
-            $constraint->evaluate(new \stdClass, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \stdClass, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that stdClass Object () is an instance of class "Exception".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsNotInstanceOf()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::isInstanceOf(\stdClass::class)
-        );
+	public function testConstraintIsNotInstanceOf()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::isInstanceOf(\stdClass::class)
+		);
 
-        $this->assertFalse($constraint->evaluate(new \stdClass, '', true));
-        $this->assertTrue($constraint->evaluate(new Exception, '', true));
-        $this->assertEquals('is not instance of class "stdClass"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate(new \stdClass, '', true));
+		$this->assertTrue($constraint->evaluate(new Exception, '', true));
+		$this->assertEquals('is not instance of class "stdClass"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(new \stdClass);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \stdClass);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that stdClass Object () is not an instance of class "stdClass".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsNotInstanceOf2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::isInstanceOf(\stdClass::class)
-        );
+	public function testConstraintIsNotInstanceOf2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::isInstanceOf(\stdClass::class)
+		);
 
-        try {
-            $constraint->evaluate(new \stdClass, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \stdClass, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that stdClass Object () is not an instance of class "stdClass".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsType()
-    {
-        $constraint = Assert::isType('string');
+	public function testConstraintIsType()
+	{
+		$constraint = Assert::isType('string');
 
-        $this->assertFalse($constraint->evaluate(0, '', true));
-        $this->assertTrue($constraint->evaluate('', '', true));
-        $this->assertEquals('is of type "string"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate(0, '', true));
+		$this->assertTrue($constraint->evaluate('', '', true));
+		$this->assertEquals('is of type "string"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(new \stdClass);
-        } catch (ExpectationFailedException $e) {
-            $this->assertStringMatchesFormat(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \stdClass);
+		} catch (ExpectationFailedException $e) {
+			$this->assertStringMatchesFormat(
+				<<<EOF
 Failed asserting that stdClass Object &%x () is of type "string".
 
 EOF
-                ,
-                $this->trimnl(TestFailure::exceptionToString($e))
-            );
+				,
+				$this->trimnl(TestFailure::exceptionToString($e))
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsType2()
-    {
-        $constraint = Assert::isType('string');
+	public function testConstraintIsType2()
+	{
+		$constraint = Assert::isType('string');
 
-        try {
-            $constraint->evaluate(new \stdClass, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertStringMatchesFormat(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \stdClass, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertStringMatchesFormat(
+				<<<EOF
 custom message
 Failed asserting that stdClass Object &%x () is of type "string".
 
 EOF
-                ,
-                $this->trimnl(TestFailure::exceptionToString($e))
-            );
+				,
+				$this->trimnl(TestFailure::exceptionToString($e))
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function resources()
-    {
-        $fh = \fopen(__FILE__, 'r');
-        \fclose($fh);
+	public function resources()
+	{
+		$fh = \fopen(__FILE__, 'r');
+		\fclose($fh);
 
-        return [
-            'open resource'     => [\fopen(__FILE__, 'r')],
-            'closed resource'   => [$fh],
-        ];
-    }
+		return [
+			'open resource'     => [\fopen(__FILE__, 'r')],
+			'closed resource'   => [$fh],
+		];
+	}
 
-    /**
-     * @dataProvider resources
-     */
-    public function testConstraintIsResourceTypeEvaluatesCorrectlyWithResources($resource)
-    {
-        $constraint = Assert::isType('resource');
+	/**
+	 * @dataProvider resources
+	 */
+	public function testConstraintIsResourceTypeEvaluatesCorrectlyWithResources($resource)
+	{
+		$constraint = Assert::isType('resource');
 
-        $this->assertTrue($constraint->evaluate($resource, '', true));
+		$this->assertTrue($constraint->evaluate($resource, '', true));
 
-        @\fclose($resource);
-    }
+		@\fclose($resource);
+	}
 
-    public function testConstraintIsNotType()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::isType('string')
-        );
+	public function testConstraintIsNotType()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::isType('string')
+		);
 
-        $this->assertTrue($constraint->evaluate(0, '', true));
-        $this->assertFalse($constraint->evaluate('', '', true));
-        $this->assertEquals('is not of type "string"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(0, '', true));
+		$this->assertFalse($constraint->evaluate('', '', true));
+		$this->assertEquals('is not of type "string"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that '' is not of type "string".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsNotType2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::isType('string')
-        );
+	public function testConstraintIsNotType2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::isType('string')
+		);
 
-        try {
-            $constraint->evaluate('', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that '' is not of type "string".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsNull()
-    {
-        $constraint = Assert::isNull();
+	public function testConstraintIsNull()
+	{
+		$constraint = Assert::isNull();
 
-        $this->assertFalse($constraint->evaluate(0, '', true));
-        $this->assertTrue($constraint->evaluate(null, '', true));
-        $this->assertEquals('is null', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate(0, '', true));
+		$this->assertTrue($constraint->evaluate(null, '', true));
+		$this->assertEquals('is null', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(0);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(0);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 0 is null.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsNull2()
-    {
-        $constraint = Assert::isNull();
+	public function testConstraintIsNull2()
+	{
+		$constraint = Assert::isNull();
 
-        try {
-            $constraint->evaluate(0, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(0, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 0 is null.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsNotNull()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::isNull()
-        );
+	public function testConstraintIsNotNull()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::isNull()
+		);
 
-        $this->assertFalse($constraint->evaluate(null, '', true));
-        $this->assertTrue($constraint->evaluate(0, '', true));
-        $this->assertEquals('is not null', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate(null, '', true));
+		$this->assertTrue($constraint->evaluate(0, '', true));
+		$this->assertEquals('is not null', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(null);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(null);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that null is not null.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsNotNull2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::isNull()
-        );
+	public function testConstraintIsNotNull2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::isNull()
+		);
 
-        try {
-            $constraint->evaluate(null, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(null, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that null is not null.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintLessThan()
-    {
-        $constraint = Assert::lessThan(1);
+	public function testConstraintLessThan()
+	{
+		$constraint = Assert::lessThan(1);
 
-        $this->assertTrue($constraint->evaluate(0, '', true));
-        $this->assertFalse($constraint->evaluate(1, '', true));
-        $this->assertEquals('is less than 1', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(0, '', true));
+		$this->assertFalse($constraint->evaluate(1, '', true));
+		$this->assertEquals('is less than 1', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(1);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(1);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 1 is less than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintLessThan2()
-    {
-        $constraint = Assert::lessThan(1);
+	public function testConstraintLessThan2()
+	{
+		$constraint = Assert::lessThan(1);
 
-        try {
-            $constraint->evaluate(1, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(1, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 1 is less than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintNotLessThan()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::lessThan(1)
-        );
+	public function testConstraintNotLessThan()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::lessThan(1)
+		);
 
-        $this->assertTrue($constraint->evaluate(1, '', true));
-        $this->assertFalse($constraint->evaluate(0, '', true));
-        $this->assertEquals('is not less than 1', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(1, '', true));
+		$this->assertFalse($constraint->evaluate(0, '', true));
+		$this->assertEquals('is not less than 1', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(0);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(0);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 0 is not less than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintNotLessThan2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::lessThan(1)
-        );
+	public function testConstraintNotLessThan2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::lessThan(1)
+		);
 
-        try {
-            $constraint->evaluate(0, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(0, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 0 is not less than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintLessThanOrEqual()
-    {
-        $constraint = Assert::lessThanOrEqual(1);
+	public function testConstraintLessThanOrEqual()
+	{
+		$constraint = Assert::lessThanOrEqual(1);
 
-        $this->assertTrue($constraint->evaluate(1, '', true));
-        $this->assertFalse($constraint->evaluate(2, '', true));
-        $this->assertEquals('is equal to 1 or is less than 1', $constraint->toString());
-        $this->assertCount(2, $constraint);
+		$this->assertTrue($constraint->evaluate(1, '', true));
+		$this->assertFalse($constraint->evaluate(2, '', true));
+		$this->assertEquals('is equal to 1 or is less than 1', $constraint->toString());
+		$this->assertCount(2, $constraint);
 
-        try {
-            $constraint->evaluate(2);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(2);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 2 is equal to 1 or is less than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintCallback()
-    {
-        $closureReflect = function ($parameter) {
-            return $parameter;
-        };
+	public function testConstraintCallback()
+	{
+		$closureReflect = function ($parameter) {
+			return $parameter;
+		};
 
-        $closureWithoutParameter = function () {
-            return true;
-        };
+		$closureWithoutParameter = function () {
+			return true;
+		};
 
-        $constraint = Assert::callback($closureWithoutParameter);
-        $this->assertTrue($constraint->evaluate('', '', true));
+		$constraint = Assert::callback($closureWithoutParameter);
+		$this->assertTrue($constraint->evaluate('', '', true));
 
-        $constraint = Assert::callback($closureReflect);
-        $this->assertTrue($constraint->evaluate(true, '', true));
-        $this->assertFalse($constraint->evaluate(false, '', true));
+		$constraint = Assert::callback($closureReflect);
+		$this->assertTrue($constraint->evaluate(true, '', true));
+		$this->assertFalse($constraint->evaluate(false, '', true));
 
-        $callback   = [$this, 'callbackReturningTrue'];
-        $constraint = Assert::callback($callback);
-        $this->assertTrue($constraint->evaluate(false, '', true));
+		$callback   = [$this, 'callbackReturningTrue'];
+		$constraint = Assert::callback($callback);
+		$this->assertTrue($constraint->evaluate(false, '', true));
 
-        $callback   = [self::class, 'staticCallbackReturningTrue'];
-        $constraint = Assert::callback($callback);
-        $this->assertTrue($constraint->evaluate(null, '', true));
+		$callback   = [self::class, 'staticCallbackReturningTrue'];
+		$constraint = Assert::callback($callback);
+		$this->assertTrue($constraint->evaluate(null, '', true));
 
-        $this->assertEquals('is accepted by specified callback', $constraint->toString());
-    }
+		$this->assertEquals('is accepted by specified callback', $constraint->toString());
+	}
 
-    public function testConstraintCallbackFailure()
-    {
-        $constraint = Assert::callback(function () {
-            return false;
-        });
+	public function testConstraintCallbackFailure()
+	{
+		$constraint = Assert::callback(function () {
+			return false;
+		});
 
-        $this->expectException(ExpectationFailedException::class);
-        $this->expectExceptionMessage('Failed asserting that \'This fails\' is accepted by specified callback.');
+		$this->expectException(ExpectationFailedException::class);
+		$this->expectExceptionMessage('Failed asserting that \'This fails\' is accepted by specified callback.');
 
-        $constraint->evaluate('This fails');
-    }
+		$constraint->evaluate('This fails');
+	}
 
-    public function callbackReturningTrue()
-    {
-        return true;
-    }
+	public function callbackReturningTrue()
+	{
+		return true;
+	}
 
-    public static function staticCallbackReturningTrue()
-    {
-        return true;
-    }
+	public static function staticCallbackReturningTrue()
+	{
+		return true;
+	}
 
-    public function testConstraintLessThanOrEqual2()
-    {
-        $constraint = Assert::lessThanOrEqual(1);
+	public function testConstraintLessThanOrEqual2()
+	{
+		$constraint = Assert::lessThanOrEqual(1);
 
-        try {
-            $constraint->evaluate(2, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(2, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 2 is equal to 1 or is less than 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintNotLessThanOrEqual()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::lessThanOrEqual(1)
-        );
+	public function testConstraintNotLessThanOrEqual()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::lessThanOrEqual(1)
+		);
 
-        $this->assertTrue($constraint->evaluate(2, '', true));
-        $this->assertFalse($constraint->evaluate(1, '', true));
-        $this->assertEquals('not( is equal to 1 or is less than 1 )', $constraint->toString());
-        $this->assertCount(2, $constraint);
+		$this->assertTrue($constraint->evaluate(2, '', true));
+		$this->assertFalse($constraint->evaluate(1, '', true));
+		$this->assertEquals('not( is equal to 1 or is less than 1 )', $constraint->toString());
+		$this->assertCount(2, $constraint);
 
-        try {
-            $constraint->evaluate(1);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(1);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that not( 1 is equal to 1 or is less than 1 ).
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintNotLessThanOrEqual2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::lessThanOrEqual(1)
-        );
+	public function testConstraintNotLessThanOrEqual2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::lessThanOrEqual(1)
+		);
 
-        try {
-            $constraint->evaluate(1, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(1, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that not( 1 is equal to 1 or is less than 1 ).
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintClassHasAttribute()
-    {
-        $constraint = Assert::classHasAttribute('privateAttribute');
+	public function testConstraintClassHasAttribute()
+	{
+		$constraint = Assert::classHasAttribute('privateAttribute');
 
-        $this->assertTrue($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
-        $this->assertFalse($constraint->evaluate(\stdClass::class, '', true));
-        $this->assertEquals('has attribute "privateAttribute"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
+		$this->assertFalse($constraint->evaluate(\stdClass::class, '', true));
+		$this->assertEquals('has attribute "privateAttribute"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(\stdClass::class);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(\stdClass::class);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that class "stdClass" has attribute "privateAttribute".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintClassHasAttribute2()
-    {
-        $constraint = Assert::classHasAttribute('privateAttribute');
+	public function testConstraintClassHasAttribute2()
+	{
+		$constraint = Assert::classHasAttribute('privateAttribute');
 
-        try {
-            $constraint->evaluate(\stdClass::class, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(\stdClass::class, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that class "stdClass" has attribute "privateAttribute".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintClassNotHasAttribute()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::classHasAttribute('privateAttribute')
-        );
+	public function testConstraintClassNotHasAttribute()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::classHasAttribute('privateAttribute')
+		);
 
-        $this->assertTrue($constraint->evaluate(\stdClass::class, '', true));
-        $this->assertFalse($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
-        $this->assertEquals('does not have attribute "privateAttribute"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(\stdClass::class, '', true));
+		$this->assertFalse($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
+		$this->assertEquals('does not have attribute "privateAttribute"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(\ClassWithNonPublicAttributes::class);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(\ClassWithNonPublicAttributes::class);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintClassNotHasAttribute2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::classHasAttribute('privateAttribute')
-        );
+	public function testConstraintClassNotHasAttribute2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::classHasAttribute('privateAttribute')
+		);
 
-        try {
-            $constraint->evaluate(\ClassWithNonPublicAttributes::class, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(\ClassWithNonPublicAttributes::class, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintClassHasStaticAttribute()
-    {
-        $constraint = Assert::classHasStaticAttribute('privateStaticAttribute');
+	public function testConstraintClassHasStaticAttribute()
+	{
+		$constraint = Assert::classHasStaticAttribute('privateStaticAttribute');
 
-        $this->assertTrue($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
-        $this->assertFalse($constraint->evaluate(\stdClass::class, '', true));
-        $this->assertEquals('has static attribute "privateStaticAttribute"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
+		$this->assertFalse($constraint->evaluate(\stdClass::class, '', true));
+		$this->assertEquals('has static attribute "privateStaticAttribute"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(\stdClass::class);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(\stdClass::class);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that class "stdClass" has static attribute "privateStaticAttribute".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintClassHasStaticAttribute2()
-    {
-        $constraint = Assert::classHasStaticAttribute('foo');
+	public function testConstraintClassHasStaticAttribute2()
+	{
+		$constraint = Assert::classHasStaticAttribute('foo');
 
-        try {
-            $constraint->evaluate(\stdClass::class, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(\stdClass::class, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that class "stdClass" has static attribute "foo".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintClassNotHasStaticAttribute()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::classHasStaticAttribute('privateStaticAttribute')
-        );
+	public function testConstraintClassNotHasStaticAttribute()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::classHasStaticAttribute('privateStaticAttribute')
+		);
 
-        $this->assertTrue($constraint->evaluate(\stdClass::class, '', true));
-        $this->assertFalse($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
-        $this->assertEquals('does not have static attribute "privateStaticAttribute"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(\stdClass::class, '', true));
+		$this->assertFalse($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
+		$this->assertEquals('does not have static attribute "privateStaticAttribute"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(\ClassWithNonPublicAttributes::class);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(\ClassWithNonPublicAttributes::class);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that class "ClassWithNonPublicAttributes" does not have static attribute "privateStaticAttribute".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintClassNotHasStaticAttribute2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::classHasStaticAttribute('privateStaticAttribute')
-        );
+	public function testConstraintClassNotHasStaticAttribute2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::classHasStaticAttribute('privateStaticAttribute')
+		);
 
-        try {
-            $constraint->evaluate(\ClassWithNonPublicAttributes::class, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(\ClassWithNonPublicAttributes::class, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that class "ClassWithNonPublicAttributes" does not have static attribute "privateStaticAttribute".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintObjectHasAttribute()
-    {
-        $constraint = Assert::objectHasAttribute('privateAttribute');
+	public function testConstraintObjectHasAttribute()
+	{
+		$constraint = Assert::objectHasAttribute('privateAttribute');
 
-        $this->assertTrue($constraint->evaluate(new \ClassWithNonPublicAttributes, '', true));
-        $this->assertFalse($constraint->evaluate(new \stdClass, '', true));
-        $this->assertEquals('has attribute "privateAttribute"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(new \ClassWithNonPublicAttributes, '', true));
+		$this->assertFalse($constraint->evaluate(new \stdClass, '', true));
+		$this->assertEquals('has attribute "privateAttribute"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(new \stdClass);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \stdClass);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that object of class "stdClass" has attribute "privateAttribute".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintObjectHasAttribute2()
-    {
-        $constraint = Assert::objectHasAttribute('privateAttribute');
+	public function testConstraintObjectHasAttribute2()
+	{
+		$constraint = Assert::objectHasAttribute('privateAttribute');
 
-        try {
-            $constraint->evaluate(new \stdClass, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \stdClass, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that object of class "stdClass" has attribute "privateAttribute".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintObjectNotHasAttribute()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::objectHasAttribute('privateAttribute')
-        );
+	public function testConstraintObjectNotHasAttribute()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::objectHasAttribute('privateAttribute')
+		);
 
-        $this->assertTrue($constraint->evaluate(new \stdClass, '', true));
-        $this->assertFalse($constraint->evaluate(new \ClassWithNonPublicAttributes, '', true));
-        $this->assertEquals('does not have attribute "privateAttribute"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(new \stdClass, '', true));
+		$this->assertFalse($constraint->evaluate(new \ClassWithNonPublicAttributes, '', true));
+		$this->assertEquals('does not have attribute "privateAttribute"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(new \ClassWithNonPublicAttributes);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \ClassWithNonPublicAttributes);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that object of class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintObjectNotHasAttribute2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::objectHasAttribute('privateAttribute')
-        );
+	public function testConstraintObjectNotHasAttribute2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::objectHasAttribute('privateAttribute')
+		);
 
-        try {
-            $constraint->evaluate(new \ClassWithNonPublicAttributes, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \ClassWithNonPublicAttributes, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that object of class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintRegularExpression()
-    {
-        $constraint = Assert::matchesRegularExpression('/foo/');
+	public function testConstraintRegularExpression()
+	{
+		$constraint = Assert::matchesRegularExpression('/foo/');
 
-        $this->assertFalse($constraint->evaluate('barbazbar', '', true));
-        $this->assertTrue($constraint->evaluate('barfoobar', '', true));
-        $this->assertEquals('matches PCRE pattern "/foo/"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate('barbazbar', '', true));
+		$this->assertTrue($constraint->evaluate('barfoobar', '', true));
+		$this->assertEquals('matches PCRE pattern "/foo/"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('barbazbar');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('barbazbar');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 'barbazbar' matches PCRE pattern "/foo/".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintRegularExpression2()
-    {
-        $constraint = Assert::matchesRegularExpression('/foo/');
+	public function testConstraintRegularExpression2()
+	{
+		$constraint = Assert::matchesRegularExpression('/foo/');
 
-        try {
-            $constraint->evaluate('barbazbar', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('barbazbar', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 'barbazbar' matches PCRE pattern "/foo/".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintPCRENotMatch()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::matchesRegularExpression('/foo/')
-        );
+	public function testConstraintPCRENotMatch()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::matchesRegularExpression('/foo/')
+		);
 
-        $this->assertTrue($constraint->evaluate('barbazbar', '', true));
-        $this->assertFalse($constraint->evaluate('barfoobar', '', true));
-        $this->assertEquals('does not match PCRE pattern "/foo/"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate('barbazbar', '', true));
+		$this->assertFalse($constraint->evaluate('barfoobar', '', true));
+		$this->assertEquals('does not match PCRE pattern "/foo/"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('barfoobar');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('barfoobar');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 'barfoobar' does not match PCRE pattern "/foo/".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintPCRENotMatch2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::matchesRegularExpression('/foo/')
-        );
+	public function testConstraintPCRENotMatch2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::matchesRegularExpression('/foo/')
+		);
 
-        try {
-            $constraint->evaluate('barfoobar', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('barfoobar', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 'barfoobar' does not match PCRE pattern "/foo/".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
-
-            return;
-        }
-
-        $this->fail();
-    }
-
-    public function testConstraintStringMatches()
-    {
-        $constraint = Assert::matches('*%c*');
-        $this->assertFalse($constraint->evaluate('**', '', true));
-        $this->assertTrue($constraint->evaluate('***', '', true));
-        $this->assertEquals('matches PCRE pattern "/^\*.\*$/s"', $constraint->toString());
-        $this->assertCount(1, $constraint);
-    }
-
-    public function testConstraintStringMatches2()
-    {
-        $constraint = Assert::matches('*%s*');
-        $this->assertFalse($constraint->evaluate('**', '', true));
-        $this->assertTrue($constraint->evaluate('***', '', true));
-        $this->assertEquals('matches PCRE pattern "/^\*[^\r\n]+\*$/s"', $constraint->toString());
-        $this->assertCount(1, $constraint);
-    }
-
-    public function testConstraintStringMatches3()
-    {
-        $constraint = Assert::matches('*%i*');
-        $this->assertFalse($constraint->evaluate('**', '', true));
-        $this->assertTrue($constraint->evaluate('*0*', '', true));
-        $this->assertEquals('matches PCRE pattern "/^\*[+-]?\d+\*$/s"', $constraint->toString());
-        $this->assertCount(1, $constraint);
-    }
-
-    public function testConstraintStringMatches4()
-    {
-        $constraint = Assert::matches('*%d*');
-        $this->assertFalse($constraint->evaluate('**', '', true));
-        $this->assertTrue($constraint->evaluate('*0*', '', true));
-        $this->assertEquals('matches PCRE pattern "/^\*\d+\*$/s"', $constraint->toString());
-        $this->assertCount(1, $constraint);
-    }
-
-    public function testConstraintStringMatches5()
-    {
-        $constraint = Assert::matches('*%x*');
-        $this->assertFalse($constraint->evaluate('**', '', true));
-        $this->assertTrue($constraint->evaluate('*0f0f0f*', '', true));
-        $this->assertEquals('matches PCRE pattern "/^\*[0-9a-fA-F]+\*$/s"', $constraint->toString());
-        $this->assertCount(1, $constraint);
-    }
-
-    public function testConstraintStringMatches6()
-    {
-        $constraint = Assert::matches('*%f*');
-        $this->assertFalse($constraint->evaluate('**', '', true));
-        $this->assertTrue($constraint->evaluate('*1.0*', '', true));
-        $this->assertEquals('matches PCRE pattern "/^\*[+-]?\.?\d+\.?\d*(?:[Ee][+-]?\d+)?\*$/s"', $constraint->toString());
-        $this->assertCount(1, $constraint);
-    }
-
-    public function testConstraintStringStartsWith()
-    {
-        $constraint = Assert::stringStartsWith('prefix');
-
-        $this->assertFalse($constraint->evaluate('foo', '', true));
-        $this->assertTrue($constraint->evaluate('prefixfoo', '', true));
-        $this->assertEquals('starts with "prefix"', $constraint->toString());
-        $this->assertCount(1, $constraint);
-
-        try {
-            $constraint->evaluate('foo');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+				,
+				TestFailure::exceptionToString($e)
+			);
+
+			return;
+		}
+
+		$this->fail();
+	}
+
+	public function testConstraintStringMatches()
+	{
+		$constraint = Assert::matches('*%c*');
+		$this->assertFalse($constraint->evaluate('**', '', true));
+		$this->assertTrue($constraint->evaluate('***', '', true));
+		$this->assertEquals('matches PCRE pattern "/^\*.\*$/s"', $constraint->toString());
+		$this->assertCount(1, $constraint);
+	}
+
+	public function testConstraintStringMatches2()
+	{
+		$constraint = Assert::matches('*%s*');
+		$this->assertFalse($constraint->evaluate('**', '', true));
+		$this->assertTrue($constraint->evaluate('***', '', true));
+		$this->assertEquals('matches PCRE pattern "/^\*[^\r\n]+\*$/s"', $constraint->toString());
+		$this->assertCount(1, $constraint);
+	}
+
+	public function testConstraintStringMatches3()
+	{
+		$constraint = Assert::matches('*%i*');
+		$this->assertFalse($constraint->evaluate('**', '', true));
+		$this->assertTrue($constraint->evaluate('*0*', '', true));
+		$this->assertEquals('matches PCRE pattern "/^\*[+-]?\d+\*$/s"', $constraint->toString());
+		$this->assertCount(1, $constraint);
+	}
+
+	public function testConstraintStringMatches4()
+	{
+		$constraint = Assert::matches('*%d*');
+		$this->assertFalse($constraint->evaluate('**', '', true));
+		$this->assertTrue($constraint->evaluate('*0*', '', true));
+		$this->assertEquals('matches PCRE pattern "/^\*\d+\*$/s"', $constraint->toString());
+		$this->assertCount(1, $constraint);
+	}
+
+	public function testConstraintStringMatches5()
+	{
+		$constraint = Assert::matches('*%x*');
+		$this->assertFalse($constraint->evaluate('**', '', true));
+		$this->assertTrue($constraint->evaluate('*0f0f0f*', '', true));
+		$this->assertEquals('matches PCRE pattern "/^\*[0-9a-fA-F]+\*$/s"', $constraint->toString());
+		$this->assertCount(1, $constraint);
+	}
+
+	public function testConstraintStringMatches6()
+	{
+		$constraint = Assert::matches('*%f*');
+		$this->assertFalse($constraint->evaluate('**', '', true));
+		$this->assertTrue($constraint->evaluate('*1.0*', '', true));
+		$this->assertEquals('matches PCRE pattern "/^\*[+-]?\.?\d+\.?\d*(?:[Ee][+-]?\d+)?\*$/s"', $constraint->toString());
+		$this->assertCount(1, $constraint);
+	}
+
+	public function testConstraintStringStartsWith()
+	{
+		$constraint = Assert::stringStartsWith('prefix');
+
+		$this->assertFalse($constraint->evaluate('foo', '', true));
+		$this->assertTrue($constraint->evaluate('prefixfoo', '', true));
+		$this->assertEquals('starts with "prefix"', $constraint->toString());
+		$this->assertCount(1, $constraint);
+
+		try {
+			$constraint->evaluate('foo');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 'foo' starts with "prefix".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintStringStartsWith2()
-    {
-        $constraint = Assert::stringStartsWith('prefix');
+	public function testConstraintStringStartsWith2()
+	{
+		$constraint = Assert::stringStartsWith('prefix');
 
-        try {
-            $constraint->evaluate('foo', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('foo', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message\nFailed asserting that 'foo' starts with "prefix".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintStringStartsNotWith()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::stringStartsWith('prefix')
-        );
+	public function testConstraintStringStartsNotWith()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::stringStartsWith('prefix')
+		);
 
-        $this->assertTrue($constraint->evaluate('foo', '', true));
-        $this->assertFalse($constraint->evaluate('prefixfoo', '', true));
-        $this->assertEquals('starts not with "prefix"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate('foo', '', true));
+		$this->assertFalse($constraint->evaluate('prefixfoo', '', true));
+		$this->assertEquals('starts not with "prefix"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('prefixfoo');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('prefixfoo');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 'prefixfoo' starts not with "prefix".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintStringStartsNotWith2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::stringStartsWith('prefix')
-        );
+	public function testConstraintStringStartsNotWith2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::stringStartsWith('prefix')
+		);
 
-        try {
-            $constraint->evaluate('prefixfoo', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('prefixfoo', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 'prefixfoo' starts not with "prefix".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintStringContains()
-    {
-        $constraint = Assert::stringContains('foo');
+	public function testConstraintStringContains()
+	{
+		$constraint = Assert::stringContains('foo');
 
-        $this->assertFalse($constraint->evaluate('barbazbar', '', true));
-        $this->assertTrue($constraint->evaluate('barfoobar', '', true));
-        $this->assertEquals('contains "foo"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate('barbazbar', '', true));
+		$this->assertTrue($constraint->evaluate('barfoobar', '', true));
+		$this->assertEquals('contains "foo"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('barbazbar');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('barbazbar');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 'barbazbar' contains "foo".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintStringContainsWhenIgnoreCase()
-    {
-        $constraint = Assert::stringContains('oryginał', true);
+	public function testConstraintStringContainsWhenIgnoreCase()
+	{
+		$constraint = Assert::stringContains('oryginał', true);
 
-        $this->assertFalse($constraint->evaluate('oryginal', '', true));
-        $this->assertTrue($constraint->evaluate('ORYGINAŁ', '', true));
-        $this->assertTrue($constraint->evaluate('oryginał', '', true));
-        $this->assertEquals('contains "oryginał"', $constraint->toString());
-        $this->assertEquals(1, \count($constraint));
+		$this->assertFalse($constraint->evaluate('oryginal', '', true));
+		$this->assertTrue($constraint->evaluate('ORYGINAŁ', '', true));
+		$this->assertTrue($constraint->evaluate('oryginał', '', true));
+		$this->assertEquals('contains "oryginał"', $constraint->toString());
+		$this->assertEquals(1, \count($constraint));
 
-        $this->expectException(ExpectationFailedException::class);
+		$this->expectException(ExpectationFailedException::class);
 
-        $constraint->evaluate('oryginal');
-    }
+		$constraint->evaluate('oryginal');
+	}
 
-    public function testConstraintStringContainsForUtf8StringWhenNotIgnoreCase()
-    {
-        $constraint = Assert::stringContains('oryginał', false);
+	public function testConstraintStringContainsForUtf8StringWhenNotIgnoreCase()
+	{
+		$constraint = Assert::stringContains('oryginał', false);
 
-        $this->assertFalse($constraint->evaluate('oryginal', '', true));
-        $this->assertFalse($constraint->evaluate('ORYGINAŁ', '', true));
-        $this->assertTrue($constraint->evaluate('oryginał', '', true));
-        $this->assertEquals('contains "oryginał"', $constraint->toString());
-        $this->assertEquals(1, \count($constraint));
+		$this->assertFalse($constraint->evaluate('oryginal', '', true));
+		$this->assertFalse($constraint->evaluate('ORYGINAŁ', '', true));
+		$this->assertTrue($constraint->evaluate('oryginał', '', true));
+		$this->assertEquals('contains "oryginał"', $constraint->toString());
+		$this->assertEquals(1, \count($constraint));
 
-        $this->expectException(ExpectationFailedException::class);
+		$this->expectException(ExpectationFailedException::class);
 
-        $constraint->evaluate('oryginal');
-    }
+		$constraint->evaluate('oryginal');
+	}
 
-    public function testConstraintStringContains2()
-    {
-        $constraint = Assert::stringContains('foo');
+	public function testConstraintStringContains2()
+	{
+		$constraint = Assert::stringContains('foo');
 
-        try {
-            $constraint->evaluate('barbazbar', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('barbazbar', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 'barbazbar' contains "foo".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintStringNotContains()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::stringContains('foo')
-        );
+	public function testConstraintStringNotContains()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::stringContains('foo')
+		);
 
-        $this->assertTrue($constraint->evaluate('barbazbar', '', true));
-        $this->assertFalse($constraint->evaluate('barfoobar', '', true));
-        $this->assertEquals('does not contain "foo"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate('barbazbar', '', true));
+		$this->assertFalse($constraint->evaluate('barfoobar', '', true));
+		$this->assertEquals('does not contain "foo"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('barfoobar');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('barfoobar');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 'barfoobar' does not contain "foo".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintStringNotContainsWhenIgnoreCase()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::stringContains('oryginał')
-        );
+	public function testConstraintStringNotContainsWhenIgnoreCase()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::stringContains('oryginał')
+		);
 
-        $this->assertTrue($constraint->evaluate('original', '', true));
-        $this->assertFalse($constraint->evaluate('ORYGINAŁ', '', true));
-        $this->assertFalse($constraint->evaluate('oryginał', '', true));
-        $this->assertEquals('does not contain "oryginał"', $constraint->toString());
-        $this->assertEquals(1, \count($constraint));
+		$this->assertTrue($constraint->evaluate('original', '', true));
+		$this->assertFalse($constraint->evaluate('ORYGINAŁ', '', true));
+		$this->assertFalse($constraint->evaluate('oryginał', '', true));
+		$this->assertEquals('does not contain "oryginał"', $constraint->toString());
+		$this->assertEquals(1, \count($constraint));
 
-        $this->expectException(ExpectationFailedException::class);
+		$this->expectException(ExpectationFailedException::class);
 
-        $constraint->evaluate('ORYGINAŁ');
-    }
+		$constraint->evaluate('ORYGINAŁ');
+	}
 
-    public function testConstraintStringNotContainsForUtf8StringWhenNotIgnoreCase()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::stringContains('oryginał', false)
-        );
+	public function testConstraintStringNotContainsForUtf8StringWhenNotIgnoreCase()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::stringContains('oryginał', false)
+		);
 
-        $this->assertTrue($constraint->evaluate('original', '', true));
-        $this->assertTrue($constraint->evaluate('ORYGINAŁ', '', true));
-        $this->assertFalse($constraint->evaluate('oryginał', '', true));
-        $this->assertEquals('does not contain "oryginał"', $constraint->toString());
-        $this->assertEquals(1, \count($constraint));
+		$this->assertTrue($constraint->evaluate('original', '', true));
+		$this->assertTrue($constraint->evaluate('ORYGINAŁ', '', true));
+		$this->assertFalse($constraint->evaluate('oryginał', '', true));
+		$this->assertEquals('does not contain "oryginał"', $constraint->toString());
+		$this->assertEquals(1, \count($constraint));
 
-        $this->expectException(ExpectationFailedException::class);
+		$this->expectException(ExpectationFailedException::class);
 
-        $constraint->evaluate('oryginał');
-    }
+		$constraint->evaluate('oryginał');
+	}
 
-    public function testConstraintStringNotContains2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::stringContains('foo')
-        );
+	public function testConstraintStringNotContains2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::stringContains('foo')
+		);
 
-        try {
-            $constraint->evaluate('barfoobar', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('barfoobar', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 'barfoobar' does not contain "foo".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintStringEndsWith()
-    {
-        $constraint = Assert::stringEndsWith('suffix');
+	public function testConstraintStringEndsWith()
+	{
+		$constraint = Assert::stringEndsWith('suffix');
 
-        $this->assertFalse($constraint->evaluate('foo', '', true));
-        $this->assertTrue($constraint->evaluate('foosuffix', '', true));
-        $this->assertEquals('ends with "suffix"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate('foo', '', true));
+		$this->assertTrue($constraint->evaluate('foosuffix', '', true));
+		$this->assertEquals('ends with "suffix"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('foo');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('foo');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 'foo' ends with "suffix".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintStringEndsWith2()
-    {
-        $constraint = Assert::stringEndsWith('suffix');
+	public function testConstraintStringEndsWith2()
+	{
+		$constraint = Assert::stringEndsWith('suffix');
 
-        try {
-            $constraint->evaluate('foo', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('foo', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 'foo' ends with "suffix".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintStringEndsNotWith()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::stringEndsWith('suffix')
-        );
+	public function testConstraintStringEndsNotWith()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::stringEndsWith('suffix')
+		);
 
-        $this->assertTrue($constraint->evaluate('foo', '', true));
-        $this->assertFalse($constraint->evaluate('foosuffix', '', true));
-        $this->assertEquals('ends not with "suffix"', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate('foo', '', true));
+		$this->assertFalse($constraint->evaluate('foosuffix', '', true));
+		$this->assertEquals('ends not with "suffix"', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate('foosuffix');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('foosuffix');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that 'foosuffix' ends not with "suffix".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintStringEndsNotWith2()
-    {
-        $constraint = Assert::logicalNot(
-            Assert::stringEndsWith('suffix')
-        );
+	public function testConstraintStringEndsNotWith2()
+	{
+		$constraint = Assert::logicalNot(
+			Assert::stringEndsWith('suffix')
+		);
 
-        try {
-            $constraint->evaluate('foosuffix', 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate('foosuffix', 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that 'foosuffix' ends not with "suffix".
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintArrayContainsCheckForObjectIdentity()
-    {
-        // Check for primitive type.
-        $constraint = new TraversableContains('foo', true, true);
+	public function testConstraintArrayContainsCheckForObjectIdentity()
+	{
+		// Check for primitive type.
+		$constraint = new TraversableContains('foo', true, true);
 
-        $this->assertFalse($constraint->evaluate([0], '', true));
-        $this->assertFalse($constraint->evaluate([true], '', true));
+		$this->assertFalse($constraint->evaluate([0], '', true));
+		$this->assertFalse($constraint->evaluate([true], '', true));
 
-        // Default case.
-        $constraint = new TraversableContains('foo');
+		// Default case.
+		$constraint = new TraversableContains('foo');
 
-        $this->assertTrue($constraint->evaluate([0], '', true));
-        $this->assertTrue($constraint->evaluate([true], '', true));
-    }
+		$this->assertTrue($constraint->evaluate([0], '', true));
+		$this->assertTrue($constraint->evaluate([true], '', true));
+	}
 
-    public function testConstraintArrayContains()
-    {
-        $constraint = new TraversableContains('foo');
+	public function testConstraintArrayContains()
+	{
+		$constraint = new TraversableContains('foo');
 
-        $this->assertFalse($constraint->evaluate(['bar'], '', true));
-        $this->assertTrue($constraint->evaluate(['foo'], '', true));
-        $this->assertEquals("contains 'foo'", $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate(['bar'], '', true));
+		$this->assertTrue($constraint->evaluate(['foo'], '', true));
+		$this->assertEquals("contains 'foo'", $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(['bar']);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(['bar']);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that an array contains 'foo'.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintArrayContains2()
-    {
-        $constraint = new TraversableContains('foo');
+	public function testConstraintArrayContains2()
+	{
+		$constraint = new TraversableContains('foo');
 
-        try {
-            $constraint->evaluate(['bar'], 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(['bar'], 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that an array contains 'foo'.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintArrayNotContains()
-    {
-        $constraint = Assert::logicalNot(
-            new TraversableContains('foo')
-        );
+	public function testConstraintArrayNotContains()
+	{
+		$constraint = Assert::logicalNot(
+			new TraversableContains('foo')
+		);
 
-        $this->assertTrue($constraint->evaluate(['bar'], '', true));
-        $this->assertFalse($constraint->evaluate(['foo'], '', true));
-        $this->assertEquals("does not contain 'foo'", $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate(['bar'], '', true));
+		$this->assertFalse($constraint->evaluate(['foo'], '', true));
+		$this->assertEquals("does not contain 'foo'", $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(['foo']);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(['foo']);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that an array does not contain 'foo'.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintArrayNotContains2()
-    {
-        $constraint = Assert::logicalNot(
-            new TraversableContains('foo')
-        );
+	public function testConstraintArrayNotContains2()
+	{
+		$constraint = Assert::logicalNot(
+			new TraversableContains('foo')
+		);
 
-        try {
-            $constraint->evaluate(['foo'], 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(['foo'], 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message
 Failed asserting that an array does not contain 'foo'.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintSplObjectStorageContains()
-    {
-        $object     = new \stdClass;
-        $constraint = new TraversableContains($object);
-        $this->assertStringMatchesFormat('contains stdClass Object &%s ()', $constraint->toString());
+	public function testConstraintSplObjectStorageContains()
+	{
+		$object     = new \stdClass;
+		$constraint = new TraversableContains($object);
+		$this->assertStringMatchesFormat('contains stdClass Object &%s ()', $constraint->toString());
 
-        $storage = new \SplObjectStorage;
-        $this->assertFalse($constraint->evaluate($storage, '', true));
+		$storage = new \SplObjectStorage;
+		$this->assertFalse($constraint->evaluate($storage, '', true));
 
-        $storage->attach($object);
-        $this->assertTrue($constraint->evaluate($storage, '', true));
+		$storage->attach($object);
+		$this->assertTrue($constraint->evaluate($storage, '', true));
 
-        try {
-            $constraint->evaluate(new \SplObjectStorage);
-        } catch (ExpectationFailedException $e) {
-            $this->assertStringMatchesFormat(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \SplObjectStorage);
+		} catch (ExpectationFailedException $e) {
+			$this->assertStringMatchesFormat(
+				<<<EOF
 Failed asserting that a traversable contains stdClass Object &%x ().
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintSplObjectStorageContains2()
-    {
-        $object     = new \stdClass;
-        $constraint = new TraversableContains($object);
+	public function testConstraintSplObjectStorageContains2()
+	{
+		$object     = new \stdClass;
+		$constraint = new TraversableContains($object);
 
-        try {
-            $constraint->evaluate(new \SplObjectStorage, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertStringMatchesFormat(
-                <<<EOF
+		try {
+			$constraint->evaluate(new \SplObjectStorage, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertStringMatchesFormat(
+				<<<EOF
 custom message
 Failed asserting that a traversable contains stdClass Object &%x ().
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testAttributeEqualTo()
-    {
-        $object     = new \ClassWithNonPublicAttributes;
-        $constraint = Assert::attributeEqualTo('foo', 1);
+	public function testAttributeEqualTo()
+	{
+		$object     = new \ClassWithNonPublicAttributes;
+		$constraint = Assert::attributeEqualTo('foo', 1);
 
-        $this->assertTrue($constraint->evaluate($object, '', true));
-        $this->assertEquals('attribute "foo" is equal to 1', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate($object, '', true));
+		$this->assertEquals('attribute "foo" is equal to 1', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        $constraint = Assert::attributeEqualTo('foo', 2);
+		$constraint = Assert::attributeEqualTo('foo', 2);
 
-        $this->assertFalse($constraint->evaluate($object, '', true));
+		$this->assertFalse($constraint->evaluate($object, '', true));
 
-        try {
-            $constraint->evaluate($object);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate($object);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that attribute "foo" is equal to 2.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testAttributeEqualTo2()
-    {
-        $object     = new \ClassWithNonPublicAttributes;
-        $constraint = Assert::attributeEqualTo('foo', 2);
+	public function testAttributeEqualTo2()
+	{
+		$object     = new \ClassWithNonPublicAttributes;
+		$constraint = Assert::attributeEqualTo('foo', 2);
 
-        try {
-            $constraint->evaluate($object, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate($object, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message\nFailed asserting that attribute "foo" is equal to 2.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testAttributeNotEqualTo()
-    {
-        $object     = new \ClassWithNonPublicAttributes;
-        $constraint = Assert::logicalNot(
-            Assert::attributeEqualTo('foo', 2)
-        );
+	public function testAttributeNotEqualTo()
+	{
+		$object     = new \ClassWithNonPublicAttributes;
+		$constraint = Assert::logicalNot(
+			Assert::attributeEqualTo('foo', 2)
+		);
 
-        $this->assertTrue($constraint->evaluate($object, '', true));
-        $this->assertEquals('attribute "foo" is not equal to 2', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertTrue($constraint->evaluate($object, '', true));
+		$this->assertEquals('attribute "foo" is not equal to 2', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        $constraint = Assert::logicalNot(
-            Assert::attributeEqualTo('foo', 1)
-        );
+		$constraint = Assert::logicalNot(
+			Assert::attributeEqualTo('foo', 1)
+		);
 
-        $this->assertFalse($constraint->evaluate($object, '', true));
+		$this->assertFalse($constraint->evaluate($object, '', true));
 
-        try {
-            $constraint->evaluate($object);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate($object);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that attribute "foo" is not equal to 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testAttributeNotEqualTo2()
-    {
-        $object     = new \ClassWithNonPublicAttributes;
-        $constraint = Assert::logicalNot(
-            Assert::attributeEqualTo('foo', 1)
-        );
+	public function testAttributeNotEqualTo2()
+	{
+		$object     = new \ClassWithNonPublicAttributes;
+		$constraint = Assert::logicalNot(
+			Assert::attributeEqualTo('foo', 1)
+		);
 
-        try {
-            $constraint->evaluate($object, 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate($object, 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message\nFailed asserting that attribute "foo" is not equal to 1.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsEmpty()
-    {
-        $constraint = new IsEmpty;
+	public function testConstraintIsEmpty()
+	{
+		$constraint = new IsEmpty;
 
-        $this->assertFalse($constraint->evaluate(['foo'], '', true));
-        $this->assertTrue($constraint->evaluate([], '', true));
-        $this->assertFalse($constraint->evaluate(new \ArrayObject(['foo']), '', true));
-        $this->assertTrue($constraint->evaluate(new \ArrayObject([]), '', true));
-        $this->assertEquals('is empty', $constraint->toString());
-        $this->assertCount(1, $constraint);
+		$this->assertFalse($constraint->evaluate(['foo'], '', true));
+		$this->assertTrue($constraint->evaluate([], '', true));
+		$this->assertFalse($constraint->evaluate(new \ArrayObject(['foo']), '', true));
+		$this->assertTrue($constraint->evaluate(new \ArrayObject([]), '', true));
+		$this->assertEquals('is empty', $constraint->toString());
+		$this->assertCount(1, $constraint);
 
-        try {
-            $constraint->evaluate(['foo']);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(['foo']);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that an array is empty.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintIsEmpty2()
-    {
-        $constraint = new IsEmpty;
+	public function testConstraintIsEmpty2()
+	{
+		$constraint = new IsEmpty;
 
-        try {
-            $constraint->evaluate(['foo'], 'custom message');
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate(['foo'], 'custom message');
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 custom message\nFailed asserting that an array is empty.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintCountWithAnArray()
-    {
-        $constraint = new Count(5);
+	public function testConstraintCountWithAnArray()
+	{
+		$constraint = new Count(5);
 
-        $this->assertTrue($constraint->evaluate([1, 2, 3, 4, 5], '', true));
-        $this->assertFalse($constraint->evaluate([1, 2, 3, 4], '', true));
-    }
+		$this->assertTrue($constraint->evaluate([1, 2, 3, 4, 5], '', true));
+		$this->assertFalse($constraint->evaluate([1, 2, 3, 4], '', true));
+	}
 
-    public function testConstraintCountWithAnIteratorWhichDoesNotImplementCountable()
-    {
-        $constraint = new Count(5);
+	public function testConstraintCountWithAnIteratorWhichDoesNotImplementCountable()
+	{
+		$constraint = new Count(5);
 
-        $this->assertTrue($constraint->evaluate(new \TestIterator([1, 2, 3, 4, 5]), '', true));
-        $this->assertFalse($constraint->evaluate(new \TestIterator([1, 2, 3, 4]), '', true));
-    }
+		$this->assertTrue($constraint->evaluate(new \TestIterator([1, 2, 3, 4, 5]), '', true));
+		$this->assertFalse($constraint->evaluate(new \TestIterator([1, 2, 3, 4]), '', true));
+	}
 
-    public function testConstraintCountWithAnObjectImplementingCountable()
-    {
-        $constraint = new Count(5);
+	public function testConstraintCountWithAnObjectImplementingCountable()
+	{
+		$constraint = new Count(5);
 
-        $this->assertTrue($constraint->evaluate(new \ArrayObject([1, 2, 3, 4, 5]), '', true));
-        $this->assertFalse($constraint->evaluate(new \ArrayObject([1, 2, 3, 4]), '', true));
-    }
+		$this->assertTrue($constraint->evaluate(new \ArrayObject([1, 2, 3, 4, 5]), '', true));
+		$this->assertFalse($constraint->evaluate(new \ArrayObject([1, 2, 3, 4]), '', true));
+	}
 
-    public function testConstraintCountFailing()
-    {
-        $constraint = new Count(5);
+	public function testConstraintCountFailing()
+	{
+		$constraint = new Count(5);
 
-        try {
-            $constraint->evaluate([1, 2]);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate([1, 2]);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that actual size 2 matches expected size 5.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintNotCountFailing()
-    {
-        $constraint = Assert::logicalNot(
-            new Count(2)
-        );
+	public function testConstraintNotCountFailing()
+	{
+		$constraint = Assert::logicalNot(
+			new Count(2)
+		);
 
-        try {
-            $constraint->evaluate([1, 2]);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate([1, 2]);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that actual size 2 does not match expected size 2.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintSameSizeWithAnArray()
-    {
-        $constraint = new SameSize([1, 2, 3, 4, 5]);
+	public function testConstraintSameSizeWithAnArray()
+	{
+		$constraint = new SameSize([1, 2, 3, 4, 5]);
 
-        $this->assertTrue($constraint->evaluate([6, 7, 8, 9, 10], '', true));
-        $this->assertFalse($constraint->evaluate([1, 2, 3, 4], '', true));
-    }
+		$this->assertTrue($constraint->evaluate([6, 7, 8, 9, 10], '', true));
+		$this->assertFalse($constraint->evaluate([1, 2, 3, 4], '', true));
+	}
 
-    public function testConstraintSameSizeWithAnIteratorWhichDoesNotImplementCountable()
-    {
-        $constraint = new SameSize(new \TestIterator([1, 2, 3, 4, 5]));
+	public function testConstraintSameSizeWithAnIteratorWhichDoesNotImplementCountable()
+	{
+		$constraint = new SameSize(new \TestIterator([1, 2, 3, 4, 5]));
 
-        $this->assertTrue($constraint->evaluate(new \TestIterator([6, 7, 8, 9, 10]), '', true));
-        $this->assertFalse($constraint->evaluate(new \TestIterator([1, 2, 3, 4]), '', true));
-    }
+		$this->assertTrue($constraint->evaluate(new \TestIterator([6, 7, 8, 9, 10]), '', true));
+		$this->assertFalse($constraint->evaluate(new \TestIterator([1, 2, 3, 4]), '', true));
+	}
 
-    public function testConstraintSameSizeWithAnObjectImplementingCountable()
-    {
-        $constraint = new SameSize(new \ArrayObject([1, 2, 3, 4, 5]));
+	public function testConstraintSameSizeWithAnObjectImplementingCountable()
+	{
+		$constraint = new SameSize(new \ArrayObject([1, 2, 3, 4, 5]));
 
-        $this->assertTrue($constraint->evaluate(new \ArrayObject([6, 7, 8, 9, 10]), '', true));
-        $this->assertFalse($constraint->evaluate(new \ArrayObject([1, 2, 3, 4]), '', true));
-    }
+		$this->assertTrue($constraint->evaluate(new \ArrayObject([6, 7, 8, 9, 10]), '', true));
+		$this->assertFalse($constraint->evaluate(new \ArrayObject([1, 2, 3, 4]), '', true));
+	}
 
-    public function testConstraintSameSizeFailing()
-    {
-        $constraint = new SameSize([1, 2, 3, 4, 5]);
+	public function testConstraintSameSizeFailing()
+	{
+		$constraint = new SameSize([1, 2, 3, 4, 5]);
 
-        try {
-            $constraint->evaluate([1, 2]);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate([1, 2]);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that actual size 2 matches expected size 5.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintNotSameSizeFailing()
-    {
-        $constraint = Assert::logicalNot(
-            new SameSize([1, 2])
-        );
+	public function testConstraintNotSameSizeFailing()
+	{
+		$constraint = Assert::logicalNot(
+			new SameSize([1, 2])
+		);
 
-        try {
-            $constraint->evaluate([3, 4]);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate([3, 4]);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that actual size 2 does not match expected size 2.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    public function testConstraintException()
-    {
-        $constraint = new Constraint\Exception('FoobarException');
-        $exception  = new \DummyException('Test');
-        $stackTrace = Filter::getFilteredStacktrace($exception);
+	public function testConstraintException()
+	{
+		$constraint = new Constraint\Exception('FoobarException');
+		$exception  = new \DummyException('Test');
+		$stackTrace = Filter::getFilteredStacktrace($exception);
 
-        try {
-            $constraint->evaluate($exception);
-        } catch (ExpectationFailedException $e) {
-            $this->assertEquals(
-                <<<EOF
+		try {
+			$constraint->evaluate($exception);
+		} catch (ExpectationFailedException $e) {
+			$this->assertEquals(
+				<<<EOF
 Failed asserting that exception of type "DummyException" matches expected exception "FoobarException". Message was: "Test" at
 $stackTrace.
 
 EOF
-                ,
-                TestFailure::exceptionToString($e)
-            );
+				,
+				TestFailure::exceptionToString($e)
+			);
 
-            return;
-        }
+			return;
+		}
 
-        $this->fail();
-    }
+		$this->fail();
+	}
 
-    /**
-     * Removes spaces in front of newlines
-     *
-     * @param string $string
-     *
-     * @return string
-     */
-    private function trimnl($string)
-    {
-        return \preg_replace('/[ ]*\n/', "\n", $string);
-    }
+	/**
+	 * Removes spaces in front of newlines
+	 *
+	 * @param string $string
+	 *
+	 * @return string
+	 */
+	private function trimnl($string)
+	{
+		return \preg_replace('/[ ]*\n/', "\n", $string);
+	}
 }

Spacing +5 added lines, -5 removed lines

@@ -248,7 +248,7 @@ 
 
     public function testConstraintFileNotExists()
     {
-        $file = \dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'ClassWithNonPublicAttributes.php';
+        $file = \dirname(__DIR__).DIRECTORY_SEPARATOR.'_files'.DIRECTORY_SEPARATOR.'ClassWithNonPublicAttributes.php';
 
         $constraint = Assert::logicalNot(
             Assert::fileExists()
@@ -278,7 +278,7 @@ 
 
     public function testConstraintFileNotExists2()
     {
-        $file = \dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'ClassWithNonPublicAttributes.php';
+        $file = \dirname(__DIR__).DIRECTORY_SEPARATOR.'_files'.DIRECTORY_SEPARATOR.'ClassWithNonPublicAttributes.php';
 
         $constraint = Assert::logicalNot(
             Assert::fileExists()
@@ -1524,11 +1524,11 @@ 
 
     public function testConstraintCallback()
     {
-        $closureReflect = function ($parameter) {
+        $closureReflect = function($parameter) {
             return $parameter;
         };
 
-        $closureWithoutParameter = function () {
+        $closureWithoutParameter = function() {
             return true;
         };
 
@@ -1552,7 +1552,7 @@ 
 
     public function testConstraintCallbackFailure()
     {
-        $constraint = Assert::callback(function () {
+        $constraint = Assert::callback(function() {
             return false;
         });
 

vendor/phpunit/phpunit/tests/Framework/SuiteTest.php

Indentation +170 added lines, -170 removed lines

@@ -12,225 +12,225 @@
 
 class SuiteTest extends TestCase
 {
-    /**
-     * @var TestResult
-     */
-    private $result;
-
-    protected function setUp()
-    {
-        $this->result = new TestResult;
-    }
-
-    public static function suite()
-    {
-        $suite = new TestSuite;
-
-        $suite->addTest(new self('testAddTestSuite'));
-        $suite->addTest(new self('testInheritedTests'));
-        $suite->addTest(new self('testNoTestCases'));
-        $suite->addTest(new self('testNoTestCaseClass'));
-        $suite->addTest(new self('testNotExistingTestCase'));
-        $suite->addTest(new self('testNotPublicTestCase'));
-        $suite->addTest(new self('testNotVoidTestCase'));
-        $suite->addTest(new self('testOneTestCase'));
-        $suite->addTest(new self('testShadowedTests'));
-        $suite->addTest(new self('testBeforeClassAndAfterClassAnnotations'));
-        $suite->addTest(new self('testBeforeClassWithDataProviders'));
-        $suite->addTest(new self('testBeforeAnnotation'));
-        $suite->addTest(new self('testTestWithAnnotation'));
-        $suite->addTest(new self('testSkippedTestDataProvider'));
-        $suite->addTest(new self('testTestDataProviderDependency'));
-        $suite->addTest(new self('testIncompleteTestDataProvider'));
-        $suite->addTest(new self('testRequirementsBeforeClassHook'));
-        $suite->addTest(new self('testDoNotSkipInheritedClass'));
-
-        return $suite;
-    }
-
-    public function testAddTestSuite()
-    {
-        $suite = new TestSuite(\OneTestCase::class);
-
-        $suite->run($this->result);
+	/**
+	 * @var TestResult
+	 */
+	private $result;
+
+	protected function setUp()
+	{
+		$this->result = new TestResult;
+	}
+
+	public static function suite()
+	{
+		$suite = new TestSuite;
+
+		$suite->addTest(new self('testAddTestSuite'));
+		$suite->addTest(new self('testInheritedTests'));
+		$suite->addTest(new self('testNoTestCases'));
+		$suite->addTest(new self('testNoTestCaseClass'));
+		$suite->addTest(new self('testNotExistingTestCase'));
+		$suite->addTest(new self('testNotPublicTestCase'));
+		$suite->addTest(new self('testNotVoidTestCase'));
+		$suite->addTest(new self('testOneTestCase'));
+		$suite->addTest(new self('testShadowedTests'));
+		$suite->addTest(new self('testBeforeClassAndAfterClassAnnotations'));
+		$suite->addTest(new self('testBeforeClassWithDataProviders'));
+		$suite->addTest(new self('testBeforeAnnotation'));
+		$suite->addTest(new self('testTestWithAnnotation'));
+		$suite->addTest(new self('testSkippedTestDataProvider'));
+		$suite->addTest(new self('testTestDataProviderDependency'));
+		$suite->addTest(new self('testIncompleteTestDataProvider'));
+		$suite->addTest(new self('testRequirementsBeforeClassHook'));
+		$suite->addTest(new self('testDoNotSkipInheritedClass'));
+
+		return $suite;
+	}
+
+	public function testAddTestSuite()
+	{
+		$suite = new TestSuite(\OneTestCase::class);
+
+		$suite->run($this->result);
 
-        $this->assertCount(1, $this->result);
-    }
-
-    public function testInheritedTests()
-    {
-        $suite = new TestSuite(\InheritedTestCase::class);
+		$this->assertCount(1, $this->result);
+	}
+
+	public function testInheritedTests()
+	{
+		$suite = new TestSuite(\InheritedTestCase::class);
 
-        $suite->run($this->result);
+		$suite->run($this->result);
 
-        $this->assertTrue($this->result->wasSuccessful());
-        $this->assertCount(2, $this->result);
-    }
+		$this->assertTrue($this->result->wasSuccessful());
+		$this->assertCount(2, $this->result);
+	}
 
-    public function testNoTestCases()
-    {
-        $suite = new TestSuite(\NoTestCases::class);
+	public function testNoTestCases()
+	{
+		$suite = new TestSuite(\NoTestCases::class);
 
-        $suite->run($this->result);
+		$suite->run($this->result);
 
-        $this->assertNotTrue($this->result->wasSuccessful());
-        $this->assertEquals(0, $this->result->failureCount());
-        $this->assertEquals(1, $this->result->warningCount());
-        $this->assertCount(1, $this->result);
-    }
+		$this->assertNotTrue($this->result->wasSuccessful());
+		$this->assertEquals(0, $this->result->failureCount());
+		$this->assertEquals(1, $this->result->warningCount());
+		$this->assertCount(1, $this->result);
+	}
 
-    public function testNoTestCaseClass()
-    {
-        $this->expectException(Exception::class);
+	public function testNoTestCaseClass()
+	{
+		$this->expectException(Exception::class);
 
-        new TestSuite(\NoTestCaseClass::class);
-    }
+		new TestSuite(\NoTestCaseClass::class);
+	}
 
-    public function testNotExistingTestCase()
-    {
-        $suite = new self('notExistingMethod');
+	public function testNotExistingTestCase()
+	{
+		$suite = new self('notExistingMethod');
 
-        $suite->run($this->result);
+		$suite->run($this->result);
 
-        $this->assertEquals(0, $this->result->errorCount());
-        $this->assertEquals(1, $this->result->failureCount());
-        $this->assertCount(1, $this->result);
-    }
+		$this->assertEquals(0, $this->result->errorCount());
+		$this->assertEquals(1, $this->result->failureCount());
+		$this->assertCount(1, $this->result);
+	}
 
-    public function testNotPublicTestCase()
-    {
-        $suite = new TestSuite(\NotPublicTestCase::class);
+	public function testNotPublicTestCase()
+	{
+		$suite = new TestSuite(\NotPublicTestCase::class);
 
-        $this->assertCount(2, $suite);
-    }
+		$this->assertCount(2, $suite);
+	}
 
-    public function testNotVoidTestCase()
-    {
-        $suite = new TestSuite(\NotVoidTestCase::class);
+	public function testNotVoidTestCase()
+	{
+		$suite = new TestSuite(\NotVoidTestCase::class);
 
-        $this->assertCount(1, $suite);
-    }
+		$this->assertCount(1, $suite);
+	}
 
-    public function testOneTestCase()
-    {
-        $suite = new TestSuite(\OneTestCase::class);
+	public function testOneTestCase()
+	{
+		$suite = new TestSuite(\OneTestCase::class);
 
-        $suite->run($this->result);
+		$suite->run($this->result);
 
-        $this->assertEquals(0, $this->result->errorCount());
-        $this->assertEquals(0, $this->result->failureCount());
-        $this->assertCount(1, $this->result);
-        $this->assertTrue($this->result->wasSuccessful());
-    }
+		$this->assertEquals(0, $this->result->errorCount());
+		$this->assertEquals(0, $this->result->failureCount());
+		$this->assertCount(1, $this->result);
+		$this->assertTrue($this->result->wasSuccessful());
+	}
 
-    public function testShadowedTests()
-    {
-        $suite = new TestSuite(\OverrideTestCase::class);
+	public function testShadowedTests()
+	{
+		$suite = new TestSuite(\OverrideTestCase::class);
 
-        $suite->run($this->result);
+		$suite->run($this->result);
 
-        $this->assertCount(1, $this->result);
-    }
+		$this->assertCount(1, $this->result);
+	}
 
-    public function testBeforeClassAndAfterClassAnnotations()
-    {
-        $suite = new TestSuite(\BeforeClassAndAfterClassTest::class);
+	public function testBeforeClassAndAfterClassAnnotations()
+	{
+		$suite = new TestSuite(\BeforeClassAndAfterClassTest::class);
 
-        \BeforeClassAndAfterClassTest::resetProperties();
-        $suite->run($this->result);
+		\BeforeClassAndAfterClassTest::resetProperties();
+		$suite->run($this->result);
 
-        $this->assertEquals(1, \BeforeClassAndAfterClassTest::$beforeClassWasRun, '@beforeClass method was not run once for the whole suite.');
-        $this->assertEquals(1, \BeforeClassAndAfterClassTest::$afterClassWasRun, '@afterClass method was not run once for the whole suite.');
-    }
+		$this->assertEquals(1, \BeforeClassAndAfterClassTest::$beforeClassWasRun, '@beforeClass method was not run once for the whole suite.');
+		$this->assertEquals(1, \BeforeClassAndAfterClassTest::$afterClassWasRun, '@afterClass method was not run once for the whole suite.');
+	}
 
-    public function testBeforeClassWithDataProviders()
-    {
-        $suite = new TestSuite(\BeforeClassWithOnlyDataProviderTest::class);
+	public function testBeforeClassWithDataProviders()
+	{
+		$suite = new TestSuite(\BeforeClassWithOnlyDataProviderTest::class);
 
-        \BeforeClassWithOnlyDataProviderTest::resetProperties();
-        $suite->run($this->result);
+		\BeforeClassWithOnlyDataProviderTest::resetProperties();
+		$suite->run($this->result);
 
-        $this->assertTrue(\BeforeClassWithOnlyDataProviderTest::$setUpBeforeClassWasCalled, 'setUpBeforeClass method was not run.');
-        $this->assertTrue(\BeforeClassWithOnlyDataProviderTest::$beforeClassWasCalled, '@beforeClass method was not run.');
-    }
+		$this->assertTrue(\BeforeClassWithOnlyDataProviderTest::$setUpBeforeClassWasCalled, 'setUpBeforeClass method was not run.');
+		$this->assertTrue(\BeforeClassWithOnlyDataProviderTest::$beforeClassWasCalled, '@beforeClass method was not run.');
+	}
 
-    public function testBeforeAnnotation()
-    {
-        $test = new TestSuite(\BeforeAndAfterTest::class);
+	public function testBeforeAnnotation()
+	{
+		$test = new TestSuite(\BeforeAndAfterTest::class);
 
-        \BeforeAndAfterTest::resetProperties();
-        $test->run();
+		\BeforeAndAfterTest::resetProperties();
+		$test->run();
 
-        $this->assertEquals(2, \BeforeAndAfterTest::$beforeWasRun);
-        $this->assertEquals(2, \BeforeAndAfterTest::$afterWasRun);
-    }
+		$this->assertEquals(2, \BeforeAndAfterTest::$beforeWasRun);
+		$this->assertEquals(2, \BeforeAndAfterTest::$afterWasRun);
+	}
 
-    public function testTestWithAnnotation()
-    {
-        $test = new TestSuite(\TestWithTest::class);
+	public function testTestWithAnnotation()
+	{
+		$test = new TestSuite(\TestWithTest::class);
 
-        \BeforeAndAfterTest::resetProperties();
-        $result = $test->run();
+		\BeforeAndAfterTest::resetProperties();
+		$result = $test->run();
 
-        $this->assertCount(4, $result->passed());
-    }
+		$this->assertCount(4, $result->passed());
+	}
 
-    public function testSkippedTestDataProvider()
-    {
-        $suite = new TestSuite(\DataProviderSkippedTest::class);
+	public function testSkippedTestDataProvider()
+	{
+		$suite = new TestSuite(\DataProviderSkippedTest::class);
 
-        $suite->run($this->result);
+		$suite->run($this->result);
 
-        $this->assertEquals(3, $this->result->count());
-        $this->assertEquals(1, $this->result->skippedCount());
-    }
+		$this->assertEquals(3, $this->result->count());
+		$this->assertEquals(1, $this->result->skippedCount());
+	}
 
-    public function testTestDataProviderDependency()
-    {
-        $suite = new TestSuite(\DataProviderDependencyTest::class);
+	public function testTestDataProviderDependency()
+	{
+		$suite = new TestSuite(\DataProviderDependencyTest::class);
 
-        $suite->run($this->result);
+		$suite->run($this->result);
 
-        $skipped           = $this->result->skipped();
-        $lastSkippedResult = \array_pop($skipped);
-        $message           = $lastSkippedResult->thrownException()->getMessage();
+		$skipped           = $this->result->skipped();
+		$lastSkippedResult = \array_pop($skipped);
+		$message           = $lastSkippedResult->thrownException()->getMessage();
 
-        $this->assertContains('Test for DataProviderDependencyTest::testDependency skipped by data provider', $message);
-    }
+		$this->assertContains('Test for DataProviderDependencyTest::testDependency skipped by data provider', $message);
+	}
 
-    public function testIncompleteTestDataProvider()
-    {
-        $suite = new TestSuite(\DataProviderIncompleteTest::class);
+	public function testIncompleteTestDataProvider()
+	{
+		$suite = new TestSuite(\DataProviderIncompleteTest::class);
 
-        $suite->run($this->result);
+		$suite->run($this->result);
 
-        $this->assertEquals(3, $this->result->count());
-        $this->assertEquals(1, $this->result->notImplementedCount());
-    }
+		$this->assertEquals(3, $this->result->count());
+		$this->assertEquals(1, $this->result->notImplementedCount());
+	}
 
-    public function testRequirementsBeforeClassHook()
-    {
-        $suite = new TestSuite(\RequirementsClassBeforeClassHookTest::class);
+	public function testRequirementsBeforeClassHook()
+	{
+		$suite = new TestSuite(\RequirementsClassBeforeClassHookTest::class);
 
-        $suite->run($this->result);
+		$suite->run($this->result);
 
-        $this->assertEquals(0, $this->result->errorCount());
-        $this->assertEquals(1, $this->result->skippedCount());
-    }
+		$this->assertEquals(0, $this->result->errorCount());
+		$this->assertEquals(1, $this->result->skippedCount());
+	}
 
-    public function testDoNotSkipInheritedClass()
-    {
-        $suite = new TestSuite(
-            'DontSkipInheritedClass'
-        );
+	public function testDoNotSkipInheritedClass()
+	{
+		$suite = new TestSuite(
+			'DontSkipInheritedClass'
+		);
 
-        $dir = \dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'Inheritance' . DIRECTORY_SEPARATOR;
+		$dir = \dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'Inheritance' . DIRECTORY_SEPARATOR;
 
-        $suite->addTestFile($dir . 'InheritanceA.php');
-        $suite->addTestFile($dir . 'InheritanceB.php');
+		$suite->addTestFile($dir . 'InheritanceA.php');
+		$suite->addTestFile($dir . 'InheritanceB.php');
 
-        $result = $suite->run();
+		$result = $suite->run();
 
-        $this->assertCount(2, $result);
-    }
+		$this->assertCount(2, $result);
+	}
 }

Spacing +3 added lines, -3 removed lines

@@ -224,10 +224,10 @@
             'DontSkipInheritedClass'
         );
 
-        $dir = \dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'Inheritance' . DIRECTORY_SEPARATOR;
+        $dir = \dirname(__DIR__).DIRECTORY_SEPARATOR.'_files'.DIRECTORY_SEPARATOR.'Inheritance'.DIRECTORY_SEPARATOR;
 
-        $suite->addTestFile($dir . 'InheritanceA.php');
-        $suite->addTestFile($dir . 'InheritanceB.php');
+        $suite->addTestFile($dir.'InheritanceA.php');
+        $suite->addTestFile($dir.'InheritanceB.php');
 
         $result = $suite->run();
 

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

Indentation +701 added lines, -701 removed lines

@@ -14,705 +14,705 @@
 
 class TestCaseTest extends TestCase
 {
-    protected $backupGlobalsBlacklist = ['i', 'singleton'];
-
-    protected static $testStatic = 0;
-
-    public static function setUpBeforeClass()
-    {
-        $GLOBALS['a']  = 'a';
-        $_ENV['b']     = 'b';
-        $_POST['c']    = 'c';
-        $_GET['d']     = 'd';
-        $_COOKIE['e']  = 'e';
-        $_SERVER['f']  = 'f';
-        $_FILES['g']   = 'g';
-        $_REQUEST['h'] = 'h';
-        $GLOBALS['i']  = 'i';
-    }
-
-    public static function tearDownAfterClass()
-    {
-        unset(
-            $GLOBALS['a'],
-            $_ENV['b'],
-            $_POST['c'],
-            $_GET['d'],
-            $_COOKIE['e'],
-            $_SERVER['f'],
-            $_FILES['g'],
-            $_REQUEST['h'],
-            $GLOBALS['i']
-        );
-    }
-
-    public function testCaseToString()
-    {
-        $this->assertEquals(
-            'PHPUnit\Framework\TestCaseTest::testCaseToString',
-            $this->toString()
-        );
-    }
-
-    public function testSuccess()
-    {
-        $test   = new \Success;
-        $result = $test->run();
-
-        $this->assertEquals(BaseTestRunner::STATUS_PASSED, $test->getStatus());
-        $this->assertEquals(0, $result->errorCount());
-        $this->assertEquals(0, $result->failureCount());
-        $this->assertEquals(0, $result->skippedCount());
-        $this->assertCount(1, $result);
-    }
-
-    public function testFailure()
-    {
-        $test   = new \Failure;
-        $result = $test->run();
-
-        $this->assertEquals(BaseTestRunner::STATUS_FAILURE, $test->getStatus());
-        $this->assertEquals(0, $result->errorCount());
-        $this->assertEquals(1, $result->failureCount());
-        $this->assertEquals(0, $result->skippedCount());
-        $this->assertCount(1, $result);
-    }
-
-    public function testError()
-    {
-        $test   = new \TestError;
-        $result = $test->run();
-
-        $this->assertEquals(BaseTestRunner::STATUS_ERROR, $test->getStatus());
-        $this->assertEquals(1, $result->errorCount());
-        $this->assertEquals(0, $result->failureCount());
-        $this->assertEquals(0, $result->skippedCount());
-        $this->assertCount(1, $result);
-    }
-
-    public function testSkipped()
-    {
-        $test   = new \TestSkipped;
-        $result = $test->run();
-
-        $this->assertEquals(BaseTestRunner::STATUS_SKIPPED, $test->getStatus());
-        $this->assertEquals('Skipped test', $test->getStatusMessage());
-        $this->assertEquals(0, $result->errorCount());
-        $this->assertEquals(0, $result->failureCount());
-        $this->assertEquals(1, $result->skippedCount());
-        $this->assertCount(1, $result);
-    }
-
-    public function testIncomplete()
-    {
-        $test   = new \TestIncomplete;
-        $result = $test->run();
-
-        $this->assertEquals(BaseTestRunner::STATUS_INCOMPLETE, $test->getStatus());
-        $this->assertEquals('Incomplete test', $test->getStatusMessage());
-        $this->assertEquals(0, $result->errorCount());
-        $this->assertEquals(0, $result->failureCount());
-        $this->assertEquals(0, $result->skippedCount());
-        $this->assertCount(1, $result);
-    }
-
-    public function testExceptionInSetUp()
-    {
-        $test   = new \ExceptionInSetUpTest('testSomething');
-        $test->run();
-
-        $this->assertTrue($test->setUp);
-        $this->assertFalse($test->assertPreConditions);
-        $this->assertFalse($test->testSomething);
-        $this->assertFalse($test->assertPostConditions);
-        $this->assertTrue($test->tearDown);
-    }
-
-    public function testExceptionInAssertPreConditions()
-    {
-        $test   = new \ExceptionInAssertPreConditionsTest('testSomething');
-        $test->run();
-
-        $this->assertTrue($test->setUp);
-        $this->assertTrue($test->assertPreConditions);
-        $this->assertFalse($test->testSomething);
-        $this->assertFalse($test->assertPostConditions);
-        $this->assertTrue($test->tearDown);
-    }
-
-    public function testExceptionInTest()
-    {
-        $test   = new \ExceptionInTest('testSomething');
-        $test->run();
-
-        $this->assertTrue($test->setUp);
-        $this->assertTrue($test->assertPreConditions);
-        $this->assertTrue($test->testSomething);
-        $this->assertFalse($test->assertPostConditions);
-        $this->assertTrue($test->tearDown);
-    }
-
-    public function testExceptionInAssertPostConditions()
-    {
-        $test   = new \ExceptionInAssertPostConditionsTest('testSomething');
-        $test->run();
-
-        $this->assertTrue($test->setUp);
-        $this->assertTrue($test->assertPreConditions);
-        $this->assertTrue($test->testSomething);
-        $this->assertTrue($test->assertPostConditions);
-        $this->assertTrue($test->tearDown);
-    }
-
-    public function testExceptionInTearDown()
-    {
-        $test   = new \ExceptionInTearDownTest('testSomething');
-        $test->run();
-
-        $this->assertTrue($test->setUp);
-        $this->assertTrue($test->assertPreConditions);
-        $this->assertTrue($test->testSomething);
-        $this->assertTrue($test->assertPostConditions);
-        $this->assertTrue($test->tearDown);
-    }
-
-    public function testNoArgTestCasePasses()
-    {
-        $result = new TestResult;
-        $t      = new TestSuite(\NoArgTestCaseTest::class);
-
-        $t->run($result);
-
-        $this->assertCount(1, $result);
-        $this->assertEquals(0, $result->failureCount());
-        $this->assertEquals(0, $result->errorCount());
-    }
-
-    public function testWasRun()
-    {
-        $test = new \WasRun;
-        $test->run();
-
-        $this->assertTrue($test->wasRun);
-    }
-
-    public function testException()
-    {
-        $test = new \ThrowExceptionTestCase('test');
-        $test->expectException(\RuntimeException::class);
-
-        $result = $test->run();
-
-        $this->assertCount(1, $result);
-        $this->assertTrue($result->wasSuccessful());
-    }
-
-    public function testExceptionWithEmptyMessage()
-    {
-        $test = new \ThrowExceptionTestCase('test');
-        $test->expectException(\RuntimeException::class);
-
-        $result = $test->run();
-
-        $this->assertCount(1, $result);
-        $this->assertTrue($result->wasSuccessful());
-    }
-
-    public function testExceptionWithNullMessage()
-    {
-        $test = new \ThrowExceptionTestCase('test');
-        $test->expectException(\RuntimeException::class);
-
-        $result = $test->run();
-
-        $this->assertCount(1, $result);
-        $this->assertTrue($result->wasSuccessful());
-    }
-
-    public function testExceptionWithMessage()
-    {
-        $test = new \ThrowExceptionTestCase('test');
-        $test->expectException(\RuntimeException::class);
-        $test->expectExceptionMessage('A runtime error occurred');
-
-        $result = $test->run();
-
-        $this->assertCount(1, $result);
-        $this->assertTrue($result->wasSuccessful());
-    }
-
-    public function testExceptionWithWrongMessage()
-    {
-        $test = new \ThrowExceptionTestCase('test');
-        $test->expectException(\RuntimeException::class);
-        $test->expectExceptionMessage('A logic error occurred');
-
-        $result = $test->run();
-
-        $this->assertEquals(1, $result->failureCount());
-        $this->assertCount(1, $result);
-        $this->assertEquals(
-            "Failed asserting that exception message 'A runtime error occurred' contains 'A logic error occurred'.",
-            $test->getStatusMessage()
-        );
-    }
-
-    public function testExceptionWithRegexpMessage()
-    {
-        $test = new \ThrowExceptionTestCase('test');
-        $test->expectException(\RuntimeException::class);
-        $test->expectExceptionMessageRegExp('/runtime .*? occurred/');
-
-        $result = $test->run();
-
-        $this->assertCount(1, $result);
-        $this->assertTrue($result->wasSuccessful());
-    }
-
-    public function testExceptionWithWrongRegexpMessage()
-    {
-        $test = new \ThrowExceptionTestCase('test');
-        $test->expectException(\RuntimeException::class);
-        $test->expectExceptionMessageRegExp('/logic .*? occurred/');
-
-        $result = $test->run();
-
-        $this->assertEquals(1, $result->failureCount());
-        $this->assertCount(1, $result);
-        $this->assertEquals(
-            "Failed asserting that exception message 'A runtime error occurred' matches '/logic .*? occurred/'.",
-            $test->getStatusMessage()
-        );
-    }
-
-    public function testExceptionWithInvalidRegexpMessage()
-    {
-        $test = new \ThrowExceptionTestCase('test');
-        $test->expectException(\RuntimeException::class);
-        $test->expectExceptionMessageRegExp('#runtime .*? occurred/');
-
-        $test->run();
-
-        $this->assertEquals(
-            "Invalid expected exception message regex given: '#runtime .*? occurred/'",
-            $test->getStatusMessage()
-        );
-    }
-
-    public function testNoException()
-    {
-        $test = new \ThrowNoExceptionTestCase('test');
-        $test->expectException(\RuntimeException::class);
-
-        $result = $test->run();
-
-        $this->assertEquals(1, $result->failureCount());
-        $this->assertCount(1, $result);
-    }
-
-    public function testWrongException()
-    {
-        $test = new \ThrowExceptionTestCase('test');
-        $test->expectException(\InvalidArgumentException::class);
-
-        $result = $test->run();
-
-        $this->assertEquals(1, $result->failureCount());
-        $this->assertCount(1, $result);
-    }
-
-    /**
-     * @backupGlobals enabled
-     */
-    public function testGlobalsBackupPre()
-    {
-        global $a;
-        global $i;
-
-        $this->assertEquals('a', $a);
-        $this->assertEquals('a', $GLOBALS['a']);
-        $this->assertEquals('b', $_ENV['b']);
-        $this->assertEquals('c', $_POST['c']);
-        $this->assertEquals('d', $_GET['d']);
-        $this->assertEquals('e', $_COOKIE['e']);
-        $this->assertEquals('f', $_SERVER['f']);
-        $this->assertEquals('g', $_FILES['g']);
-        $this->assertEquals('h', $_REQUEST['h']);
-        $this->assertEquals('i', $i);
-        $this->assertEquals('i', $GLOBALS['i']);
-
-        $GLOBALS['a']   = 'aa';
-        $GLOBALS['foo'] = 'bar';
-        $_ENV['b']      = 'bb';
-        $_POST['c']     = 'cc';
-        $_GET['d']      = 'dd';
-        $_COOKIE['e']   = 'ee';
-        $_SERVER['f']   = 'ff';
-        $_FILES['g']    = 'gg';
-        $_REQUEST['h']  = 'hh';
-        $GLOBALS['i']   = 'ii';
-
-        $this->assertEquals('aa', $a);
-        $this->assertEquals('aa', $GLOBALS['a']);
-        $this->assertEquals('bar', $GLOBALS['foo']);
-        $this->assertEquals('bb', $_ENV['b']);
-        $this->assertEquals('cc', $_POST['c']);
-        $this->assertEquals('dd', $_GET['d']);
-        $this->assertEquals('ee', $_COOKIE['e']);
-        $this->assertEquals('ff', $_SERVER['f']);
-        $this->assertEquals('gg', $_FILES['g']);
-        $this->assertEquals('hh', $_REQUEST['h']);
-        $this->assertEquals('ii', $i);
-        $this->assertEquals('ii', $GLOBALS['i']);
-    }
-
-    public function testGlobalsBackupPost()
-    {
-        global $a;
-        global $i;
-
-        $this->assertEquals('a', $a);
-        $this->assertEquals('a', $GLOBALS['a']);
-        $this->assertEquals('b', $_ENV['b']);
-        $this->assertEquals('c', $_POST['c']);
-        $this->assertEquals('d', $_GET['d']);
-        $this->assertEquals('e', $_COOKIE['e']);
-        $this->assertEquals('f', $_SERVER['f']);
-        $this->assertEquals('g', $_FILES['g']);
-        $this->assertEquals('h', $_REQUEST['h']);
-        $this->assertEquals('ii', $i);
-        $this->assertEquals('ii', $GLOBALS['i']);
-
-        $this->assertArrayNotHasKey('foo', $GLOBALS);
-    }
-
-    /**
-     * @backupGlobals enabled
-     * @backupStaticAttributes enabled
-     *
-     * @doesNotPerformAssertions
-     */
-    public function testStaticAttributesBackupPre()
-    {
-        $GLOBALS['singleton'] = \Singleton::getInstance();
-        self::$testStatic     = 123;
-    }
-
-    /**
-     * @depends testStaticAttributesBackupPre
-     */
-    public function testStaticAttributesBackupPost()
-    {
-        $this->assertNotSame($GLOBALS['singleton'], \Singleton::getInstance());
-        $this->assertSame(0, self::$testStatic);
-    }
-
-    public function testIsInIsolationReturnsFalse()
-    {
-        $test   = new \IsolationTest('testIsInIsolationReturnsFalse');
-        $result = $test->run();
-
-        $this->assertCount(1, $result);
-        $this->assertTrue($result->wasSuccessful());
-    }
-
-    public function testIsInIsolationReturnsTrue()
-    {
-        $test   = new \IsolationTest('testIsInIsolationReturnsTrue');
-        $test->setRunTestInSeparateProcess(true);
-        $result = $test->run();
-
-        $this->assertCount(1, $result);
-        $this->assertTrue($result->wasSuccessful());
-    }
-
-    public function testExpectOutputStringFooActualFoo()
-    {
-        $test   = new \OutputTestCase('testExpectOutputStringFooActualFoo');
-        $result = $test->run();
-
-        $this->assertCount(1, $result);
-        $this->assertTrue($result->wasSuccessful());
-    }
-
-    public function testExpectOutputStringFooActualBar()
-    {
-        $test   = new \OutputTestCase('testExpectOutputStringFooActualBar');
-        $result = $test->run();
-
-        $this->assertCount(1, $result);
-        $this->assertFalse($result->wasSuccessful());
-    }
-
-    public function testExpectOutputRegexFooActualFoo()
-    {
-        $test   = new \OutputTestCase('testExpectOutputRegexFooActualFoo');
-        $result = $test->run();
-
-        $this->assertCount(1, $result);
-        $this->assertTrue($result->wasSuccessful());
-    }
-
-    public function testExpectOutputRegexFooActualBar()
-    {
-        $test   = new \OutputTestCase('testExpectOutputRegexFooActualBar');
-        $result = $test->run();
-
-        $this->assertCount(1, $result);
-        $this->assertFalse($result->wasSuccessful());
-    }
-
-    public function testSkipsIfRequiresHigherVersionOfPHPUnit()
-    {
-        $test   = new \RequirementsTest('testAlwaysSkip');
-        $result = $test->run();
-
-        $this->assertEquals(1, $result->skippedCount());
-        $this->assertEquals(
-            'PHPUnit >= 1111111 is required.',
-            $test->getStatusMessage()
-        );
-    }
-
-    public function testSkipsIfRequiresHigherVersionOfPHP()
-    {
-        $test   = new \RequirementsTest('testAlwaysSkip2');
-        $result = $test->run();
-
-        $this->assertEquals(1, $result->skippedCount());
-        $this->assertEquals(
-            'PHP >= 9999999 is required.',
-            $test->getStatusMessage()
-        );
-    }
-
-    public function testSkipsIfRequiresNonExistingOs()
-    {
-        $test   = new \RequirementsTest('testAlwaysSkip3');
-        $result = $test->run();
-
-        $this->assertEquals(1, $result->skippedCount());
-        $this->assertEquals(
-            'Operating system matching /DOESNOTEXIST/i is required.',
-            $test->getStatusMessage()
-        );
-    }
-
-    public function testSkipsIfRequiresNonExistingOsFamily()
-    {
-        $test   = new \RequirementsTest('testAlwaysSkip4');
-        $result = $test->run();
-
-        $this->assertEquals(1, $result->skippedCount());
-        $this->assertEquals(
-            'Operating system DOESNOTEXIST is required.',
-            $test->getStatusMessage()
-        );
-    }
-
-    public function testSkipsIfRequiresNonExistingFunction()
-    {
-        $test   = new \RequirementsTest('testNine');
-        $result = $test->run();
-
-        $this->assertEquals(1, $result->skippedCount());
-        $this->assertEquals(
-            'Function testFunc is required.',
-            $test->getStatusMessage()
-        );
-    }
-
-    public function testSkipsIfRequiresNonExistingExtension()
-    {
-        $test   = new \RequirementsTest('testTen');
-        $test->run();
-
-        $this->assertEquals(
-            'Extension testExt is required.',
-            $test->getStatusMessage()
-        );
-    }
-
-    public function testSkipsIfRequiresExtensionWithAMinimumVersion()
-    {
-        $test   = new \RequirementsTest('testSpecificExtensionVersion');
-        $test->run();
-
-        $this->assertEquals(
-            'Extension testExt >= 1.8.0 is required.',
-            $test->getStatusMessage()
-        );
-    }
-
-    public function testSkipsProvidesMessagesForAllSkippingReasons()
-    {
-        $test   = new \RequirementsTest('testAllPossibleRequirements');
-        $test->run();
-
-        $this->assertEquals(
-            'PHP >= 99-dev is required.' . PHP_EOL .
-            'PHPUnit >= 9-dev is required.' . PHP_EOL .
-            'Operating system matching /DOESNOTEXIST/i is required.' . PHP_EOL .
-            'Function testFuncOne is required.' . PHP_EOL .
-            'Function testFuncTwo is required.' . PHP_EOL .
-            'Extension testExtOne is required.' . PHP_EOL .
-            'Extension testExtTwo is required.' . PHP_EOL .
-            'Extension testExtThree >= 2.0 is required.',
-            $test->getStatusMessage()
-        );
-    }
-
-    public function testRequiringAnExistingMethodDoesNotSkip()
-    {
-        $test   = new \RequirementsTest('testExistingMethod');
-        $result = $test->run();
-        $this->assertEquals(0, $result->skippedCount());
-    }
-
-    public function testRequiringAnExistingFunctionDoesNotSkip()
-    {
-        $test   = new \RequirementsTest('testExistingFunction');
-        $result = $test->run();
-        $this->assertEquals(0, $result->skippedCount());
-    }
-
-    public function testRequiringAnExistingExtensionDoesNotSkip()
-    {
-        $test   = new \RequirementsTest('testExistingExtension');
-        $result = $test->run();
-        $this->assertEquals(0, $result->skippedCount());
-    }
-
-    public function testRequiringAnExistingOsDoesNotSkip()
-    {
-        $test   = new \RequirementsTest('testExistingOs');
-        $result = $test->run();
-        $this->assertEquals(0, $result->skippedCount());
-    }
-
-    public function testCurrentWorkingDirectoryIsRestored()
-    {
-        $expectedCwd = \getcwd();
-
-        $test = new \ChangeCurrentWorkingDirectoryTest('testSomethingThatChangesTheCwd');
-        $test->run();
-
-        $this->assertSame($expectedCwd, \getcwd());
-    }
-
-    /**
-     * @requires PHP 7
-     * @expectedException \TypeError
-     */
-    public function testTypeErrorCanBeExpected()
-    {
-        $o = new \ClassWithScalarTypeDeclarations;
-        $o->foo(null, null);
-    }
-
-    public function testCreateMockFromClassName()
-    {
-        $mock = $this->createMock(\Mockable::class);
-
-        $this->assertInstanceOf(\Mockable::class, $mock);
-        $this->assertInstanceOf(\PHPUnit_Framework_MockObject_MockObject::class, $mock);
-    }
-
-    public function testCreateMockMocksAllMethods()
-    {
-        /** @var \Mockable $mock */
-        $mock = $this->createMock(\Mockable::class);
-
-        $this->assertNull($mock->foo());
-        $this->assertNull($mock->bar());
-    }
-
-    public function testCreatePartialMockDoesNotMockAllMethods()
-    {
-        /** @var \Mockable $mock */
-        $mock = $this->createPartialMock(\Mockable::class, ['foo']);
-
-        $this->assertNull($mock->foo());
-        $this->assertTrue($mock->bar());
-    }
-
-    public function testCreatePartialMockCanMockNoMethods()
-    {
-        /** @var \Mockable $mock */
-        $mock = $this->createPartialMock(\Mockable::class, []);
-
-        $this->assertTrue($mock->foo());
-        $this->assertTrue($mock->bar());
-    }
-
-    public function testCreateMockSkipsConstructor()
-    {
-        /** @var \Mockable $mock */
-        $mock = $this->createMock(\Mockable::class);
-
-        $this->assertFalse($mock->constructorCalled);
-    }
-
-    public function testCreateMockDisablesOriginalClone()
-    {
-        /** @var \Mockable $mock */
-        $mock = $this->createMock(\Mockable::class);
-
-        $cloned = clone $mock;
-        $this->assertFalse($cloned->cloned);
-    }
-
-    public function testConfiguredMockCanBeCreated()
-    {
-        /** @var \Mockable $mock */
-        $mock = $this->createConfiguredMock(
-            \Mockable::class,
-            [
-                'foo' => false
-            ]
-        );
-
-        $this->assertFalse($mock->foo());
-        $this->assertNull($mock->bar());
-    }
-
-    public function testProvidingOfAutoreferencedArray()
-    {
-        $test = new \TestAutoreferenced('testJsonEncodeException', $this->getAutoreferencedArray());
-        $test->runBare();
-
-        $this->assertInternalType('array', $test->myTestData);
-        $this->assertArrayHasKey('data', $test->myTestData);
-        $this->assertEquals($test->myTestData['data'][0], $test->myTestData['data']);
-    }
-
-    /**
-     * @return array<string, array>
-     */
-    private function getAutoreferencedArray()
-    {
-        $recursionData   = [];
-        $recursionData[] = &$recursionData;
-
-        return [
-            'RECURSION' => [
-                'data' => $recursionData
-            ]
-        ];
-    }
-
-    public function testProvidingArrayThatMixesObjectsAndScalars()
-    {
-        $data = [
-            [123],
-            ['foo'],
-            [$this->createMock(\Mockable::class)],
-        ];
-
-        $test = new \TestAutoreferenced('testJsonEncodeException', [$data]);
-        $test->runBare();
-
-        $this->assertInternalType('array', $test->myTestData);
-        $this->assertSame($data, $test->myTestData);
-    }
+	protected $backupGlobalsBlacklist = ['i', 'singleton'];
+
+	protected static $testStatic = 0;
+
+	public static function setUpBeforeClass()
+	{
+		$GLOBALS['a']  = 'a';
+		$_ENV['b']     = 'b';
+		$_POST['c']    = 'c';
+		$_GET['d']     = 'd';
+		$_COOKIE['e']  = 'e';
+		$_SERVER['f']  = 'f';
+		$_FILES['g']   = 'g';
+		$_REQUEST['h'] = 'h';
+		$GLOBALS['i']  = 'i';
+	}
+
+	public static function tearDownAfterClass()
+	{
+		unset(
+			$GLOBALS['a'],
+			$_ENV['b'],
+			$_POST['c'],
+			$_GET['d'],
+			$_COOKIE['e'],
+			$_SERVER['f'],
+			$_FILES['g'],
+			$_REQUEST['h'],
+			$GLOBALS['i']
+		);
+	}
+
+	public function testCaseToString()
+	{
+		$this->assertEquals(
+			'PHPUnit\Framework\TestCaseTest::testCaseToString',
+			$this->toString()
+		);
+	}
+
+	public function testSuccess()
+	{
+		$test   = new \Success;
+		$result = $test->run();
+
+		$this->assertEquals(BaseTestRunner::STATUS_PASSED, $test->getStatus());
+		$this->assertEquals(0, $result->errorCount());
+		$this->assertEquals(0, $result->failureCount());
+		$this->assertEquals(0, $result->skippedCount());
+		$this->assertCount(1, $result);
+	}
+
+	public function testFailure()
+	{
+		$test   = new \Failure;
+		$result = $test->run();
+
+		$this->assertEquals(BaseTestRunner::STATUS_FAILURE, $test->getStatus());
+		$this->assertEquals(0, $result->errorCount());
+		$this->assertEquals(1, $result->failureCount());
+		$this->assertEquals(0, $result->skippedCount());
+		$this->assertCount(1, $result);
+	}
+
+	public function testError()
+	{
+		$test   = new \TestError;
+		$result = $test->run();
+
+		$this->assertEquals(BaseTestRunner::STATUS_ERROR, $test->getStatus());
+		$this->assertEquals(1, $result->errorCount());
+		$this->assertEquals(0, $result->failureCount());
+		$this->assertEquals(0, $result->skippedCount());
+		$this->assertCount(1, $result);
+	}
+
+	public function testSkipped()
+	{
+		$test   = new \TestSkipped;
+		$result = $test->run();
+
+		$this->assertEquals(BaseTestRunner::STATUS_SKIPPED, $test->getStatus());
+		$this->assertEquals('Skipped test', $test->getStatusMessage());
+		$this->assertEquals(0, $result->errorCount());
+		$this->assertEquals(0, $result->failureCount());
+		$this->assertEquals(1, $result->skippedCount());
+		$this->assertCount(1, $result);
+	}
+
+	public function testIncomplete()
+	{
+		$test   = new \TestIncomplete;
+		$result = $test->run();
+
+		$this->assertEquals(BaseTestRunner::STATUS_INCOMPLETE, $test->getStatus());
+		$this->assertEquals('Incomplete test', $test->getStatusMessage());
+		$this->assertEquals(0, $result->errorCount());
+		$this->assertEquals(0, $result->failureCount());
+		$this->assertEquals(0, $result->skippedCount());
+		$this->assertCount(1, $result);
+	}
+
+	public function testExceptionInSetUp()
+	{
+		$test   = new \ExceptionInSetUpTest('testSomething');
+		$test->run();
+
+		$this->assertTrue($test->setUp);
+		$this->assertFalse($test->assertPreConditions);
+		$this->assertFalse($test->testSomething);
+		$this->assertFalse($test->assertPostConditions);
+		$this->assertTrue($test->tearDown);
+	}
+
+	public function testExceptionInAssertPreConditions()
+	{
+		$test   = new \ExceptionInAssertPreConditionsTest('testSomething');
+		$test->run();
+
+		$this->assertTrue($test->setUp);
+		$this->assertTrue($test->assertPreConditions);
+		$this->assertFalse($test->testSomething);
+		$this->assertFalse($test->assertPostConditions);
+		$this->assertTrue($test->tearDown);
+	}
+
+	public function testExceptionInTest()
+	{
+		$test   = new \ExceptionInTest('testSomething');
+		$test->run();
+
+		$this->assertTrue($test->setUp);
+		$this->assertTrue($test->assertPreConditions);
+		$this->assertTrue($test->testSomething);
+		$this->assertFalse($test->assertPostConditions);
+		$this->assertTrue($test->tearDown);
+	}
+
+	public function testExceptionInAssertPostConditions()
+	{
+		$test   = new \ExceptionInAssertPostConditionsTest('testSomething');
+		$test->run();
+
+		$this->assertTrue($test->setUp);
+		$this->assertTrue($test->assertPreConditions);
+		$this->assertTrue($test->testSomething);
+		$this->assertTrue($test->assertPostConditions);
+		$this->assertTrue($test->tearDown);
+	}
+
+	public function testExceptionInTearDown()
+	{
+		$test   = new \ExceptionInTearDownTest('testSomething');
+		$test->run();
+
+		$this->assertTrue($test->setUp);
+		$this->assertTrue($test->assertPreConditions);
+		$this->assertTrue($test->testSomething);
+		$this->assertTrue($test->assertPostConditions);
+		$this->assertTrue($test->tearDown);
+	}
+
+	public function testNoArgTestCasePasses()
+	{
+		$result = new TestResult;
+		$t      = new TestSuite(\NoArgTestCaseTest::class);
+
+		$t->run($result);
+
+		$this->assertCount(1, $result);
+		$this->assertEquals(0, $result->failureCount());
+		$this->assertEquals(0, $result->errorCount());
+	}
+
+	public function testWasRun()
+	{
+		$test = new \WasRun;
+		$test->run();
+
+		$this->assertTrue($test->wasRun);
+	}
+
+	public function testException()
+	{
+		$test = new \ThrowExceptionTestCase('test');
+		$test->expectException(\RuntimeException::class);
+
+		$result = $test->run();
+
+		$this->assertCount(1, $result);
+		$this->assertTrue($result->wasSuccessful());
+	}
+
+	public function testExceptionWithEmptyMessage()
+	{
+		$test = new \ThrowExceptionTestCase('test');
+		$test->expectException(\RuntimeException::class);
+
+		$result = $test->run();
+
+		$this->assertCount(1, $result);
+		$this->assertTrue($result->wasSuccessful());
+	}
+
+	public function testExceptionWithNullMessage()
+	{
+		$test = new \ThrowExceptionTestCase('test');
+		$test->expectException(\RuntimeException::class);
+
+		$result = $test->run();
+
+		$this->assertCount(1, $result);
+		$this->assertTrue($result->wasSuccessful());
+	}
+
+	public function testExceptionWithMessage()
+	{
+		$test = new \ThrowExceptionTestCase('test');
+		$test->expectException(\RuntimeException::class);
+		$test->expectExceptionMessage('A runtime error occurred');
+
+		$result = $test->run();
+
+		$this->assertCount(1, $result);
+		$this->assertTrue($result->wasSuccessful());
+	}
+
+	public function testExceptionWithWrongMessage()
+	{
+		$test = new \ThrowExceptionTestCase('test');
+		$test->expectException(\RuntimeException::class);
+		$test->expectExceptionMessage('A logic error occurred');
+
+		$result = $test->run();
+
+		$this->assertEquals(1, $result->failureCount());
+		$this->assertCount(1, $result);
+		$this->assertEquals(
+			"Failed asserting that exception message 'A runtime error occurred' contains 'A logic error occurred'.",
+			$test->getStatusMessage()
+		);
+	}
+
+	public function testExceptionWithRegexpMessage()
+	{
+		$test = new \ThrowExceptionTestCase('test');
+		$test->expectException(\RuntimeException::class);
+		$test->expectExceptionMessageRegExp('/runtime .*? occurred/');
+
+		$result = $test->run();
+
+		$this->assertCount(1, $result);
+		$this->assertTrue($result->wasSuccessful());
+	}
+
+	public function testExceptionWithWrongRegexpMessage()
+	{
+		$test = new \ThrowExceptionTestCase('test');
+		$test->expectException(\RuntimeException::class);
+		$test->expectExceptionMessageRegExp('/logic .*? occurred/');
+
+		$result = $test->run();
+
+		$this->assertEquals(1, $result->failureCount());
+		$this->assertCount(1, $result);
+		$this->assertEquals(
+			"Failed asserting that exception message 'A runtime error occurred' matches '/logic .*? occurred/'.",
+			$test->getStatusMessage()
+		);
+	}
+
+	public function testExceptionWithInvalidRegexpMessage()
+	{
+		$test = new \ThrowExceptionTestCase('test');
+		$test->expectException(\RuntimeException::class);
+		$test->expectExceptionMessageRegExp('#runtime .*? occurred/');
+
+		$test->run();
+
+		$this->assertEquals(
+			"Invalid expected exception message regex given: '#runtime .*? occurred/'",
+			$test->getStatusMessage()
+		);
+	}
+
+	public function testNoException()
+	{
+		$test = new \ThrowNoExceptionTestCase('test');
+		$test->expectException(\RuntimeException::class);
+
+		$result = $test->run();
+
+		$this->assertEquals(1, $result->failureCount());
+		$this->assertCount(1, $result);
+	}
+
+	public function testWrongException()
+	{
+		$test = new \ThrowExceptionTestCase('test');
+		$test->expectException(\InvalidArgumentException::class);
+
+		$result = $test->run();
+
+		$this->assertEquals(1, $result->failureCount());
+		$this->assertCount(1, $result);
+	}
+
+	/**
+	 * @backupGlobals enabled
+	 */
+	public function testGlobalsBackupPre()
+	{
+		global $a;
+		global $i;
+
+		$this->assertEquals('a', $a);
+		$this->assertEquals('a', $GLOBALS['a']);
+		$this->assertEquals('b', $_ENV['b']);
+		$this->assertEquals('c', $_POST['c']);
+		$this->assertEquals('d', $_GET['d']);
+		$this->assertEquals('e', $_COOKIE['e']);
+		$this->assertEquals('f', $_SERVER['f']);
+		$this->assertEquals('g', $_FILES['g']);
+		$this->assertEquals('h', $_REQUEST['h']);
+		$this->assertEquals('i', $i);
+		$this->assertEquals('i', $GLOBALS['i']);
+
+		$GLOBALS['a']   = 'aa';
+		$GLOBALS['foo'] = 'bar';
+		$_ENV['b']      = 'bb';
+		$_POST['c']     = 'cc';
+		$_GET['d']      = 'dd';
+		$_COOKIE['e']   = 'ee';
+		$_SERVER['f']   = 'ff';
+		$_FILES['g']    = 'gg';
+		$_REQUEST['h']  = 'hh';
+		$GLOBALS['i']   = 'ii';
+
+		$this->assertEquals('aa', $a);
+		$this->assertEquals('aa', $GLOBALS['a']);
+		$this->assertEquals('bar', $GLOBALS['foo']);
+		$this->assertEquals('bb', $_ENV['b']);
+		$this->assertEquals('cc', $_POST['c']);
+		$this->assertEquals('dd', $_GET['d']);
+		$this->assertEquals('ee', $_COOKIE['e']);
+		$this->assertEquals('ff', $_SERVER['f']);
+		$this->assertEquals('gg', $_FILES['g']);
+		$this->assertEquals('hh', $_REQUEST['h']);
+		$this->assertEquals('ii', $i);
+		$this->assertEquals('ii', $GLOBALS['i']);
+	}
+
+	public function testGlobalsBackupPost()
+	{
+		global $a;
+		global $i;
+
+		$this->assertEquals('a', $a);
+		$this->assertEquals('a', $GLOBALS['a']);
+		$this->assertEquals('b', $_ENV['b']);
+		$this->assertEquals('c', $_POST['c']);
+		$this->assertEquals('d', $_GET['d']);
+		$this->assertEquals('e', $_COOKIE['e']);
+		$this->assertEquals('f', $_SERVER['f']);
+		$this->assertEquals('g', $_FILES['g']);
+		$this->assertEquals('h', $_REQUEST['h']);
+		$this->assertEquals('ii', $i);
+		$this->assertEquals('ii', $GLOBALS['i']);
+
+		$this->assertArrayNotHasKey('foo', $GLOBALS);
+	}
+
+	/**
+	 * @backupGlobals enabled
+	 * @backupStaticAttributes enabled
+	 *
+	 * @doesNotPerformAssertions
+	 */
+	public function testStaticAttributesBackupPre()
+	{
+		$GLOBALS['singleton'] = \Singleton::getInstance();
+		self::$testStatic     = 123;
+	}
+
+	/**
+	 * @depends testStaticAttributesBackupPre
+	 */
+	public function testStaticAttributesBackupPost()
+	{
+		$this->assertNotSame($GLOBALS['singleton'], \Singleton::getInstance());
+		$this->assertSame(0, self::$testStatic);
+	}
+
+	public function testIsInIsolationReturnsFalse()
+	{
+		$test   = new \IsolationTest('testIsInIsolationReturnsFalse');
+		$result = $test->run();
+
+		$this->assertCount(1, $result);
+		$this->assertTrue($result->wasSuccessful());
+	}
+
+	public function testIsInIsolationReturnsTrue()
+	{
+		$test   = new \IsolationTest('testIsInIsolationReturnsTrue');
+		$test->setRunTestInSeparateProcess(true);
+		$result = $test->run();
+
+		$this->assertCount(1, $result);
+		$this->assertTrue($result->wasSuccessful());
+	}
+
+	public function testExpectOutputStringFooActualFoo()
+	{
+		$test   = new \OutputTestCase('testExpectOutputStringFooActualFoo');
+		$result = $test->run();
+
+		$this->assertCount(1, $result);
+		$this->assertTrue($result->wasSuccessful());
+	}
+
+	public function testExpectOutputStringFooActualBar()
+	{
+		$test   = new \OutputTestCase('testExpectOutputStringFooActualBar');
+		$result = $test->run();
+
+		$this->assertCount(1, $result);
+		$this->assertFalse($result->wasSuccessful());
+	}
+
+	public function testExpectOutputRegexFooActualFoo()
+	{
+		$test   = new \OutputTestCase('testExpectOutputRegexFooActualFoo');
+		$result = $test->run();
+
+		$this->assertCount(1, $result);
+		$this->assertTrue($result->wasSuccessful());
+	}
+
+	public function testExpectOutputRegexFooActualBar()
+	{
+		$test   = new \OutputTestCase('testExpectOutputRegexFooActualBar');
+		$result = $test->run();
+
+		$this->assertCount(1, $result);
+		$this->assertFalse($result->wasSuccessful());
+	}
+
+	public function testSkipsIfRequiresHigherVersionOfPHPUnit()
+	{
+		$test   = new \RequirementsTest('testAlwaysSkip');
+		$result = $test->run();
+
+		$this->assertEquals(1, $result->skippedCount());
+		$this->assertEquals(
+			'PHPUnit >= 1111111 is required.',
+			$test->getStatusMessage()
+		);
+	}
+
+	public function testSkipsIfRequiresHigherVersionOfPHP()
+	{
+		$test   = new \RequirementsTest('testAlwaysSkip2');
+		$result = $test->run();
+
+		$this->assertEquals(1, $result->skippedCount());
+		$this->assertEquals(
+			'PHP >= 9999999 is required.',
+			$test->getStatusMessage()
+		);
+	}
+
+	public function testSkipsIfRequiresNonExistingOs()
+	{
+		$test   = new \RequirementsTest('testAlwaysSkip3');
+		$result = $test->run();
+
+		$this->assertEquals(1, $result->skippedCount());
+		$this->assertEquals(
+			'Operating system matching /DOESNOTEXIST/i is required.',
+			$test->getStatusMessage()
+		);
+	}
+
+	public function testSkipsIfRequiresNonExistingOsFamily()
+	{
+		$test   = new \RequirementsTest('testAlwaysSkip4');
+		$result = $test->run();
+
+		$this->assertEquals(1, $result->skippedCount());
+		$this->assertEquals(
+			'Operating system DOESNOTEXIST is required.',
+			$test->getStatusMessage()
+		);
+	}
+
+	public function testSkipsIfRequiresNonExistingFunction()
+	{
+		$test   = new \RequirementsTest('testNine');
+		$result = $test->run();
+
+		$this->assertEquals(1, $result->skippedCount());
+		$this->assertEquals(
+			'Function testFunc is required.',
+			$test->getStatusMessage()
+		);
+	}
+
+	public function testSkipsIfRequiresNonExistingExtension()
+	{
+		$test   = new \RequirementsTest('testTen');
+		$test->run();
+
+		$this->assertEquals(
+			'Extension testExt is required.',
+			$test->getStatusMessage()
+		);
+	}
+
+	public function testSkipsIfRequiresExtensionWithAMinimumVersion()
+	{
+		$test   = new \RequirementsTest('testSpecificExtensionVersion');
+		$test->run();
+
+		$this->assertEquals(
+			'Extension testExt >= 1.8.0 is required.',
+			$test->getStatusMessage()
+		);
+	}
+
+	public function testSkipsProvidesMessagesForAllSkippingReasons()
+	{
+		$test   = new \RequirementsTest('testAllPossibleRequirements');
+		$test->run();
+
+		$this->assertEquals(
+			'PHP >= 99-dev is required.' . PHP_EOL .
+			'PHPUnit >= 9-dev is required.' . PHP_EOL .
+			'Operating system matching /DOESNOTEXIST/i is required.' . PHP_EOL .
+			'Function testFuncOne is required.' . PHP_EOL .
+			'Function testFuncTwo is required.' . PHP_EOL .
+			'Extension testExtOne is required.' . PHP_EOL .
+			'Extension testExtTwo is required.' . PHP_EOL .
+			'Extension testExtThree >= 2.0 is required.',
+			$test->getStatusMessage()
+		);
+	}
+
+	public function testRequiringAnExistingMethodDoesNotSkip()
+	{
+		$test   = new \RequirementsTest('testExistingMethod');
+		$result = $test->run();
+		$this->assertEquals(0, $result->skippedCount());
+	}
+
+	public function testRequiringAnExistingFunctionDoesNotSkip()
+	{
+		$test   = new \RequirementsTest('testExistingFunction');
+		$result = $test->run();
+		$this->assertEquals(0, $result->skippedCount());
+	}
+
+	public function testRequiringAnExistingExtensionDoesNotSkip()
+	{
+		$test   = new \RequirementsTest('testExistingExtension');
+		$result = $test->run();
+		$this->assertEquals(0, $result->skippedCount());
+	}
+
+	public function testRequiringAnExistingOsDoesNotSkip()
+	{
+		$test   = new \RequirementsTest('testExistingOs');
+		$result = $test->run();
+		$this->assertEquals(0, $result->skippedCount());
+	}
+
+	public function testCurrentWorkingDirectoryIsRestored()
+	{
+		$expectedCwd = \getcwd();
+
+		$test = new \ChangeCurrentWorkingDirectoryTest('testSomethingThatChangesTheCwd');
+		$test->run();
+
+		$this->assertSame($expectedCwd, \getcwd());
+	}
+
+	/**
+	 * @requires PHP 7
+	 * @expectedException \TypeError
+	 */
+	public function testTypeErrorCanBeExpected()
+	{
+		$o = new \ClassWithScalarTypeDeclarations;
+		$o->foo(null, null);
+	}
+
+	public function testCreateMockFromClassName()
+	{
+		$mock = $this->createMock(\Mockable::class);
+
+		$this->assertInstanceOf(\Mockable::class, $mock);
+		$this->assertInstanceOf(\PHPUnit_Framework_MockObject_MockObject::class, $mock);
+	}
+
+	public function testCreateMockMocksAllMethods()
+	{
+		/** @var \Mockable $mock */
+		$mock = $this->createMock(\Mockable::class);
+
+		$this->assertNull($mock->foo());
+		$this->assertNull($mock->bar());
+	}
+
+	public function testCreatePartialMockDoesNotMockAllMethods()
+	{
+		/** @var \Mockable $mock */
+		$mock = $this->createPartialMock(\Mockable::class, ['foo']);
+
+		$this->assertNull($mock->foo());
+		$this->assertTrue($mock->bar());
+	}
+
+	public function testCreatePartialMockCanMockNoMethods()
+	{
+		/** @var \Mockable $mock */
+		$mock = $this->createPartialMock(\Mockable::class, []);
+
+		$this->assertTrue($mock->foo());
+		$this->assertTrue($mock->bar());
+	}
+
+	public function testCreateMockSkipsConstructor()
+	{
+		/** @var \Mockable $mock */
+		$mock = $this->createMock(\Mockable::class);
+
+		$this->assertFalse($mock->constructorCalled);
+	}
+
+	public function testCreateMockDisablesOriginalClone()
+	{
+		/** @var \Mockable $mock */
+		$mock = $this->createMock(\Mockable::class);
+
+		$cloned = clone $mock;
+		$this->assertFalse($cloned->cloned);
+	}
+
+	public function testConfiguredMockCanBeCreated()
+	{
+		/** @var \Mockable $mock */
+		$mock = $this->createConfiguredMock(
+			\Mockable::class,
+			[
+				'foo' => false
+			]
+		);
+
+		$this->assertFalse($mock->foo());
+		$this->assertNull($mock->bar());
+	}
+
+	public function testProvidingOfAutoreferencedArray()
+	{
+		$test = new \TestAutoreferenced('testJsonEncodeException', $this->getAutoreferencedArray());
+		$test->runBare();
+
+		$this->assertInternalType('array', $test->myTestData);
+		$this->assertArrayHasKey('data', $test->myTestData);
+		$this->assertEquals($test->myTestData['data'][0], $test->myTestData['data']);
+	}
+
+	/**
+	 * @return array<string, array>
+	 */
+	private function getAutoreferencedArray()
+	{
+		$recursionData   = [];
+		$recursionData[] = &$recursionData;
+
+		return [
+			'RECURSION' => [
+				'data' => $recursionData
+			]
+		];
+	}
+
+	public function testProvidingArrayThatMixesObjectsAndScalars()
+	{
+		$data = [
+			[123],
+			['foo'],
+			[$this->createMock(\Mockable::class)],
+		];
+
+		$test = new \TestAutoreferenced('testJsonEncodeException', [$data]);
+		$test->runBare();
+
+		$this->assertInternalType('array', $test->myTestData);
+		$this->assertSame($data, $test->myTestData);
+	}
 }

Spacing +15 added lines, -15 removed lines

@@ -118,7 +118,7 @@ 
 
     public function testExceptionInSetUp()
     {
-        $test   = new \ExceptionInSetUpTest('testSomething');
+        $test = new \ExceptionInSetUpTest('testSomething');
         $test->run();
 
         $this->assertTrue($test->setUp);
@@ -130,7 +130,7 @@ 
 
     public function testExceptionInAssertPreConditions()
     {
-        $test   = new \ExceptionInAssertPreConditionsTest('testSomething');
+        $test = new \ExceptionInAssertPreConditionsTest('testSomething');
         $test->run();
 
         $this->assertTrue($test->setUp);
@@ -142,7 +142,7 @@ 
 
     public function testExceptionInTest()
     {
-        $test   = new \ExceptionInTest('testSomething');
+        $test = new \ExceptionInTest('testSomething');
         $test->run();
 
         $this->assertTrue($test->setUp);
@@ -154,7 +154,7 @@ 
 
     public function testExceptionInAssertPostConditions()
     {
-        $test   = new \ExceptionInAssertPostConditionsTest('testSomething');
+        $test = new \ExceptionInAssertPostConditionsTest('testSomething');
         $test->run();
 
         $this->assertTrue($test->setUp);
@@ -166,7 +166,7 @@ 
 
     public function testExceptionInTearDown()
     {
-        $test   = new \ExceptionInTearDownTest('testSomething');
+        $test = new \ExceptionInTearDownTest('testSomething');
         $test->run();
 
         $this->assertTrue($test->setUp);
@@ -524,7 +524,7 @@ 
 
     public function testSkipsIfRequiresNonExistingExtension()
     {
-        $test   = new \RequirementsTest('testTen');
+        $test = new \RequirementsTest('testTen');
         $test->run();
 
         $this->assertEquals(
@@ -535,7 +535,7 @@ 
 
     public function testSkipsIfRequiresExtensionWithAMinimumVersion()
     {
-        $test   = new \RequirementsTest('testSpecificExtensionVersion');
+        $test = new \RequirementsTest('testSpecificExtensionVersion');
         $test->run();
 
         $this->assertEquals(
@@ -546,17 +546,17 @@ 
 
     public function testSkipsProvidesMessagesForAllSkippingReasons()
     {
-        $test   = new \RequirementsTest('testAllPossibleRequirements');
+        $test = new \RequirementsTest('testAllPossibleRequirements');
         $test->run();
 
         $this->assertEquals(
-            'PHP >= 99-dev is required.' . PHP_EOL .
-            'PHPUnit >= 9-dev is required.' . PHP_EOL .
-            'Operating system matching /DOESNOTEXIST/i is required.' . PHP_EOL .
-            'Function testFuncOne is required.' . PHP_EOL .
-            'Function testFuncTwo is required.' . PHP_EOL .
-            'Extension testExtOne is required.' . PHP_EOL .
-            'Extension testExtTwo is required.' . PHP_EOL .
+            'PHP >= 99-dev is required.'.PHP_EOL.
+            'PHPUnit >= 9-dev is required.'.PHP_EOL.
+            'Operating system matching /DOESNOTEXIST/i is required.'.PHP_EOL.
+            'Function testFuncOne is required.'.PHP_EOL.
+            'Function testFuncTwo is required.'.PHP_EOL.
+            'Extension testExtOne is required.'.PHP_EOL.
+            'Extension testExtTwo is required.'.PHP_EOL.
             'Extension testExtThree >= 2.0 is required.',
             $test->getStatusMessage()
         );

vendor/phpunit/phpunit/tests/Framework/Constraint/IsJsonTest.php

Indentation +15 added lines, -15 removed lines

@@ -14,21 +14,21 @@
 
 class IsJsonTest extends TestCase
 {
-    /**
-     * @dataProvider evaluateDataprovider
-     */
-    public function testEvaluate($expected, $jsonOther)
-    {
-        $constraint = new IsJson;
+	/**
+	 * @dataProvider evaluateDataprovider
+	 */
+	public function testEvaluate($expected, $jsonOther)
+	{
+		$constraint = new IsJson;
 
-        $this->assertEquals($expected, $constraint->evaluate($jsonOther, '', true));
-    }
+		$this->assertEquals($expected, $constraint->evaluate($jsonOther, '', true));
+	}
 
-    public static function evaluateDataprovider()
-    {
-        return [
-            'valid JSON'                                     => [true, '{}'],
-            'empty string should be treated as invalid JSON' => [false, ''],
-        ];
-    }
+	public static function evaluateDataprovider()
+	{
+		return [
+			'valid JSON'                                     => [true, '{}'],
+			'empty string should be treated as invalid JSON' => [false, ''],
+		];
+	}
 }

vendor/phpunit/phpunit/tests/Framework/Constraint/ArraySubsetTest.php

Indentation +60 added lines, -60 removed lines

@@ -15,71 +15,71 @@
 
 class ArraySubsetTest extends TestCase
 {
-    /**
-     * @param bool               $expected
-     * @param array|\Traversable $subset
-     * @param array|\Traversable $other
-     * @param bool               $strict
-     * @dataProvider evaluateDataProvider
-     */
-    public function testEvaluate($expected, $subset, $other, $strict)
-    {
-        $constraint = new ArraySubset($subset, $strict);
+	/**
+	 * @param bool               $expected
+	 * @param array|\Traversable $subset
+	 * @param array|\Traversable $other
+	 * @param bool               $strict
+	 * @dataProvider evaluateDataProvider
+	 */
+	public function testEvaluate($expected, $subset, $other, $strict)
+	{
+		$constraint = new ArraySubset($subset, $strict);
 
-        $this->assertSame($expected, $constraint->evaluate($other, '', true));
-    }
+		$this->assertSame($expected, $constraint->evaluate($other, '', true));
+	}
 
-    public static function evaluateDataProvider()
-    {
-        return [
-            'loose array subset and array other' => [
-                'expected' => true,
-                'subset'   => ['bar' => 0],
-                'other'    => ['foo' => '', 'bar' => '0'],
-                'strict'   => false
-            ],
-            'strict array subset and array other' => [
-                'expected' => false,
-                'subset'   => ['bar' => 0],
-                'other'    => ['foo' => '', 'bar' => '0'],
-                'strict'   => true
-            ],
-            'loose array subset and ArrayObject other' => [
-                'expected' => true,
-                'subset'   => ['bar' => 0],
-                'other'    => new \ArrayObject(['foo' => '', 'bar' => '0']),
-                'strict'   => false
-            ],
-            'strict ArrayObject subset and array other' => [
-                'expected' => true,
-                'subset'   => new \ArrayObject(['bar' => 0]),
-                'other'    => ['foo' => '', 'bar' => 0],
-                'strict'   => true
-            ],
-        ];
-    }
+	public static function evaluateDataProvider()
+	{
+		return [
+			'loose array subset and array other' => [
+				'expected' => true,
+				'subset'   => ['bar' => 0],
+				'other'    => ['foo' => '', 'bar' => '0'],
+				'strict'   => false
+			],
+			'strict array subset and array other' => [
+				'expected' => false,
+				'subset'   => ['bar' => 0],
+				'other'    => ['foo' => '', 'bar' => '0'],
+				'strict'   => true
+			],
+			'loose array subset and ArrayObject other' => [
+				'expected' => true,
+				'subset'   => ['bar' => 0],
+				'other'    => new \ArrayObject(['foo' => '', 'bar' => '0']),
+				'strict'   => false
+			],
+			'strict ArrayObject subset and array other' => [
+				'expected' => true,
+				'subset'   => new \ArrayObject(['bar' => 0]),
+				'other'    => ['foo' => '', 'bar' => 0],
+				'strict'   => true
+			],
+		];
+	}
 
-    public function testEvaluateWithArrayAccess()
-    {
-        $arrayAccess = new \ArrayAccessible(['foo' => 'bar']);
+	public function testEvaluateWithArrayAccess()
+	{
+		$arrayAccess = new \ArrayAccessible(['foo' => 'bar']);
 
-        $constraint = new ArraySubset(['foo' => 'bar']);
+		$constraint = new ArraySubset(['foo' => 'bar']);
 
-        $this->assertTrue($constraint->evaluate($arrayAccess, '', true));
-    }
+		$this->assertTrue($constraint->evaluate($arrayAccess, '', true));
+	}
 
-    public function testEvaluateFailMessage()
-    {
-        $constraint = new ArraySubset(['foo' => 'bar']);
+	public function testEvaluateFailMessage()
+	{
+		$constraint = new ArraySubset(['foo' => 'bar']);
 
-        try {
-            $constraint->evaluate(['baz' => 'bar'], '', false);
-            $this->fail(\sprintf('Expected %s to be thrown.', ExpectationFailedException::class));
-        } catch (ExpectationFailedException $expectedException) {
-            $comparisonFailure = $expectedException->getComparisonFailure();
-            $this->assertNotNull($comparisonFailure);
-            $this->assertContains('[foo] => bar', $comparisonFailure->getExpectedAsString());
-            $this->assertContains('[baz] => bar', $comparisonFailure->getActualAsString());
-        }
-    }
+		try {
+			$constraint->evaluate(['baz' => 'bar'], '', false);
+			$this->fail(\sprintf('Expected %s to be thrown.', ExpectationFailedException::class));
+		} catch (ExpectationFailedException $expectedException) {
+			$comparisonFailure = $expectedException->getComparisonFailure();
+			$this->assertNotNull($comparisonFailure);
+			$this->assertContains('[foo] => bar', $comparisonFailure->getExpectedAsString());
+			$this->assertContains('[baz] => bar', $comparisonFailure->getActualAsString());
+		}
+	}
 }

vendor/phpunit/phpunit/tests/Framework/Constraint/CountTest.php

Indentation +129 added lines, -129 removed lines

@@ -14,135 +14,135 @@
 
 class CountTest extends TestCase
 {
-    public function testCount()
-    {
-        $countConstraint = new Count(3);
-        $this->assertTrue($countConstraint->evaluate([1, 2, 3], '', true));
+	public function testCount()
+	{
+		$countConstraint = new Count(3);
+		$this->assertTrue($countConstraint->evaluate([1, 2, 3], '', true));
 
-        $countConstraint = new Count(0);
-        $this->assertTrue($countConstraint->evaluate([], '', true));
+		$countConstraint = new Count(0);
+		$this->assertTrue($countConstraint->evaluate([], '', true));
 
-        $countConstraint = new Count(2);
-        $it              = new \TestIterator([1, 2]);
-        $ia              = new \TestIteratorAggregate($it);
-        $ia2             = new \TestIteratorAggregate2($ia);
-
-        $this->assertTrue($countConstraint->evaluate($it, '', true));
-        $this->assertTrue($countConstraint->evaluate($ia, '', true));
-        $this->assertTrue($countConstraint->evaluate($ia2, '', true));
-    }
-
-    public function testCountDoesNotChangeIteratorKey()
-    {
-        $countConstraint = new Count(2);
-
-        // test with 1st implementation of Iterator
-        $it = new \TestIterator([1, 2]);
-
-        $countConstraint->evaluate($it, '', true);
-        $this->assertEquals(1, $it->current());
-
-        $it->next();
-        $countConstraint->evaluate($it, '', true);
-        $this->assertEquals(2, $it->current());
-
-        $it->next();
-        $countConstraint->evaluate($it, '', true);
-        $this->assertFalse($it->valid());
-
-        // test with 2nd implementation of Iterator
-        $it = new \TestIterator2([1, 2]);
-
-        $countConstraint = new Count(2);
-        $countConstraint->evaluate($it, '', true);
-        $this->assertEquals(1, $it->current());
-
-        $it->next();
-        $countConstraint->evaluate($it, '', true);
-        $this->assertEquals(2, $it->current());
-
-        $it->next();
-        $countConstraint->evaluate($it, '', true);
-        $this->assertFalse($it->valid());
-
-        // test with IteratorAggregate
-        $it = new \TestIterator([1, 2]);
-        $ia = new \TestIteratorAggregate($it);
-
-        $countConstraint = new Count(2);
-        $countConstraint->evaluate($ia, '', true);
-        $this->assertEquals(1, $it->current());
-
-        $it->next();
-        $countConstraint->evaluate($ia, '', true);
-        $this->assertEquals(2, $it->current());
-
-        $it->next();
-        $countConstraint->evaluate($ia, '', true);
-        $this->assertFalse($it->valid());
-
-        // test with nested IteratorAggregate
-        $it  = new \TestIterator([1, 2]);
-        $ia  = new \TestIteratorAggregate($it);
-        $ia2 = new \TestIteratorAggregate2($ia);
-
-        $countConstraint = new Count(2);
-        $countConstraint->evaluate($ia2, '', true);
-        $this->assertEquals(1, $it->current());
-
-        $it->next();
-        $countConstraint->evaluate($ia2, '', true);
-        $this->assertEquals(2, $it->current());
-
-        $it->next();
-        $countConstraint->evaluate($ia2, '', true);
-        $this->assertFalse($it->valid());
-    }
-
-    public function testCountGeneratorsDoNotRewind()
-    {
-        $generatorMaker = new \TestGeneratorMaker;
-
-        $countConstraint = new Count(3);
-
-        $generator = $generatorMaker->create([1, 2, 3]);
-        $this->assertEquals(1, $generator->current());
-        $countConstraint->evaluate($generator, '', true);
-        $this->assertEquals(null, $generator->current());
-
-        $countConstraint = new Count(2);
-
-        $generator = $generatorMaker->create([1, 2, 3]);
-        $this->assertEquals(1, $generator->current());
-        $generator->next();
-        $this->assertEquals(2, $generator->current());
-        $countConstraint->evaluate($generator, '', true);
-        $this->assertEquals(null, $generator->current());
-
-        $countConstraint = new Count(1);
-
-        $generator = $generatorMaker->create([1, 2, 3]);
-        $this->assertEquals(1, $generator->current());
-        $generator->next();
-        $this->assertEquals(2, $generator->current());
-        $generator->next();
-        $this->assertEquals(3, $generator->current());
-        $countConstraint->evaluate($generator, '', true);
-        $this->assertEquals(null, $generator->current());
-    }
-
-    public function testCountTraversable()
-    {
-        $countConstraint = new Count(5);
-
-        // DatePeriod is used as an object that is Traversable but does not
-        // implement Iterator or IteratorAggregate. The following ISO 8601
-        // recurring time interval will yield five total DateTime objects.
-        $datePeriod = new \DatePeriod('R4/2017-05-01T00:00:00Z/P1D');
-
-        $this->assertInstanceOf(\Traversable::class, $datePeriod);
-        $this->assertNotInstanceOf(\Iterator::class, $datePeriod);
-        $this->assertNotInstanceOf(\IteratorAggregate::class, $datePeriod);
-        $this->assertTrue($countConstraint->evaluate($datePeriod, '', true));
-    }
+		$countConstraint = new Count(2);
+		$it              = new \TestIterator([1, 2]);
+		$ia              = new \TestIteratorAggregate($it);
+		$ia2             = new \TestIteratorAggregate2($ia);
+
+		$this->assertTrue($countConstraint->evaluate($it, '', true));
+		$this->assertTrue($countConstraint->evaluate($ia, '', true));
+		$this->assertTrue($countConstraint->evaluate($ia2, '', true));
+	}
+
+	public function testCountDoesNotChangeIteratorKey()
+	{
+		$countConstraint = new Count(2);
+
+		// test with 1st implementation of Iterator
+		$it = new \TestIterator([1, 2]);
+
+		$countConstraint->evaluate($it, '', true);
+		$this->assertEquals(1, $it->current());
+
+		$it->next();
+		$countConstraint->evaluate($it, '', true);
+		$this->assertEquals(2, $it->current());
+
+		$it->next();
+		$countConstraint->evaluate($it, '', true);
+		$this->assertFalse($it->valid());
+
+		// test with 2nd implementation of Iterator
+		$it = new \TestIterator2([1, 2]);
+
+		$countConstraint = new Count(2);
+		$countConstraint->evaluate($it, '', true);
+		$this->assertEquals(1, $it->current());
+
+		$it->next();
+		$countConstraint->evaluate($it, '', true);
+		$this->assertEquals(2, $it->current());
+
+		$it->next();
+		$countConstraint->evaluate($it, '', true);
+		$this->assertFalse($it->valid());
+
+		// test with IteratorAggregate
+		$it = new \TestIterator([1, 2]);
+		$ia = new \TestIteratorAggregate($it);
+
+		$countConstraint = new Count(2);
+		$countConstraint->evaluate($ia, '', true);
+		$this->assertEquals(1, $it->current());
+
+		$it->next();
+		$countConstraint->evaluate($ia, '', true);
+		$this->assertEquals(2, $it->current());
+
+		$it->next();
+		$countConstraint->evaluate($ia, '', true);
+		$this->assertFalse($it->valid());
+
+		// test with nested IteratorAggregate
+		$it  = new \TestIterator([1, 2]);
+		$ia  = new \TestIteratorAggregate($it);
+		$ia2 = new \TestIteratorAggregate2($ia);
+
+		$countConstraint = new Count(2);
+		$countConstraint->evaluate($ia2, '', true);
+		$this->assertEquals(1, $it->current());
+
+		$it->next();
+		$countConstraint->evaluate($ia2, '', true);
+		$this->assertEquals(2, $it->current());
+
+		$it->next();
+		$countConstraint->evaluate($ia2, '', true);
+		$this->assertFalse($it->valid());
+	}
+
+	public function testCountGeneratorsDoNotRewind()
+	{
+		$generatorMaker = new \TestGeneratorMaker;
+
+		$countConstraint = new Count(3);
+
+		$generator = $generatorMaker->create([1, 2, 3]);
+		$this->assertEquals(1, $generator->current());
+		$countConstraint->evaluate($generator, '', true);
+		$this->assertEquals(null, $generator->current());
+
+		$countConstraint = new Count(2);
+
+		$generator = $generatorMaker->create([1, 2, 3]);
+		$this->assertEquals(1, $generator->current());
+		$generator->next();
+		$this->assertEquals(2, $generator->current());
+		$countConstraint->evaluate($generator, '', true);
+		$this->assertEquals(null, $generator->current());
+
+		$countConstraint = new Count(1);
+
+		$generator = $generatorMaker->create([1, 2, 3]);
+		$this->assertEquals(1, $generator->current());
+		$generator->next();
+		$this->assertEquals(2, $generator->current());
+		$generator->next();
+		$this->assertEquals(3, $generator->current());
+		$countConstraint->evaluate($generator, '', true);
+		$this->assertEquals(null, $generator->current());
+	}
+
+	public function testCountTraversable()
+	{
+		$countConstraint = new Count(5);
+
+		// DatePeriod is used as an object that is Traversable but does not
+		// implement Iterator or IteratorAggregate. The following ISO 8601
+		// recurring time interval will yield five total DateTime objects.
+		$datePeriod = new \DatePeriod('R4/2017-05-01T00:00:00Z/P1D');
+
+		$this->assertInstanceOf(\Traversable::class, $datePeriod);
+		$this->assertNotInstanceOf(\Iterator::class, $datePeriod);
+		$this->assertNotInstanceOf(\IteratorAggregate::class, $datePeriod);
+		$this->assertTrue($countConstraint->evaluate($datePeriod, '', true));
+	}
 }

vendor/phpunit/phpunit/tests/Framework/Constraint/JsonMatchesTest.php

Indentation +61 added lines, -61 removed lines

@@ -15,72 +15,72 @@
 
 class JsonMatchesTest extends TestCase
 {
-    /**
-     * @dataProvider evaluateDataprovider
-     */
-    public function testEvaluate($expected, $jsonOther, $jsonValue)
-    {
-        $constraint = new JsonMatches($jsonValue);
+	/**
+	 * @dataProvider evaluateDataprovider
+	 */
+	public function testEvaluate($expected, $jsonOther, $jsonValue)
+	{
+		$constraint = new JsonMatches($jsonValue);
 
-        $this->assertEquals($expected, $constraint->evaluate($jsonOther, '', true));
-    }
+		$this->assertEquals($expected, $constraint->evaluate($jsonOther, '', true));
+	}
 
-    /**
-     * @dataProvider evaluateThrowsExpectationFailedExceptionWhenJsonIsValidButDoesNotMatchDataprovider
-     */
-    public function testEvaluateThrowsExpectationFailedExceptionWhenJsonIsValidButDoesNotMatch($jsonOther, $jsonValue)
-    {
-        $constraint = new JsonMatches($jsonValue);
+	/**
+	 * @dataProvider evaluateThrowsExpectationFailedExceptionWhenJsonIsValidButDoesNotMatchDataprovider
+	 */
+	public function testEvaluateThrowsExpectationFailedExceptionWhenJsonIsValidButDoesNotMatch($jsonOther, $jsonValue)
+	{
+		$constraint = new JsonMatches($jsonValue);
 
-        try {
-            $constraint->evaluate($jsonOther, '', false);
-            $this->fail(\sprintf('Expected %s to be thrown.', ExpectationFailedException::class));
-        } catch (ExpectationFailedException $expectedException) {
-            $comparisonFailure = $expectedException->getComparisonFailure();
-            $this->assertNotNull($comparisonFailure);
-            $this->assertSame($jsonOther, $comparisonFailure->getExpectedAsString());
-            $this->assertSame($jsonValue, $comparisonFailure->getActualAsString());
-            $this->assertSame('Failed asserting that two json values are equal.', $comparisonFailure->getMessage());
-        }
-    }
+		try {
+			$constraint->evaluate($jsonOther, '', false);
+			$this->fail(\sprintf('Expected %s to be thrown.', ExpectationFailedException::class));
+		} catch (ExpectationFailedException $expectedException) {
+			$comparisonFailure = $expectedException->getComparisonFailure();
+			$this->assertNotNull($comparisonFailure);
+			$this->assertSame($jsonOther, $comparisonFailure->getExpectedAsString());
+			$this->assertSame($jsonValue, $comparisonFailure->getActualAsString());
+			$this->assertSame('Failed asserting that two json values are equal.', $comparisonFailure->getMessage());
+		}
+	}
 
-    public function testToString()
-    {
-        $jsonValue  = \json_encode(['Mascott' => 'Tux']);
-        $constraint = new JsonMatches($jsonValue);
+	public function testToString()
+	{
+		$jsonValue  = \json_encode(['Mascott' => 'Tux']);
+		$constraint = new JsonMatches($jsonValue);
 
-        $this->assertEquals('matches JSON string "' . $jsonValue . '"', $constraint->toString());
-    }
+		$this->assertEquals('matches JSON string "' . $jsonValue . '"', $constraint->toString());
+	}
 
-    public static function evaluateDataprovider()
-    {
-        return [
-            'valid JSON'                              => [true, \json_encode(['Mascott'                           => 'Tux']), \json_encode(['Mascott'                           => 'Tux'])],
-            'error syntax'                            => [false, '{"Mascott"::}', \json_encode(['Mascott'         => 'Tux'])],
-            'error UTF-8'                             => [false, \json_encode('\xB1\x31'), \json_encode(['Mascott' => 'Tux'])],
-            'invalid JSON in class instantiation'     => [false, \json_encode(['Mascott'                          => 'Tux']), '{"Mascott"::}'],
-            'string type not equals number'           => [false, '{"age": "5"}', '{"age": 5}'],
-            'string type not equals boolean'          => [false, '{"age": "true"}', '{"age": true}'],
-            'string type not equals null'             => [false, '{"age": "null"}', '{"age": null}'],
-            'object fields are unordered'             => [true, '{"first":1, "second":"2"}', '{"second":"2", "first":1}'],
-            'child object fields are unordered'       => [true, '{"Mascott": {"name":"Tux", "age":5}}', '{"Mascott": {"age":5, "name":"Tux"}}'],
-            'null field different from missing field' => [false, '{"present": true, "missing": null}', '{"present": true}'],
-            'array elements are ordered'              => [false, '["first", "second"]', '["second", "first"]'],
-            'single boolean valid json'               => [true, 'true', 'true'],
-            'single number valid json'                => [true, '5.3', '5.3'],
-            'single null valid json'                  => [true, 'null', 'null'],
-        ];
-    }
+	public static function evaluateDataprovider()
+	{
+		return [
+			'valid JSON'                              => [true, \json_encode(['Mascott'                           => 'Tux']), \json_encode(['Mascott'                           => 'Tux'])],
+			'error syntax'                            => [false, '{"Mascott"::}', \json_encode(['Mascott'         => 'Tux'])],
+			'error UTF-8'                             => [false, \json_encode('\xB1\x31'), \json_encode(['Mascott' => 'Tux'])],
+			'invalid JSON in class instantiation'     => [false, \json_encode(['Mascott'                          => 'Tux']), '{"Mascott"::}'],
+			'string type not equals number'           => [false, '{"age": "5"}', '{"age": 5}'],
+			'string type not equals boolean'          => [false, '{"age": "true"}', '{"age": true}'],
+			'string type not equals null'             => [false, '{"age": "null"}', '{"age": null}'],
+			'object fields are unordered'             => [true, '{"first":1, "second":"2"}', '{"second":"2", "first":1}'],
+			'child object fields are unordered'       => [true, '{"Mascott": {"name":"Tux", "age":5}}', '{"Mascott": {"age":5, "name":"Tux"}}'],
+			'null field different from missing field' => [false, '{"present": true, "missing": null}', '{"present": true}'],
+			'array elements are ordered'              => [false, '["first", "second"]', '["second", "first"]'],
+			'single boolean valid json'               => [true, 'true', 'true'],
+			'single number valid json'                => [true, '5.3', '5.3'],
+			'single null valid json'                  => [true, 'null', 'null'],
+		];
+	}
 
-    public static function evaluateThrowsExpectationFailedExceptionWhenJsonIsValidButDoesNotMatchDataprovider()
-    {
-        return [
-            'error UTF-8'                             => [\json_encode('\xB1\x31'), \json_encode(['Mascott' => 'Tux'])],
-            'string type not equals number'           => ['{"age": "5"}', '{"age": 5}'],
-            'string type not equals boolean'          => ['{"age": "true"}', '{"age": true}'],
-            'string type not equals null'             => ['{"age": "null"}', '{"age": null}'],
-            'null field different from missing field' => ['{"present": true, "missing": null}', '{"present": true}'],
-            'array elements are ordered'              => ['["first", "second"]', '["second", "first"]']
-        ];
-    }
+	public static function evaluateThrowsExpectationFailedExceptionWhenJsonIsValidButDoesNotMatchDataprovider()
+	{
+		return [
+			'error UTF-8'                             => [\json_encode('\xB1\x31'), \json_encode(['Mascott' => 'Tux'])],
+			'string type not equals number'           => ['{"age": "5"}', '{"age": 5}'],
+			'string type not equals boolean'          => ['{"age": "true"}', '{"age": true}'],
+			'string type not equals null'             => ['{"age": "null"}', '{"age": null}'],
+			'null field different from missing field' => ['{"present": true, "missing": null}', '{"present": true}'],
+			'array elements are ordered'              => ['["first", "second"]', '["second", "first"]']
+		];
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -49,7 +49,7 @@
         $jsonValue  = \json_encode(['Mascott' => 'Tux']);
         $constraint = new JsonMatches($jsonValue);
 
-        $this->assertEquals('matches JSON string "' . $jsonValue . '"', $constraint->toString());
+        $this->assertEquals('matches JSON string "'.$jsonValue.'"', $constraint->toString());
     }
 
     public static function evaluateDataprovider()