commitall

vendor/sebastian/comparator/.gitignore

@@ -0,0 +1,6 @@
+/build/coverage
+/composer.lock
+/composer.phar
+/phpunit.xml
+/.idea
+/vendor

vendor/sebastian/comparator/.travis.yml

@@ -0,0 +1,25 @@
+language: php
+
+sudo: false
+
+install:
+  - travis_retry composer install --no-interaction --prefer-source
+
+script: ./vendor/bin/phpunit --configuration ./build/travis-ci.xml
+
+php:
+  - 5.3.3
+  - 5.3
+  - 5.4
+  - 5.5
+  - 5.6
+  - hhvm
+
+notifications:
+  email: false
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/6668f52f3dd4e3f81960
+    on_success: always
+    on_failure: always
+    on_start: false

vendor/sebastian/comparator/LICENSE

@@ -0,0 +1,33 @@
+Comparator
+
+Copyright (c) 2002-2015, Sebastian Bergmann <sebastian@phpunit.de>.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in
+   the documentation and/or other materials provided with the
+   distribution.
+
+ * Neither the name of Sebastian Bergmann nor the names of his
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

vendor/sebastian/comparator/README.md

@@ -0,0 +1,39 @@
+[![Build Status](https://travis-ci.org/sebastianbergmann/comparator.svg?branch=master)](https://travis-ci.org/sebastianbergmann/comparator)
+
+# Comparator
+
+This component provides the functionality to compare PHP values for equality.
+
+## Installation
+
+You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/):
+
+    composer require sebastian/comparator
+
+If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency:
+
+    composer require --dev sebastian/comparator
+
+## Usage
+
+```php
+<?php
+use SebastianBergmann\Comparator\Factory;
+use SebastianBergmann\Comparator\ComparisonFailure;
+
+$date1 = new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York'));
+$date2 = new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/Chicago'));
+
+$factory = new Factory;
+$comparator = $factory->getComparatorFor($date1, $date2);
+
+try {
+    $comparator->assertEquals($date1, $date2);
+    print "Dates match";
+}
+
+catch (ComparisonFailure $failure) {
+    print "Dates don't match";
+}
+```
+

vendor/sebastian/comparator/build.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="comparator">
+ <target name="clean" description="Cleanup build artifacts">
+  <delete dir="${basedir}/vendor"/>
+  <delete file="${basedir}/composer.lock"/>
+ </target>
+
+ <target name="composer" depends="clean" description="Install dependencies with Composer">
+  <tstamp>
+   <format property="thirty.days.ago" pattern="MM/dd/yyyy hh:mm aa" offset="-30" unit="day"/>
+  </tstamp>
+  <delete>
+   <fileset dir="${basedir}">
+    <include name="composer.phar" />
+    <date datetime="${thirty.days.ago}" when="before"/>
+   </fileset>
+  </delete>
+
+  <get src="https://getcomposer.org/composer.phar" dest="${basedir}/composer.phar" skipexisting="true"/>
+
+  <exec executable="php">
+   <arg value="composer.phar"/>
+   <arg value="install"/>
+  </exec>
+ </target>
+
+ <target name="phpab" description="Generate autoloader script">
+  <exec executable="phpab">
+   <arg value="--output" />
+   <arg path="tests/autoload.php" />
+   <arg path="tests" />
+  </exec>
+ </target>
+</project>

vendor/sebastian/comparator/build/travis-ci.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.2/phpunit.xsd"
+         bootstrap="../tests/bootstrap.php"
+         backupGlobals="false"
+         verbose="true">
+  <testsuite name="Comparator">
+    <directory suffix="Test.php">../tests</directory>
+  </testsuite>
+</phpunit>
+

vendor/sebastian/comparator/composer.json

@@ -0,0 +1,44 @@
+{
+    "name": "sebastian/comparator",
+    "description": "Provides the functionality to compare PHP values for equality",
+    "keywords": ["comparator","compare","equality"],
+    "homepage": "http://www.github.com/sebastianbergmann/comparator",
+    "license": "BSD-3-Clause",
+    "authors": [
+        {
+            "name": "Sebastian Bergmann",
+            "email": "sebastian@phpunit.de"
+        },
+        {
+            "name": "Jeff Welch",
+            "email": "whatthejeff@gmail.com"
+        },
+        {
+            "name": "Volker Dusch",
+            "email": "github@wallbash.com"
+        },
+        {
+            "name": "Bernhard Schussek",
+            "email": "bschussek@2bepublished.at"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.3",
+        "sebastian/diff": "~1.2",
+        "sebastian/exporter": "~1.2 || ~2.0"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "~4.4"
+    },
+    "autoload": {
+        "classmap": [
+            "src/"
+        ]
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "1.2.x-dev"
+        }
+    }
+}
+

vendor/sebastian/comparator/phpunit.xml.dist

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.1/phpunit.xsd"
+         bootstrap="tests/bootstrap.php"
+         backupGlobals="false"
+         verbose="true">
+  <testsuite name="Comparator">
+    <directory suffix="Test.php">tests</directory>
+  </testsuite>
+
+  <logging>
+    <log type="coverage-html" target="build/coverage"/>
+  </logging>
+
+  <filter>
+    <whitelist processUncoveredFilesFromWhitelist="true">
+      <directory suffix=".php">src</directory>
+    </whitelist>
+  </filter>
+</phpunit>
+

vendor/sebastian/comparator/src/ArrayComparator.php

@@ -0,0 +1,132 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Compares arrays for equality.
+ */
+class ArrayComparator extends Comparator
+{
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    public function accepts($expected, $actual)
+    {
+        return is_array($expected) && is_array($actual);
+    }
+
+    /**
+     * Asserts that two values are equal.
+     *
+     * @param mixed $expected     First value to compare
+     * @param mixed $actual       Second value to compare
+     * @param float $delta        Allowed numerical distance between two values to consider them equal
+     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+     * @param bool  $ignoreCase   Case is ignored when set to true
+     * @param array $processed    List of already processed elements (used to prevent infinite recursion)
+     *
+     * @throws ComparisonFailure
+     */
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = array())
+    {
+        if ($canonicalize) {
+            sort($expected);
+            sort($actual);
+        }
+
+        $remaining = $actual;
+        $expString = $actString = "Array (\n";
+        $equal     = true;
+
+        foreach ($expected as $key => $value) {
+            unset($remaining[$key]);
+
+            if (!array_key_exists($key, $actual)) {
+                $expString .= sprintf(
+                    "    %s => %s\n",
+                    $this->exporter->export($key),
+                    $this->exporter->shortenedExport($value)
+                );
+
+                $equal = false;
+
+                continue;
+            }
+
+            try {
+                $comparator = $this->factory->getComparatorFor($value, $actual[$key]);
+                $comparator->assertEquals($value, $actual[$key], $delta, $canonicalize, $ignoreCase, $processed);
+
+                $expString .= sprintf(
+                    "    %s => %s\n",
+                    $this->exporter->export($key),
+                    $this->exporter->shortenedExport($value)
+                );
+                $actString .= sprintf(
+                    "    %s => %s\n",
+                    $this->exporter->export($key),
+                    $this->exporter->shortenedExport($actual[$key])
+                );
+            } catch (ComparisonFailure $e) {
+                $expString .= sprintf(
+                    "    %s => %s\n",
+                    $this->exporter->export($key),
+                    $e->getExpectedAsString()
+                    ? $this->indent($e->getExpectedAsString())
+                    : $this->exporter->shortenedExport($e->getExpected())
+                );
+
+                $actString .= sprintf(
+                    "    %s => %s\n",
+                    $this->exporter->export($key),
+                    $e->getActualAsString()
+                    ? $this->indent($e->getActualAsString())
+                    : $this->exporter->shortenedExport($e->getActual())
+                );
+
+                $equal = false;
+            }
+        }
+
+        foreach ($remaining as $key => $value) {
+            $actString .= sprintf(
+                "    %s => %s\n",
+                $this->exporter->export($key),
+                $this->exporter->shortenedExport($value)
+            );
+
+            $equal = false;
+        }
+
+        $expString .= ')';
+        $actString .= ')';
+
+        if (!$equal) {
+            throw new ComparisonFailure(
+                $expected,
+                $actual,
+                $expString,
+                $actString,
+                false,
+                'Failed asserting that two arrays are equal.'
+            );
+        }
+    }
+
+    protected function indent($lines)
+    {
+        return trim(str_replace("\n", "\n    ", $lines));
+    }
+}

vendor/sebastian/comparator/src/Comparator.php

@@ -0,0 +1,64 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+use SebastianBergmann\Exporter\Exporter;
+
+/**
+ * Abstract base class for comparators which compare values for equality.
+ */
+abstract class Comparator
+{
+    /**
+     * @var Factory
+     */
+    protected $factory;
+
+    /**
+     * @var Exporter
+     */
+    protected $exporter;
+
+    public function __construct()
+    {
+        $this->exporter = new Exporter;
+    }
+
+    /**
+     * @param Factory $factory
+     */
+    public function setFactory(Factory $factory)
+    {
+        $this->factory = $factory;
+    }
+
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    abstract public function accepts($expected, $actual);
+
+    /**
+     * Asserts that two values are equal.
+     *
+     * @param mixed $expected     First value to compare
+     * @param mixed $actual       Second value to compare
+     * @param float $delta        Allowed numerical distance between two values to consider them equal
+     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+     * @param bool  $ignoreCase   Case is ignored when set to true
+     *
+     * @throws ComparisonFailure
+     */
+    abstract public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false);
+}

vendor/sebastian/comparator/src/ComparisonFailure.php

@@ -0,0 +1,129 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+use SebastianBergmann\Diff\Differ;
+
+/**
+ * Thrown when an assertion for string equality failed.
+ */
+class ComparisonFailure extends \RuntimeException
+{
+    /**
+     * Expected value of the retrieval which does not match $actual.
+     * @var mixed
+     */
+    protected $expected;
+
+    /**
+     * Actually retrieved value which does not match $expected.
+     * @var mixed
+     */
+    protected $actual;
+
+    /**
+     * The string representation of the expected value
+     * @var string
+     */
+    protected $expectedAsString;
+
+    /**
+     * The string representation of the actual value
+     * @var string
+     */
+    protected $actualAsString;
+
+    /**
+     * @var bool
+     */
+    protected $identical;
+
+    /**
+     * Optional message which is placed in front of the first line
+     * returned by toString().
+     * @var string
+     */
+    protected $message;
+
+    /**
+     * Initialises with the expected value and the actual value.
+     *
+     * @param mixed  $expected         Expected value retrieved.
+     * @param mixed  $actual           Actual value retrieved.
+     * @param string $expectedAsString
+     * @param string $actualAsString
+     * @param bool   $identical
+     * @param string $message          A string which is prefixed on all returned lines
+     *                                 in the difference output.
+     */
+    public function __construct($expected, $actual, $expectedAsString, $actualAsString, $identical = false, $message = '')
+    {
+        $this->expected         = $expected;
+        $this->actual           = $actual;
+        $this->expectedAsString = $expectedAsString;
+        $this->actualAsString   = $actualAsString;
+        $this->message          = $message;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getActual()
+    {
+        return $this->actual;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getExpected()
+    {
+        return $this->expected;
+    }
+
+    /**
+     * @return string
+     */
+    public function getActualAsString()
+    {
+        return $this->actualAsString;
+    }
+
+    /**
+     * @return string
+     */
+    public function getExpectedAsString()
+    {
+        return $this->expectedAsString;
+    }
+
+    /**
+     * @return string
+     */
+    public function getDiff()
+    {
+        if (!$this->actualAsString && !$this->expectedAsString) {
+            return '';
+        }
+
+        $differ = new Differ("\n--- Expected\n+++ Actual\n");
+
+        return $differ->diff($this->expectedAsString, $this->actualAsString);
+    }
+
+    /**
+     * @return string
+     */
+    public function toString()
+    {
+        return $this->message . $this->getDiff();
+    }
+}

vendor/sebastian/comparator/src/DOMNodeComparator.php

@@ -0,0 +1,107 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+use DOMDocument;
+use DOMNode;
+
+/**
+ * Compares DOMNode instances for equality.
+ */
+class DOMNodeComparator extends ObjectComparator
+{
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    public function accepts($expected, $actual)
+    {
+        return $expected instanceof DOMNode && $actual instanceof DOMNode;
+    }
+
+    /**
+     * Asserts that two values are equal.
+     *
+     * @param mixed $expected     First value to compare
+     * @param mixed $actual       Second value to compare
+     * @param float $delta        Allowed numerical distance between two values to consider them equal
+     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+     * @param bool  $ignoreCase   Case is ignored when set to true
+     * @param array $processed    List of already processed elements (used to prevent infinite recursion)
+     *
+     * @throws ComparisonFailure
+     */
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = array())
+    {
+        $expectedAsString = $this->nodeToText($expected, true, $ignoreCase);
+        $actualAsString   = $this->nodeToText($actual, true, $ignoreCase);
+
+        if ($expectedAsString !== $actualAsString) {
+            if ($expected instanceof DOMDocument) {
+                $type = 'documents';
+            } else {
+                $type = 'nodes';
+            }
+
+            throw new ComparisonFailure(
+                $expected,
+                $actual,
+                $expectedAsString,
+                $actualAsString,
+                false,
+                sprintf("Failed asserting that two DOM %s are equal.\n", $type)
+            );
+        }
+    }
+
+    /**
+     * Returns the normalized, whitespace-cleaned, and indented textual
+     * representation of a DOMNode.
+     *
+     * @param  DOMNode $node
+     * @param  bool    $canonicalize
+     * @param  bool    $ignoreCase
+     * @return string
+     */
+    private function nodeToText(DOMNode $node, $canonicalize, $ignoreCase)
+    {
+        if ($canonicalize) {
+            $document = new DOMDocument;
+            $document->loadXML($node->C14N());
+
+            $node = $document;
+        }
+
+        if ($node instanceof DOMDocument) {
+            $document = $node;
+        } else {
+            $document = $node->ownerDocument;
+        }
+
+        $document->formatOutput = true;
+        $document->normalizeDocument();
+
+        if ($node instanceof DOMDocument) {
+            $text = $node->saveXML();
+        } else {
+            $text = $document->saveXML($node);
+        }
+
+        if ($ignoreCase) {
+            $text = strtolower($text);
+        }
+
+        return $text;
+    }
+}

vendor/sebastian/comparator/src/DateTimeComparator.php

@@ -0,0 +1,77 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Compares DateTimeInterface instances for equality.
+ */
+class DateTimeComparator extends ObjectComparator
+{
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    public function accepts($expected, $actual)
+    {
+        return ($expected instanceof \DateTime || $expected instanceof \DateTimeInterface) &&
+            ($actual instanceof \DateTime || $actual instanceof \DateTimeInterface);
+    }
+
+    /**
+     * Asserts that two values are equal.
+     *
+     * @param mixed $expected     First value to compare
+     * @param mixed $actual       Second value to compare
+     * @param float $delta        Allowed numerical distance between two values to consider them equal
+     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+     * @param bool  $ignoreCase   Case is ignored when set to true
+     * @param array $processed    List of already processed elements (used to prevent infinite recursion)
+     *
+     * @throws ComparisonFailure
+     */
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = array())
+    {
+        $delta = new \DateInterval(sprintf('PT%sS', abs($delta)));
+
+        $expectedLower = clone $expected;
+        $expectedUpper = clone $expected;
+
+        if ($actual < $expectedLower->sub($delta) ||
+            $actual > $expectedUpper->add($delta)) {
+            throw new ComparisonFailure(
+                $expected,
+                $actual,
+                $this->dateTimeToString($expected),
+                $this->dateTimeToString($actual),
+                false,
+                'Failed asserting that two DateTime objects are equal.'
+            );
+        }
+    }
+
+    /**
+     * Returns an ISO 8601 formatted string representation of a datetime or
+     * 'Invalid DateTimeInterface object' if the provided DateTimeInterface was not properly
+     * initialized.
+     *
+     * @param  \DateTimeInterface $datetime
+     * @return string
+     */
+    private function dateTimeToString($datetime)
+    {
+        $string = $datetime->format('Y-m-d\TH:i:s.uO');
+
+        return $string ? $string : 'Invalid DateTimeInterface object';
+    }
+}

vendor/sebastian/comparator/src/DoubleComparator.php

@@ -0,0 +1,56 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Compares doubles for equality.
+ */
+class DoubleComparator extends NumericComparator
+{
+    /**
+     * Smallest value available in PHP.
+     *
+     * @var float
+     */
+    const EPSILON = 0.0000000001;
+
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    public function accepts($expected, $actual)
+    {
+        return (is_double($expected) || is_double($actual)) && is_numeric($expected) && is_numeric($actual);
+    }
+
+    /**
+     * Asserts that two values are equal.
+     *
+     * @param mixed $expected     First value to compare
+     * @param mixed $actual       Second value to compare
+     * @param float $delta        Allowed numerical distance between two values to consider them equal
+     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+     * @param bool  $ignoreCase   Case is ignored when set to true
+     *
+     * @throws ComparisonFailure
+     */
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    {
+        if ($delta == 0) {
+            $delta = self::EPSILON;
+        }
+
+        parent::assertEquals($expected, $actual, $delta, $canonicalize, $ignoreCase);
+    }
+}

vendor/sebastian/comparator/src/ExceptionComparator.php

@@ -0,0 +1,51 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Compares Exception instances for equality.
+ */
+class ExceptionComparator extends ObjectComparator
+{
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    public function accepts($expected, $actual)
+    {
+        return $expected instanceof \Exception && $actual instanceof \Exception;
+    }
+
+    /**
+     * Converts an object to an array containing all of its private, protected
+     * and public properties.
+     *
+     * @param  object $object
+     * @return array
+     */
+    protected function toArray($object)
+    {
+        $array = parent::toArray($object);
+
+        unset(
+            $array['file'],
+            $array['line'],
+            $array['trace'],
+            $array['string'],
+            $array['xdebug_message']
+        );
+
+        return $array;
+    }
+}

vendor/sebastian/comparator/src/Factory.php

@@ -0,0 +1,107 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Factory for comparators which compare values for equality.
+ */
+class Factory
+{
+    /**
+     * @var Comparator[]
+     */
+    private $comparators = array();
+
+    /**
+     * @var Factory
+     */
+    private static $instance;
+
+    /**
+     * Constructs a new factory.
+     */
+    public function __construct()
+    {
+        $this->register(new TypeComparator);
+        $this->register(new ScalarComparator);
+        $this->register(new NumericComparator);
+        $this->register(new DoubleComparator);
+        $this->register(new ArrayComparator);
+        $this->register(new ResourceComparator);
+        $this->register(new ObjectComparator);
+        $this->register(new ExceptionComparator);
+        $this->register(new SplObjectStorageComparator);
+        $this->register(new DOMNodeComparator);
+        $this->register(new MockObjectComparator);
+        $this->register(new DateTimeComparator);
+    }
+
+    /**
+     * @return Factory
+     */
+    public static function getInstance()
+    {
+        if (self::$instance === null) {
+            self::$instance = new self;
+        }
+
+        return self::$instance;
+    }
+
+    /**
+     * Returns the correct comparator for comparing two values.
+     *
+     * @param  mixed      $expected The first value to compare
+     * @param  mixed      $actual   The second value to compare
+     * @return Comparator
+     */
+    public function getComparatorFor($expected, $actual)
+    {
+        foreach ($this->comparators as $comparator) {
+            if ($comparator->accepts($expected, $actual)) {
+                return $comparator;
+            }
+        }
+    }
+
+    /**
+     * Registers a new comparator.
+     *
+     * This comparator will be returned by getInstance() if its accept() method
+     * returns TRUE for the compared values. It has higher priority than the
+     * existing comparators, meaning that its accept() method will be tested
+     * before those of the other comparators.
+     *
+     * @param Comparator $comparator The registered comparator
+     */
+    public function register(Comparator $comparator)
+    {
+        array_unshift($this->comparators, $comparator);
+
+        $comparator->setFactory($this);
+    }
+
+    /**
+     * Unregisters a comparator.
+     *
+     * This comparator will no longer be returned by getInstance().
+     *
+     * @param Comparator $comparator The unregistered comparator
+     */
+    public function unregister(Comparator $comparator)
+    {
+        foreach ($this->comparators as $key => $_comparator) {
+            if ($comparator === $_comparator) {
+                unset($this->comparators[$key]);
+            }
+        }
+    }
+}

vendor/sebastian/comparator/src/MockObjectComparator.php

@@ -0,0 +1,45 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Compares PHPUnit_Framework_MockObject_MockObject instances for equality.
+ */
+class MockObjectComparator extends ObjectComparator
+{
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    public function accepts($expected, $actual)
+    {
+        return $expected instanceof \PHPUnit_Framework_MockObject_MockObject && $actual instanceof \PHPUnit_Framework_MockObject_MockObject;
+    }
+
+    /**
+     * Converts an object to an array containing all of its private, protected
+     * and public properties.
+     *
+     * @param  object $object
+     * @return array
+     */
+    protected function toArray($object)
+    {
+        $array = parent::toArray($object);
+
+        unset($array['__phpunit_invocationMocker']);
+
+        return $array;
+    }
+}

vendor/sebastian/comparator/src/NumericComparator.php

@@ -0,0 +1,68 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Compares numerical values for equality.
+ */
+class NumericComparator extends ScalarComparator
+{
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    public function accepts($expected, $actual)
+    {
+        // all numerical values, but not if one of them is a double
+        // or both of them are strings
+        return is_numeric($expected) && is_numeric($actual) &&
+               !(is_double($expected) || is_double($actual)) &&
+               !(is_string($expected) && is_string($actual));
+    }
+
+    /**
+     * Asserts that two values are equal.
+     *
+     * @param mixed $expected     First value to compare
+     * @param mixed $actual       Second value to compare
+     * @param float $delta        Allowed numerical distance between two values to consider them equal
+     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+     * @param bool  $ignoreCase   Case is ignored when set to true
+     *
+     * @throws ComparisonFailure
+     */
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    {
+        if (is_infinite($actual) && is_infinite($expected)) {
+            return;
+        }
+
+        if ((is_infinite($actual) xor is_infinite($expected)) ||
+            (is_nan($actual) or is_nan($expected)) ||
+            abs($actual - $expected) > $delta) {
+            throw new ComparisonFailure(
+                $expected,
+                $actual,
+                '',
+                '',
+                false,
+                sprintf(
+                    'Failed asserting that %s matches expected %s.',
+                    $this->exporter->export($actual),
+                    $this->exporter->export($expected)
+                )
+            );
+        }
+    }
+}

vendor/sebastian/comparator/src/ObjectComparator.php

@@ -0,0 +1,105 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Compares objects for equality.
+ */
+class ObjectComparator extends ArrayComparator
+{
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    public function accepts($expected, $actual)
+    {
+        return is_object($expected) && is_object($actual);
+    }
+
+    /**
+     * Asserts that two values are equal.
+     *
+     * @param mixed $expected     First value to compare
+     * @param mixed $actual       Second value to compare
+     * @param float $delta        Allowed numerical distance between two values to consider them equal
+     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+     * @param bool  $ignoreCase   Case is ignored when set to true
+     * @param array $processed    List of already processed elements (used to prevent infinite recursion)
+     *
+     * @throws ComparisonFailure
+     */
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = array())
+    {
+        if (get_class($actual) !== get_class($expected)) {
+            throw new ComparisonFailure(
+                $expected,
+                $actual,
+                $this->exporter->export($expected),
+                $this->exporter->export($actual),
+                false,
+                sprintf(
+                    '%s is not instance of expected class "%s".',
+                    $this->exporter->export($actual),
+                    get_class($expected)
+                )
+            );
+        }
+
+        // don't compare twice to allow for cyclic dependencies
+        if (in_array(array($actual, $expected), $processed, true) ||
+            in_array(array($expected, $actual), $processed, true)) {
+            return;
+        }
+
+        $processed[] = array($actual, $expected);
+
+        // don't compare objects if they are identical
+        // this helps to avoid the error "maximum function nesting level reached"
+        // CAUTION: this conditional clause is not tested
+        if ($actual !== $expected) {
+            try {
+                parent::assertEquals(
+                    $this->toArray($expected),
+                    $this->toArray($actual),
+                    $delta,
+                    $canonicalize,
+                    $ignoreCase,
+                    $processed
+                );
+            } catch (ComparisonFailure $e) {
+                throw new ComparisonFailure(
+                    $expected,
+                    $actual,
+                    // replace "Array" with "MyClass object"
+                    substr_replace($e->getExpectedAsString(), get_class($expected) . ' Object', 0, 5),
+                    substr_replace($e->getActualAsString(), get_class($actual) . ' Object', 0, 5),
+                    false,
+                    'Failed asserting that two objects are equal.'
+                );
+            }
+        }
+    }
+
+    /**
+     * Converts an object to an array containing all of its private, protected
+     * and public properties.
+     *
+     * @param  object $object
+     * @return array
+     */
+    protected function toArray($object)
+    {
+        return $this->exporter->toArray($object);
+    }
+}

vendor/sebastian/comparator/src/ResourceComparator.php

@@ -0,0 +1,52 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Compares resources for equality.
+ */
+class ResourceComparator extends Comparator
+{
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    public function accepts($expected, $actual)
+    {
+        return is_resource($expected) && is_resource($actual);
+    }
+
+    /**
+     * Asserts that two values are equal.
+     *
+     * @param mixed $expected     First value to compare
+     * @param mixed $actual       Second value to compare
+     * @param float $delta        Allowed numerical distance between two values to consider them equal
+     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+     * @param bool  $ignoreCase   Case is ignored when set to true
+     *
+     * @throws ComparisonFailure
+     */
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    {
+        if ($actual != $expected) {
+            throw new ComparisonFailure(
+                $expected,
+                $actual,
+                $this->exporter->export($expected),
+                $this->exporter->export($actual)
+            );
+        }
+    }
+}

vendor/sebastian/comparator/src/ScalarComparator.php

@@ -0,0 +1,90 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Compares scalar or NULL values for equality.
+ */
+class ScalarComparator extends Comparator
+{
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     * @since  Method available since Release 3.6.0
+     */
+    public function accepts($expected, $actual)
+    {
+        return ((is_scalar($expected) xor null === $expected) &&
+               (is_scalar($actual) xor null === $actual))
+               // allow comparison between strings and objects featuring __toString()
+               || (is_string($expected) && is_object($actual) && method_exists($actual, '__toString'))
+               || (is_object($expected) && method_exists($expected, '__toString') && is_string($actual));
+    }
+
+    /**
+     * Asserts that two values are equal.
+     *
+     * @param mixed $expected     First value to compare
+     * @param mixed $actual       Second value to compare
+     * @param float $delta        Allowed numerical distance between two values to consider them equal
+     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+     * @param bool  $ignoreCase   Case is ignored when set to true
+     *
+     * @throws ComparisonFailure
+     */
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    {
+        $expectedToCompare = $expected;
+        $actualToCompare   = $actual;
+
+        // always compare as strings to avoid strange behaviour
+        // otherwise 0 == 'Foobar'
+        if (is_string($expected) || is_string($actual)) {
+            $expectedToCompare = (string) $expectedToCompare;
+            $actualToCompare   = (string) $actualToCompare;
+
+            if ($ignoreCase) {
+                $expectedToCompare = strtolower($expectedToCompare);
+                $actualToCompare   = strtolower($actualToCompare);
+            }
+        }
+
+        if ($expectedToCompare != $actualToCompare) {
+            if (is_string($expected) && is_string($actual)) {
+                throw new ComparisonFailure(
+                    $expected,
+                    $actual,
+                    $this->exporter->export($expected),
+                    $this->exporter->export($actual),
+                    false,
+                    'Failed asserting that two strings are equal.'
+                );
+            }
+
+            throw new ComparisonFailure(
+                $expected,
+                $actual,
+                // no diff is required
+                '',
+                '',
+                false,
+                sprintf(
+                    'Failed asserting that %s matches expected %s.',
+                    $this->exporter->export($actual),
+                    $this->exporter->export($expected)
+                )
+            );
+        }
+    }
+}

vendor/sebastian/comparator/src/SplObjectStorageComparator.php

@@ -0,0 +1,69 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Compares \SplObjectStorage instances for equality.
+ */
+class SplObjectStorageComparator extends Comparator
+{
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    public function accepts($expected, $actual)
+    {
+        return $expected instanceof \SplObjectStorage && $actual instanceof \SplObjectStorage;
+    }
+
+    /**
+     * Asserts that two values are equal.
+     *
+     * @param mixed $expected     First value to compare
+     * @param mixed $actual       Second value to compare
+     * @param float $delta        Allowed numerical distance between two values to consider them equal
+     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+     * @param bool  $ignoreCase   Case is ignored when set to true
+     *
+     * @throws ComparisonFailure
+     */
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    {
+        foreach ($actual as $object) {
+            if (!$expected->contains($object)) {
+                throw new ComparisonFailure(
+                    $expected,
+                    $actual,
+                    $this->exporter->export($expected),
+                    $this->exporter->export($actual),
+                    false,
+                    'Failed asserting that two objects are equal.'
+                );
+            }
+        }
+
+        foreach ($expected as $object) {
+            if (!$actual->contains($object)) {
+                throw new ComparisonFailure(
+                    $expected,
+                    $actual,
+                    $this->exporter->export($expected),
+                    $this->exporter->export($actual),
+                    false,
+                    'Failed asserting that two objects are equal.'
+                );
+            }
+        }
+    }
+}

vendor/sebastian/comparator/src/TypeComparator.php

@@ -0,0 +1,59 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * Compares values for type equality.
+ */
+class TypeComparator extends Comparator
+{
+    /**
+     * Returns whether the comparator can compare two values.
+     *
+     * @param  mixed $expected The first value to compare
+     * @param  mixed $actual   The second value to compare
+     * @return bool
+     */
+    public function accepts($expected, $actual)
+    {
+        return true;
+    }
+
+    /**
+     * Asserts that two values are equal.
+     *
+     * @param mixed $expected     First value to compare
+     * @param mixed $actual       Second value to compare
+     * @param float $delta        Allowed numerical distance between two values to consider them equal
+     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+     * @param bool  $ignoreCase   Case is ignored when set to true
+     *
+     * @throws ComparisonFailure
+     */
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    {
+        if (gettype($expected) != gettype($actual)) {
+            throw new ComparisonFailure(
+                $expected,
+                $actual,
+                // we don't need a diff
+                '',
+                '',
+                false,
+                sprintf(
+                    '%s does not match expected type "%s".',
+                    $this->exporter->shortenedExport($actual),
+                    gettype($expected)
+                )
+            );
+        }
+    }
+}

vendor/sebastian/comparator/tests/ArrayComparatorTest.php

@@ -0,0 +1,163 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\ArrayComparator
+ *
+ */
+class ArrayComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new ArrayComparator;
+        $this->comparator->setFactory(new Factory);
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return array(
+          array(array(), null),
+          array(null, array()),
+          array(null, null)
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return array(
+          array(
+            array('a' => 1, 'b' => 2),
+            array('b' => 2, 'a' => 1)
+          ),
+          array(
+            array(1),
+            array('1')
+          ),
+          array(
+            array(3, 2, 1),
+            array(2, 3, 1),
+            0,
+            true
+          ),
+          array(
+            array(2.3),
+            array(2.5),
+            0.5
+          ),
+          array(
+            array(array(2.3)),
+            array(array(2.5)),
+            0.5
+          ),
+          array(
+            array(new Struct(2.3)),
+            array(new Struct(2.5)),
+            0.5
+          ),
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return array(
+          array(
+            array(),
+            array(0 => 1)
+          ),
+          array(
+            array(0 => 1),
+            array()
+          ),
+          array(
+            array(0 => null),
+            array()
+          ),
+          array(
+            array(0 => 1, 1 => 2),
+            array(0 => 1, 1 => 3)
+          ),
+          array(
+            array('a', 'b' => array(1, 2)),
+            array('a', 'b' => array(2, 1))
+          ),
+          array(
+            array(2.3),
+            array(4.2),
+            0.5
+          ),
+          array(
+            array(array(2.3)),
+            array(array(4.2)),
+            0.5
+          ),
+          array(
+            array(new Struct(2.3)),
+            array(new Struct(4.2)),
+            0.5
+          )
+        );
+    }
+
+    /**
+     * @covers  ::accepts
+     */
+    public function testAcceptsSucceeds()
+    {
+        $this->assertTrue(
+          $this->comparator->accepts(array(), array())
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsFailsProvider
+     */
+    public function testAcceptsFails($expected, $actual)
+    {
+        $this->assertFalse(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0, $canonicalize = false)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual, $delta, $canonicalize);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual,$delta = 0.0, $canonicalize = false)
+    {
+        $this->setExpectedException(
+          'SebastianBergmann\\Comparator\\ComparisonFailure',
+          'Failed asserting that two arrays are equal'
+        );
+        $this->comparator->assertEquals($expected, $actual, $delta, $canonicalize);
+    }
+}

vendor/sebastian/comparator/tests/DOMNodeComparatorTest.php

@@ -0,0 +1,162 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+use DOMNode;
+use DOMDocument;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\DOMNodeComparator
+ *
+ */
+class DOMNodeComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new DOMNodeComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        $document = new DOMDocument;
+        $node = new DOMNode;
+
+        return array(
+          array($document, $document),
+          array($node, $node),
+          array($document, $node),
+          array($node, $document)
+        );
+    }
+
+    public function acceptsFailsProvider()
+    {
+        $document = new DOMDocument;
+
+        return array(
+          array($document, null),
+          array(null, $document),
+          array(null, null)
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return array(
+          array(
+            $this->createDOMDocument('<root></root>'),
+            $this->createDOMDocument('<root/>')
+          ),
+          array(
+            $this->createDOMDocument('<root attr="bar"></root>'),
+            $this->createDOMDocument('<root attr="bar"/>')
+          ),
+          array(
+            $this->createDOMDocument('<root><foo attr="bar"></foo></root>'),
+            $this->createDOMDocument('<root><foo attr="bar"/></root>')
+          ),
+          array(
+            $this->createDOMDocument("<root>\n  <child/>\n</root>"),
+            $this->createDOMDocument('<root><child/></root>')
+          ),
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return array(
+          array(
+            $this->createDOMDocument('<root></root>'),
+            $this->createDOMDocument('<bar/>')
+          ),
+          array(
+            $this->createDOMDocument('<foo attr1="bar"/>'),
+            $this->createDOMDocument('<foo attr1="foobar"/>')
+          ),
+          array(
+            $this->createDOMDocument('<foo> bar </foo>'),
+            $this->createDOMDocument('<foo />')
+          ),
+          array(
+            $this->createDOMDocument('<foo xmlns="urn:myns:bar"/>'),
+            $this->createDOMDocument('<foo xmlns="urn:notmyns:bar"/>')
+          ),
+          array(
+            $this->createDOMDocument('<foo> bar </foo>'),
+            $this->createDOMDocument('<foo> bir </foo>')
+          )
+        );
+    }
+
+    private function createDOMDocument($content)
+    {
+        $document = new DOMDocument;
+        $document->preserveWhiteSpace = false;
+        $document->loadXML($content);
+
+        return $document;
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsSucceedsProvider
+     */
+    public function testAcceptsSucceeds($expected, $actual)
+    {
+        $this->assertTrue(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsFailsProvider
+     */
+    public function testAcceptsFails($expected, $actual)
+    {
+        $this->assertFalse(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual)
+    {
+        $this->setExpectedException(
+          'SebastianBergmann\\Comparator\\ComparisonFailure',
+          'Failed asserting that two DOM'
+        );
+        $this->comparator->assertEquals($expected, $actual);
+    }
+}

vendor/sebastian/comparator/tests/DateTimeComparatorTest.php

@@ -0,0 +1,216 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+use DateTime;
+use DateTimeImmutable;
+use DateTimeZone;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\DateTimeComparator
+ *
+ */
+class DateTimeComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new DateTimeComparator;
+    }
+
+    public function acceptsFailsProvider()
+    {
+        $datetime = new DateTime;
+
+        return array(
+          array($datetime, null),
+          array(null, $datetime),
+          array(null, null)
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return array(
+          array(
+            new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York'))
+          ),
+          array(
+            new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 04:13:25', new DateTimeZone('America/New_York')),
+            10
+          ),
+          array(
+            new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 04:14:40', new DateTimeZone('America/New_York')),
+            65
+          ),
+          array(
+            new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29', new DateTimeZone('America/New_York'))
+          ),
+          array(
+            new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/Chicago'))
+          ),
+          array(
+            new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 03:13:49', new DateTimeZone('America/Chicago')),
+            15
+          ),
+          array(
+            new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago'))
+          ),
+          array(
+            new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 23:01:30', new DateTimeZone('America/Chicago')),
+            100
+          ),
+          array(
+            new DateTime('@1364616000'),
+            new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago'))
+          ),
+          array(
+            new DateTime('2013-03-29T05:13:35-0500'),
+            new DateTime('2013-03-29T04:13:35-0600')
+          )
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return array(
+          array(
+            new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/New_York'))
+          ),
+          array(
+            new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/New_York')),
+            3500
+          ),
+          array(
+            new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 05:13:35', new DateTimeZone('America/New_York')),
+            3500
+          ),
+          array(
+            new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-30', new DateTimeZone('America/New_York'))
+          ),
+          array(
+            new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
+            43200
+          ),
+          array(
+            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')),
+          ),
+          array(
+            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')),
+            3500
+          ),
+          array(
+            new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-30', new DateTimeZone('America/Chicago'))
+          ),
+          array(
+            new DateTime('2013-03-29T05:13:35-0600'),
+            new DateTime('2013-03-29T04:13:35-0600')
+          ),
+          array(
+            new DateTime('2013-03-29T05:13:35-0600'),
+            new DateTime('2013-03-29T05:13:35-0500')
+          ),
+        );
+    }
+
+    /**
+     * @covers  ::accepts
+     */
+    public function testAcceptsSucceeds()
+    {
+        $this->assertTrue(
+          $this->comparator->accepts(
+            new DateTime,
+            new DateTime
+          )
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsFailsProvider
+     */
+    public function testAcceptsFails($expected, $actual)
+    {
+        $this->assertFalse(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual, $delta);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual, $delta = 0.0)
+    {
+        $this->setExpectedException(
+          'SebastianBergmann\\Comparator\\ComparisonFailure',
+          'Failed asserting that two DateTime objects are equal.'
+        );
+        $this->comparator->assertEquals($expected, $actual, $delta);
+    }
+
+    /**
+     * @requires PHP 5.5
+     * @covers   ::accepts
+     */
+    public function testAcceptsDateTimeInterface()
+    {
+        $this->assertTrue($this->comparator->accepts(new DateTime, new DateTimeImmutable));
+    }
+
+    /**
+     * @requires PHP 5.5
+     * @covers   ::assertEquals
+     */
+    public function testSupportsDateTimeInterface()
+    {
+        $this->comparator->assertEquals(
+          new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
+          new DateTimeImmutable('2013-03-29 04:13:35', new DateTimeZone('America/New_York'))
+        );
+    }
+}

vendor/sebastian/comparator/tests/DoubleComparatorTest.php

@@ -0,0 +1,134 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\DoubleComparator
+ *
+ */
+class DoubleComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new DoubleComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return array(
+          array(0, 5.0),
+          array(5.0, 0),
+          array('5', 4.5),
+          array(1.2e3, 7E-10),
+          array(3, acos(8)),
+          array(acos(8), 3),
+          array(acos(8), acos(8))
+        );
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return array(
+          array(5, 5),
+          array('4.5', 5),
+          array(0x539, 02471),
+          array(5.0, false),
+          array(null, 5.0)
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return array(
+          array(2.3, 2.3),
+          array('2.3', 2.3),
+          array(5.0, 5),
+          array(5, 5.0),
+          array(5.0, '5'),
+          array(1.2e3, 1200),
+          array(2.3, 2.5, 0.5),
+          array(3, 3.05, 0.05),
+          array(1.2e3, 1201, 1),
+          array((string)(1/3), 1 - 2/3),
+          array(1/3, (string)(1 - 2/3))
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return array(
+          array(2.3, 4.2),
+          array('2.3', 4.2),
+          array(5.0, '4'),
+          array(5.0, 6),
+          array(1.2e3, 1201),
+          array(2.3, 2.5, 0.2),
+          array(3, 3.05, 0.04),
+          array(3, acos(8)),
+          array(acos(8), 3),
+          array(acos(8), acos(8))
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsSucceedsProvider
+     */
+    public function testAcceptsSucceeds($expected, $actual)
+    {
+        $this->assertTrue(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsFailsProvider
+     */
+    public function testAcceptsFails($expected, $actual)
+    {
+        $this->assertFalse(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual, $delta);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual, $delta = 0.0)
+    {
+        $this->setExpectedException(
+          'SebastianBergmann\\Comparator\\ComparisonFailure', 'matches expected'
+        );
+        $this->comparator->assertEquals($expected, $actual, $delta);
+    }
+}

vendor/sebastian/comparator/tests/ExceptionComparatorTest.php

@@ -0,0 +1,136 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+use \Exception;
+use \RuntimeException;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\ExceptionComparator
+ *
+ */
+class ExceptionComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new ExceptionComparator;
+        $this->comparator->setFactory(new Factory);
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return array(
+          array(new Exception, new Exception),
+          array(new RuntimeException, new RuntimeException),
+          array(new Exception, new RuntimeException)
+        );
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return array(
+          array(new Exception, null),
+          array(null, new Exception),
+          array(null, null)
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        $exception1 = new Exception;
+        $exception2 = new Exception;
+
+        $exception3 = new RunTimeException('Error', 100);
+        $exception4 = new RunTimeException('Error', 100);
+
+        return array(
+          array($exception1, $exception1),
+          array($exception1, $exception2),
+          array($exception3, $exception3),
+          array($exception3, $exception4)
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        $typeMessage = 'not instance of expected class';
+        $equalMessage = 'Failed asserting that two objects are equal.';
+
+        $exception1 = new Exception('Error', 100);
+        $exception2 = new Exception('Error', 101);
+        $exception3 = new Exception('Errors', 101);
+
+        $exception4 = new RunTimeException('Error', 100);
+        $exception5 = new RunTimeException('Error', 101);
+
+        return array(
+          array($exception1, $exception2, $equalMessage),
+          array($exception1, $exception3, $equalMessage),
+          array($exception1, $exception4, $typeMessage),
+          array($exception2, $exception3, $equalMessage),
+          array($exception4, $exception5, $equalMessage)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsSucceedsProvider
+     */
+    public function testAcceptsSucceeds($expected, $actual)
+    {
+        $this->assertTrue(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsFailsProvider
+     */
+    public function testAcceptsFails($expected, $actual)
+    {
+        $this->assertFalse(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual, $message)
+    {
+        $this->setExpectedException(
+          'SebastianBergmann\\Comparator\\ComparisonFailure', $message
+        );
+        $this->comparator->assertEquals($expected, $actual);
+    }
+}

vendor/sebastian/comparator/tests/FactoryTest.php

@@ -0,0 +1,115 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\Factory
+ *
+ */
+class FactoryTest extends \PHPUnit_Framework_TestCase
+{
+    public function instanceProvider()
+    {
+        $tmpfile = tmpfile();
+
+        return array(
+            array(NULL, NULL, 'SebastianBergmann\\Comparator\\ScalarComparator'),
+            array(NULL, TRUE, 'SebastianBergmann\\Comparator\\ScalarComparator'),
+            array(TRUE, NULL, 'SebastianBergmann\\Comparator\\ScalarComparator'),
+            array(TRUE, TRUE, 'SebastianBergmann\\Comparator\\ScalarComparator'),
+            array(FALSE, FALSE, 'SebastianBergmann\\Comparator\\ScalarComparator'),
+            array(TRUE, FALSE, 'SebastianBergmann\\Comparator\\ScalarComparator'),
+            array(FALSE, TRUE, 'SebastianBergmann\\Comparator\\ScalarComparator'),
+            array('', '', 'SebastianBergmann\\Comparator\\ScalarComparator'),
+            array('0', '0', 'SebastianBergmann\\Comparator\\ScalarComparator'),
+            array('0', 0, 'SebastianBergmann\\Comparator\\NumericComparator'),
+            array(0, '0', 'SebastianBergmann\\Comparator\\NumericComparator'),
+            array(0, 0, 'SebastianBergmann\\Comparator\\NumericComparator'),
+            array(1.0, 0, 'SebastianBergmann\\Comparator\\DoubleComparator'),
+            array(0, 1.0, 'SebastianBergmann\\Comparator\\DoubleComparator'),
+            array(1.0, 1.0, 'SebastianBergmann\\Comparator\\DoubleComparator'),
+            array(array(1), array(1), 'SebastianBergmann\\Comparator\\ArrayComparator'),
+            array($tmpfile, $tmpfile, 'SebastianBergmann\\Comparator\\ResourceComparator'),
+            array(new \stdClass, new \stdClass, 'SebastianBergmann\\Comparator\\ObjectComparator'),
+            array(new \DateTime, new \DateTime, 'SebastianBergmann\\Comparator\\DateTimeComparator'),
+            array(new \SplObjectStorage, new \SplObjectStorage, 'SebastianBergmann\\Comparator\\SplObjectStorageComparator'),
+            array(new \Exception, new \Exception, 'SebastianBergmann\\Comparator\\ExceptionComparator'),
+            array(new \DOMDocument, new \DOMDocument, 'SebastianBergmann\\Comparator\\DOMNodeComparator'),
+            // mixed types
+            array($tmpfile, array(1), 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array(array(1), $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array($tmpfile, '1', 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array('1', $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array($tmpfile, new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array(new \stdClass, $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array(new \stdClass, array(1), 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array(array(1), new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array(new \stdClass, '1', 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array('1', new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array(new ClassWithToString, '1', 'SebastianBergmann\\Comparator\\ScalarComparator'),
+            array('1', new ClassWithToString, 'SebastianBergmann\\Comparator\\ScalarComparator'),
+            array(1.0, new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array(new \stdClass, 1.0, 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array(1.0, array(1), 'SebastianBergmann\\Comparator\\TypeComparator'),
+            array(array(1), 1.0, 'SebastianBergmann\\Comparator\\TypeComparator'),
+        );
+    }
+
+    /**
+     * @dataProvider instanceProvider
+     * @covers       ::getComparatorFor
+     * @covers       ::__construct
+     */
+    public function testGetComparatorFor($a, $b, $expected)
+    {
+        $factory = new Factory;
+        $actual = $factory->getComparatorFor($a, $b);
+        $this->assertInstanceOf($expected, $actual);
+    }
+
+    /**
+     * @covers ::register
+     */
+    public function testRegister()
+    {
+        $comparator = new TestClassComparator;
+
+        $factory = new Factory;
+        $factory->register($comparator);
+
+        $a = new TestClass;
+        $b = new TestClass;
+        $expected = 'SebastianBergmann\\Comparator\\TestClassComparator';
+        $actual = $factory->getComparatorFor($a, $b);
+
+        $factory->unregister($comparator);
+        $this->assertInstanceOf($expected, $actual);
+    }
+
+    /**
+     * @covers ::unregister
+     */
+    public function testUnregister()
+    {
+        $comparator = new TestClassComparator;
+
+        $factory = new Factory;
+        $factory->register($comparator);
+        $factory->unregister($comparator);
+
+        $a = new TestClass;
+        $b = new TestClass;
+        $expected = 'SebastianBergmann\\Comparator\\ObjectComparator';
+        $actual = $factory->getComparatorFor($a, $b);
+
+        $this->assertInstanceOf($expected, $actual);
+    }
+}

vendor/sebastian/comparator/tests/MockObjectComparatorTest.php

@@ -0,0 +1,166 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\MockObjectComparator
+ *
+ */
+class MockObjectComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new MockObjectComparator;
+        $this->comparator->setFactory(new Factory);
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        $testmock = $this->getMock('SebastianBergmann\\Comparator\\TestClass');
+        $stdmock = $this->getMock('stdClass');
+
+        return array(
+          array($testmock, $testmock),
+          array($stdmock, $stdmock),
+          array($stdmock, $testmock)
+        );
+    }
+
+    public function acceptsFailsProvider()
+    {
+        $stdmock = $this->getMock('stdClass');
+
+        return array(
+          array($stdmock, null),
+          array(null, $stdmock),
+          array(null, null)
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        // cyclic dependencies
+        $book1 = $this->getMock('SebastianBergmann\\Comparator\\Book', null);
+        $book1->author = $this->getMock('SebastianBergmann\\Comparator\\Author', null, array('Terry Pratchett'));
+        $book1->author->books[] = $book1;
+        $book2 = $this->getMock('SebastianBergmann\\Comparator\\Book', null);
+        $book2->author = $this->getMock('SebastianBergmann\\Comparator\\Author', null, array('Terry Pratchett'));
+        $book2->author->books[] = $book2;
+
+        $object1 = $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(4, 8, 15));
+        $object2 = $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(4, 8, 15));
+
+        return array(
+          array($object1, $object1),
+          array($object1, $object2),
+          array($book1, $book1),
+          array($book1, $book2),
+          array(
+            $this->getMock('SebastianBergmann\\Comparator\\Struct', null, array(2.3)),
+            $this->getMock('SebastianBergmann\\Comparator\\Struct', null, array(2.5)),
+            0.5
+          )
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        $typeMessage = 'is not instance of expected class';
+        $equalMessage = 'Failed asserting that two objects are equal.';
+
+        // cyclic dependencies
+        $book1 = $this->getMock('SebastianBergmann\\Comparator\\Book', null);
+        $book1->author = $this->getMock('SebastianBergmann\\Comparator\\Author', null, array('Terry Pratchett'));
+        $book1->author->books[] = $book1;
+        $book2 = $this->getMock('SebastianBergmann\\Comparator\\Book', null);
+        $book2->author = $this->getMock('SebastianBergmann\\Comparator\\Author', null, array('Terry Pratch'));
+        $book2->author->books[] = $book2;
+
+        $book3 = $this->getMock('SebastianBergmann\\Comparator\\Book', null);
+        $book3->author = 'Terry Pratchett';
+        $book4 = $this->getMock('stdClass');
+        $book4->author = 'Terry Pratchett';
+
+        $object1 = $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(4, 8, 15));
+        $object2 = $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(16, 23, 42));
+
+        return array(
+          array(
+            $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(4, 8, 15)),
+            $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(16, 23, 42)),
+            $equalMessage
+          ),
+          array($object1, $object2, $equalMessage),
+          array($book1, $book2, $equalMessage),
+          array($book3, $book4, $typeMessage),
+          array(
+            $this->getMock('SebastianBergmann\\Comparator\\Struct', null, array(2.3)),
+            $this->getMock('SebastianBergmann\\Comparator\\Struct', null, array(4.2)),
+            $equalMessage,
+            0.5
+          )
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsSucceedsProvider
+     */
+    public function testAcceptsSucceeds($expected, $actual)
+    {
+        $this->assertTrue(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsFailsProvider
+     */
+    public function testAcceptsFails($expected, $actual)
+    {
+        $this->assertFalse(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual, $delta);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0)
+    {
+        $this->setExpectedException(
+          'SebastianBergmann\\Comparator\\ComparisonFailure', $message
+        );
+        $this->comparator->assertEquals($expected, $actual, $delta);
+    }
+}

vendor/sebastian/comparator/tests/NumericComparatorTest.php

@@ -0,0 +1,122 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\NumericComparator
+ *
+ */
+class NumericComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new NumericComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return array(
+          array(5, 10),
+          array(8, '0'),
+          array('10', 0),
+          array(0x74c3b00c, 42),
+          array(0755, 0777)
+        );
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return array(
+          array('5', '10'),
+          array(8, 5.0),
+          array(5.0, 8),
+          array(10, null),
+          array(false, 12)
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return array(
+          array(1337, 1337),
+          array('1337', 1337),
+          array(0x539, 1337),
+          array(02471, 1337),
+          array(1337, 1338, 1),
+          array('1337', 1340, 5),
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return array(
+          array(1337, 1338),
+          array('1338', 1337),
+          array(0x539, 1338),
+          array(1337, 1339, 1),
+          array('1337', 1340, 2),
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsSucceedsProvider
+     */
+    public function testAcceptsSucceeds($expected, $actual)
+    {
+        $this->assertTrue(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsFailsProvider
+     */
+    public function testAcceptsFails($expected, $actual)
+    {
+        $this->assertFalse(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual, $delta);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual, $delta = 0.0)
+    {
+        $this->setExpectedException(
+          'SebastianBergmann\\Comparator\\ComparisonFailure', 'matches expected'
+        );
+        $this->comparator->assertEquals($expected, $actual, $delta);
+    }
+}

vendor/sebastian/comparator/tests/ObjectComparatorTest.php

@@ -0,0 +1,150 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+use stdClass;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\ObjectComparator
+ *
+ */
+class ObjectComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new ObjectComparator;
+        $this->comparator->setFactory(new Factory);
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return array(
+          array(new TestClass, new TestClass),
+          array(new stdClass, new stdClass),
+          array(new stdClass, new TestClass)
+        );
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return array(
+          array(new stdClass, null),
+          array(null, new stdClass),
+          array(null, null)
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        // cyclic dependencies
+        $book1 = new Book;
+        $book1->author = new Author('Terry Pratchett');
+        $book1->author->books[] = $book1;
+        $book2 = new Book;
+        $book2->author = new Author('Terry Pratchett');
+        $book2->author->books[] = $book2;
+
+        $object1 = new SampleClass(4, 8, 15);
+        $object2 = new SampleClass(4, 8, 15);
+
+        return array(
+          array($object1, $object1),
+          array($object1, $object2),
+          array($book1, $book1),
+          array($book1, $book2),
+          array(new Struct(2.3), new Struct(2.5), 0.5)
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        $typeMessage = 'is not instance of expected class';
+        $equalMessage = 'Failed asserting that two objects are equal.';
+
+        // cyclic dependencies
+        $book1 = new Book;
+        $book1->author = new Author('Terry Pratchett');
+        $book1->author->books[] = $book1;
+        $book2 = new Book;
+        $book2->author = new Author('Terry Pratch');
+        $book2->author->books[] = $book2;
+
+        $book3 = new Book;
+        $book3->author = 'Terry Pratchett';
+        $book4 = new stdClass;
+        $book4->author = 'Terry Pratchett';
+
+        $object1 = new SampleClass( 4,  8, 15);
+        $object2 = new SampleClass(16, 23, 42);
+
+        return array(
+          array(new SampleClass(4, 8, 15), new SampleClass(16, 23, 42), $equalMessage),
+          array($object1, $object2, $equalMessage),
+          array($book1, $book2, $equalMessage),
+          array($book3, $book4, $typeMessage),
+          array(new Struct(2.3), new Struct(4.2), $equalMessage, 0.5)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsSucceedsProvider
+     */
+    public function testAcceptsSucceeds($expected, $actual)
+    {
+        $this->assertTrue(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsFailsProvider
+     */
+    public function testAcceptsFails($expected, $actual)
+    {
+        $this->assertFalse(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual, $delta);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0)
+    {
+        $this->setExpectedException(
+          'SebastianBergmann\\Comparator\\ComparisonFailure', $message
+        );
+        $this->comparator->assertEquals($expected, $actual, $delta);
+    }
+}

vendor/sebastian/comparator/tests/ResourceComparatorTest.php

@@ -0,0 +1,120 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\ResourceComparator
+ *
+ */
+class ResourceComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new ResourceComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        $tmpfile1 = tmpfile();
+        $tmpfile2 = tmpfile();
+
+        return array(
+          array($tmpfile1, $tmpfile1),
+          array($tmpfile2, $tmpfile2),
+          array($tmpfile1, $tmpfile2)
+        );
+    }
+
+    public function acceptsFailsProvider()
+    {
+        $tmpfile1 = tmpfile();
+
+        return array(
+          array($tmpfile1, null),
+          array(null, $tmpfile1),
+          array(null, null)
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        $tmpfile1 = tmpfile();
+        $tmpfile2 = tmpfile();
+
+        return array(
+          array($tmpfile1, $tmpfile1),
+          array($tmpfile2, $tmpfile2)
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        $tmpfile1 = tmpfile();
+        $tmpfile2 = tmpfile();
+
+        return array(
+          array($tmpfile1, $tmpfile2),
+          array($tmpfile2, $tmpfile1)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsSucceedsProvider
+     */
+    public function testAcceptsSucceeds($expected, $actual)
+    {
+        $this->assertTrue(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsFailsProvider
+     */
+    public function testAcceptsFails($expected, $actual)
+    {
+        $this->assertFalse(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual)
+    {
+        $this->setExpectedException('SebastianBergmann\\Comparator\\ComparisonFailure');
+        $this->comparator->assertEquals($expected, $actual);
+    }
+}

vendor/sebastian/comparator/tests/ScalarComparatorTest.php

@@ -0,0 +1,158 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\ScalarComparator
+ *
+ */
+class ScalarComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new ScalarComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return array(
+          array("string", "string"),
+          array(new ClassWithToString, "string"),
+          array("string", new ClassWithToString),
+          array("string", null),
+          array(false, "string"),
+          array(false, true),
+          array(null, false),
+          array(null, null),
+          array("10", 10),
+          array("", false),
+          array("1", true),
+          array(1, true),
+          array(0, false),
+          array(0.1, "0.1")
+        );
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return array(
+          array(array(), array()),
+          array("string", array()),
+          array(new ClassWithToString, new ClassWithToString),
+          array(false, new ClassWithToString),
+          array(tmpfile(), tmpfile())
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return array(
+          array("string", "string"),
+          array(new ClassWithToString, new ClassWithToString),
+          array("string representation", new ClassWithToString),
+          array(new ClassWithToString, "string representation"),
+          array("string", "STRING", true),
+          array("STRING", "string", true),
+          array("String Representation", new ClassWithToString, true),
+          array(new ClassWithToString, "String Representation", true),
+          array("10", 10),
+          array("", false),
+          array("1", true),
+          array(1, true),
+          array(0, false),
+          array(0.1, "0.1"),
+          array(false, null),
+          array(false, false),
+          array(true, true),
+          array(null, null)
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        $stringException = 'Failed asserting that two strings are equal.';
+        $otherException = 'matches expected';
+
+        return array(
+          array("string", "other string", $stringException),
+          array("string", "STRING", $stringException),
+          array("STRING", "string", $stringException),
+          array("string", "other string", $stringException),
+          // https://github.com/sebastianbergmann/phpunit/issues/1023
+          array('9E6666666','9E7777777', $stringException),
+          array(new ClassWithToString, "does not match", $otherException),
+          array("does not match", new ClassWithToString, $otherException),
+          array(0, 'Foobar', $otherException),
+          array('Foobar', 0, $otherException),
+          array("10", 25, $otherException),
+          array("1", false, $otherException),
+          array("", true, $otherException),
+          array(false, true, $otherException),
+          array(true, false, $otherException),
+          array(null, true, $otherException),
+          array(0, true, $otherException)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsSucceedsProvider
+     */
+    public function testAcceptsSucceeds($expected, $actual)
+    {
+        $this->assertTrue(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsFailsProvider
+     */
+    public function testAcceptsFails($expected, $actual)
+    {
+        $this->assertFalse(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual, $ignoreCase = false)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual, 0.0, false, $ignoreCase);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual, $message)
+    {
+        $this->setExpectedException(
+          'SebastianBergmann\\Comparator\\ComparisonFailure', $message
+        );
+        $this->comparator->assertEquals($expected, $actual);
+    }
+}

vendor/sebastian/comparator/tests/SplObjectStorageComparatorTest.php

@@ -0,0 +1,137 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+use SplObjectStorage;
+use stdClass;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\SplObjectStorageComparator
+ *
+ */
+class SplObjectStorageComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new SplObjectStorageComparator;
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return array(
+          array(new SplObjectStorage, new stdClass),
+          array(new stdClass, new SplObjectStorage),
+          array(new stdClass, new stdClass)
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        $object1 = new stdClass();
+        $object2 = new stdClass();
+
+        $storage1 = new SplObjectStorage();
+        $storage2 = new SplObjectStorage();
+
+        $storage3 = new SplObjectStorage();
+        $storage3->attach($object1);
+        $storage3->attach($object2);
+
+        $storage4 = new SplObjectStorage();
+        $storage4->attach($object2);
+        $storage4->attach($object1);
+
+        return array(
+          array($storage1, $storage1),
+          array($storage1, $storage2),
+          array($storage3, $storage3),
+          array($storage3, $storage4)
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        $object1 = new stdClass;
+        $object2 = new stdClass;
+
+        $storage1 = new SplObjectStorage;
+
+        $storage2 = new SplObjectStorage;
+        $storage2->attach($object1);
+
+        $storage3 = new SplObjectStorage;
+        $storage3->attach($object2);
+        $storage3->attach($object1);
+
+        return array(
+          array($storage1, $storage2),
+          array($storage1, $storage3),
+          array($storage2, $storage3),
+        );
+    }
+
+    /**
+     * @covers  ::accepts
+     */
+    public function testAcceptsSucceeds()
+    {
+        $this->assertTrue(
+          $this->comparator->accepts(
+            new SplObjectStorage,
+            new SplObjectStorage
+          )
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsFailsProvider
+     */
+    public function testAcceptsFails($expected, $actual)
+    {
+        $this->assertFalse(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual)
+    {
+        $this->setExpectedException(
+          'SebastianBergmann\\Comparator\\ComparisonFailure',
+          'Failed asserting that two objects are equal.'
+        );
+        $this->comparator->assertEquals($expected, $actual);
+    }
+}

vendor/sebastian/comparator/tests/TypeComparatorTest.php

@@ -0,0 +1,104 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+use stdClass;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\TypeComparator
+ *
+ */
+class TypeComparatorTest extends \PHPUnit_Framework_TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new TypeComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return array(
+          array(true, 1),
+          array(false, array(1)),
+          array(null, new stdClass),
+          array(1.0, 5),
+          array("", "")
+        );
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return array(
+          array(true, true),
+          array(true, false),
+          array(false, false),
+          array(null, null),
+          array(new stdClass, new stdClass),
+          array(0, 0),
+          array(1.0, 2.0),
+          array("hello", "world"),
+          array("", ""),
+          array(array(), array(1,2,3))
+        );
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return array(
+          array(true, null),
+          array(null, false),
+          array(1.0, 0),
+          array(new stdClass, array()),
+          array("1", 1)
+        );
+    }
+
+    /**
+     * @covers       ::accepts
+     * @dataProvider acceptsSucceedsProvider
+     */
+    public function testAcceptsSucceeds($expected, $actual)
+    {
+        $this->assertTrue(
+          $this->comparator->accepts($expected, $actual)
+        );
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsSucceedsProvider
+     */
+    public function testAssertEqualsSucceeds($expected, $actual)
+    {
+        $exception = null;
+
+        try {
+            $this->comparator->assertEquals($expected, $actual);
+        }
+
+        catch (ComparisonFailure $exception) {
+        }
+
+        $this->assertNull($exception, 'Unexpected ComparisonFailure');
+    }
+
+    /**
+     * @covers       ::assertEquals
+     * @dataProvider assertEqualsFailsProvider
+     */
+    public function testAssertEqualsFails($expected, $actual)
+    {
+        $this->setExpectedException('SebastianBergmann\\Comparator\\ComparisonFailure', 'does not match expected type');
+        $this->comparator->assertEquals($expected, $actual);
+    }
+}

vendor/sebastian/comparator/tests/_files/Author.php

@@ -0,0 +1,28 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * An author.
+ *
+ */
+class Author
+{
+    // the order of properties is important for testing the cycle!
+    public $books = array();
+
+    private $name = '';
+
+    public function __construct($name)
+    {
+        $this->name = $name;
+    }
+}

vendor/sebastian/comparator/tests/_files/Book.php

@@ -0,0 +1,21 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * A book.
+ *
+ */
+class Book
+{
+    // the order of properties is important for testing the cycle!
+    public $author = null;
+}

vendor/sebastian/comparator/tests/_files/ClassWithToString.php

@@ -0,0 +1,19 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+class ClassWithToString
+{
+    public function __toString()
+    {
+        return 'string representation';
+    }
+}

vendor/sebastian/comparator/tests/_files/SampleClass.php

@@ -0,0 +1,29 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * A sample class.
+ *
+ */
+class SampleClass
+{
+    public $a;
+    protected $b;
+    protected $c;
+
+    public function __construct($a, $b, $c)
+    {
+        $this->a = $a;
+        $this->b = $b;
+        $this->c = $c;
+    }
+}

vendor/sebastian/comparator/tests/_files/Struct.php

@@ -0,0 +1,25 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+/**
+ * A struct.
+ *
+ */
+class Struct
+{
+    public $var;
+
+    public function __construct($var)
+    {
+        $this->var = $var;
+    }
+}

vendor/sebastian/comparator/tests/_files/TestClass.php

@@ -0,0 +1,14 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+class TestClass {
+}

vendor/sebastian/comparator/tests/_files/TestClassComparator.php

@@ -0,0 +1,14 @@
+<?php
+/*
+ * This file is part of the Comparator package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SebastianBergmann\Comparator;
+
+class TestClassComparator extends ObjectComparator {
+}

vendor/sebastian/comparator/tests/autoload.php

@@ -0,0 +1,38 @@
+<?php
+// @codingStandardsIgnoreFile
+// @codeCoverageIgnoreStart
+// this is an autogenerated file - do not edit
+spl_autoload_register(
+    function($class) {
+        static $classes = null;
+        if ($classes === null) {
+            $classes = array(
+                'sebastianbergmann\\comparator\\arraycomparatortest' => '/ArrayComparatorTest.php',
+                'sebastianbergmann\\comparator\\author' => '/_files/Author.php',
+                'sebastianbergmann\\comparator\\book' => '/_files/Book.php',
+                'sebastianbergmann\\comparator\\classwithtostring' => '/_files/ClassWithToString.php',
+                'sebastianbergmann\\comparator\\datetimecomparatortest' => '/DateTimeComparatorTest.php',
+                'sebastianbergmann\\comparator\\domnodecomparatortest' => '/DOMNodeComparatorTest.php',
+                'sebastianbergmann\\comparator\\doublecomparatortest' => '/DoubleComparatorTest.php',
+                'sebastianbergmann\\comparator\\exceptioncomparatortest' => '/ExceptionComparatorTest.php',
+                'sebastianbergmann\\comparator\\factorytest' => '/FactoryTest.php',
+                'sebastianbergmann\\comparator\\mockobjectcomparatortest' => '/MockObjectComparatorTest.php',
+                'sebastianbergmann\\comparator\\numericcomparatortest' => '/NumericComparatorTest.php',
+                'sebastianbergmann\\comparator\\objectcomparatortest' => '/ObjectComparatorTest.php',
+                'sebastianbergmann\\comparator\\resourcecomparatortest' => '/ResourceComparatorTest.php',
+                'sebastianbergmann\\comparator\\sampleclass' => '/_files/SampleClass.php',
+                'sebastianbergmann\\comparator\\scalarcomparatortest' => '/ScalarComparatorTest.php',
+                'sebastianbergmann\\comparator\\splobjectstoragecomparatortest' => '/SplObjectStorageComparatorTest.php',
+                'sebastianbergmann\\comparator\\struct' => '/_files/Struct.php',
+                'sebastianbergmann\\comparator\\testclass' => '/_files/TestClass.php',
+                'sebastianbergmann\\comparator\\testclasscomparator' => '/_files/TestClassComparator.php',
+                'sebastianbergmann\\comparator\\typecomparatortest' => '/TypeComparatorTest.php'
+            );
+        }
+        $cn = strtolower($class);
+        if (isset($classes[$cn])) {
+            require __DIR__ . $classes[$cn];
+        }
+    }
+);
+// @codeCoverageIgnoreEnd

vendor/sebastian/comparator/tests/bootstrap.php

@@ -0,0 +1,7 @@
+<?php
+require __DIR__ . '/../vendor/autoload.php';
+require __DIR__ . '/autoload.php';
+
+ini_set('precision', 14);
+ini_set('serialize_precision', 14);
+