Added Laravel project

Laravel/vendor/sebastian/comparator/.gitignore

@@ -0,0 +1,4 @@
+/.idea
+/.php_cs.cache
+/composer.lock
+/vendor

Laravel/vendor/sebastian/comparator/.php_cs

@@ -0,0 +1,81 @@
+<?php
+$header = <<<'EOF'
+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.
+EOF;
+
+return PhpCsFixer\Config::create()
+    ->setRiskyAllowed(true)
+    ->setRules(
+        [
+            'array_syntax' => ['syntax' => 'short'],
+            'binary_operator_spaces' => [
+                'align_double_arrow' => true,
+                'align_equals' => true
+            ],
+            'blank_line_after_namespace' => true,
+            'blank_line_before_return' => true,
+            'braces' => true,
+            'cast_spaces' => true,
+            'concat_space' => ['spacing' => 'one'],
+            'elseif' => true,
+            'encoding' => true,
+            'full_opening_tag' => true,
+            'function_declaration' => true,
+            'header_comment' => ['header' => $header, 'separate' => 'none'],
+            'indentation_type' => true,
+            'line_ending' => true,
+            'lowercase_constants' => true,
+            'lowercase_keywords' => true,
+            'method_argument_space' => true,
+            //'native_function_invocation' => true,
+            'no_alias_functions' => true,
+            'no_blank_lines_after_class_opening' => true,
+            'no_blank_lines_after_phpdoc' => true,
+            'no_closing_tag' => true,
+            'no_empty_phpdoc' => true,
+            'no_empty_statement' => true,
+            'no_extra_consecutive_blank_lines' => true,
+            'no_leading_namespace_whitespace' => true,
+            'no_singleline_whitespace_before_semicolons' => true,
+            'no_spaces_after_function_name' => true,
+            'no_spaces_inside_parenthesis' => true,
+            'no_trailing_comma_in_list_call' => true,
+            'no_trailing_whitespace' => true,
+            'no_unused_imports' => true,
+            'no_whitespace_in_blank_line' => true,
+            'phpdoc_align' => true,
+            'phpdoc_indent' => true,
+            'phpdoc_no_access' => true,
+            'phpdoc_no_empty_return' => true,
+            'phpdoc_no_package' => true,
+            'phpdoc_scalar' => true,
+            //'phpdoc_separation' => true,
+            'phpdoc_to_comment' => true,
+            'phpdoc_trim' => true,
+            'phpdoc_types' => true,
+            'phpdoc_var_without_name' => true,
+            'self_accessor' => true,
+            'simplified_null_return' => true,
+            'single_blank_line_at_eof' => true,
+            'single_import_per_statement' => true,
+            'single_line_after_imports' => true,
+            'single_quote' => true,
+            'strict_param' => true,
+            'ternary_operator_spaces' => true,
+            'trim_array_spaces' => true,
+            'visibility_required' => true,
+        ]
+    )
+    ->setFinder(
+        PhpCsFixer\Finder::create()
+        ->files()
+        ->in(__DIR__ . '/src')
+        ->in(__DIR__ . '/tests')
+        ->exclude(__DIR__.'/tests/_fixture')
+        ->name('*.php')
+    );

Laravel/vendor/sebastian/comparator/.travis.yml

@@ -0,0 +1,35 @@
+language: php
+
+sudo: false
+
+php:
+  - 7.0
+  - 7.0snapshot
+  - 7.1
+  - 7.1snapshot
+  - master
+
+env:
+  matrix:
+    - DEPENDENCIES="high"
+    - DEPENDENCIES="low"
+  global:
+    - DEFAULT_COMPOSER_FLAGS="--no-interaction --no-ansi --no-progress --no-suggest"
+
+before_install:
+  - composer self-update
+  - composer clear-cache
+
+install:
+  - if [[ "$DEPENDENCIES" = 'high' ]]; then travis_retry composer update $DEFAULT_COMPOSER_FLAGS; fi
+  - if [[ "$DEPENDENCIES" = 'low' ]]; then travis_retry composer update $DEFAULT_COMPOSER_FLAGS --prefer-lowest; fi
+
+script:
+  - ./vendor/bin/phpunit --coverage-clover=coverage.xml
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
+
+notifications:
+  email: false
+

Laravel/vendor/sebastian/comparator/LICENSE

@@ -0,0 +1,33 @@
+Comparator
+
+Copyright (c) 2002-2017, 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.

Laravel/vendor/sebastian/comparator/README.md

@@ -0,0 +1,37 @@
+[![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";
+}
+```
+

Laravel/vendor/sebastian/comparator/build.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="comparator" default="setup">
+    <target name="setup" depends="clean,composer"/>
+
+    <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">
+        <exec executable="composer" taskname="composer">
+            <env key="COMPOSER_DISABLE_XDEBUG_WARN" value="1"/>
+            <arg value="update"/>
+            <arg value="--no-interaction"/>
+            <arg value="--no-progress"/>
+            <arg value="--no-ansi"/>
+            <arg value="--no-suggest"/>
+        </exec>
+    </target>
+</project>
+

Laravel/vendor/sebastian/comparator/composer.json

@@ -0,0 +1,54 @@
+{
+    "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"
+        }
+    ],
+    "prefer-stable": true,
+    "require": {
+        "php": "^7.0",
+        "sebastian/diff": "^2.0",
+        "sebastian/exporter": "^3.0"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^6.0"
+    },
+    "config": {
+        "optimize-autoloader": true,
+        "sort-packages": true
+    },
+    "autoload": {
+        "classmap": [
+            "src/"
+        ]
+    },
+    "autoload-dev": {
+        "classmap": [
+            "tests/_fixture"
+        ]
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "2.0.x-dev"
+        }
+    }
+}
+

Laravel/vendor/sebastian/comparator/phpunit.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/6.0/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
+         beStrictAboutCoversAnnotation="true"
+         beStrictAboutOutputDuringTests="true"
+         beStrictAboutTodoAnnotatedTests="true"
+         verbose="true">
+    <testsuite>
+        <directory suffix="Test.php">tests</directory>
+    </testsuite>
+
+    <filter>
+        <whitelist processUncoveredFilesFromWhitelist="true">
+            <directory suffix=".php">src</directory>
+        </whitelist>
+    </filter>
+</phpunit>

Laravel/vendor/sebastian/comparator/src/ArrayComparator.php

@@ -0,0 +1,131 @@
+<?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 = [])
+    {
+        if ($canonicalize) {
+            sort($expected);
+            sort($actual);
+        }
+
+        $remaining        = $actual;
+        $actualAsString   = "Array (\n";
+        $expectedAsString = "Array (\n";
+        $equal            = true;
+
+        foreach ($expected as $key => $value) {
+            unset($remaining[$key]);
+
+            if (!array_key_exists($key, $actual)) {
+                $expectedAsString .= 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);
+
+                $expectedAsString .= sprintf(
+                    "    %s => %s\n",
+                    $this->exporter->export($key),
+                    $this->exporter->shortenedExport($value)
+                );
+
+                $actualAsString .= sprintf(
+                    "    %s => %s\n",
+                    $this->exporter->export($key),
+                    $this->exporter->shortenedExport($actual[$key])
+                );
+            } catch (ComparisonFailure $e) {
+                $expectedAsString .= sprintf(
+                    "    %s => %s\n",
+                    $this->exporter->export($key),
+                    $e->getExpectedAsString() ? $this->indent($e->getExpectedAsString()) : $this->exporter->shortenedExport($e->getExpected())
+                );
+
+                $actualAsString .= 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) {
+            $actualAsString .= sprintf(
+                "    %s => %s\n",
+                $this->exporter->export($key),
+                $this->exporter->shortenedExport($value)
+            );
+
+            $equal = false;
+        }
+
+        $expectedAsString .= ')';
+        $actualAsString   .= ')';
+
+        if (!$equal) {
+            throw new ComparisonFailure(
+                $expected,
+                $actual,
+                $expectedAsString,
+                $actualAsString,
+                false,
+                'Failed asserting that two arrays are equal.'
+            );
+        }
+    }
+
+    protected function indent($lines)
+    {
+        return trim(str_replace("\n", "\n    ", $lines));
+    }
+}

Laravel/vendor/sebastian/comparator/src/Comparator.php

@@ -0,0 +1,65 @@
+<?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);
+}

Laravel/vendor/sebastian/comparator/src/ComparisonFailure.php

@@ -0,0 +1,135 @@
+<?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;
+use SebastianBergmann\Diff\Output\UnifiedDiffOutputBuilder;
+
+/**
+ * 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(new UnifiedDiffOutputBuilder("\n--- Expected\n+++ Actual\n"));
+
+        return $differ->diff($this->expectedAsString, $this->actualAsString);
+    }
+
+    /**
+     * @return string
+     */
+    public function toString()
+    {
+        return $this->message . $this->getDiff();
+    }
+}

Laravel/vendor/sebastian/comparator/src/DOMNodeComparator.php

@@ -0,0 +1,87 @@
+<?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 = [])
+    {
+        $expectedAsString = $this->nodeToText($expected, true, $ignoreCase);
+        $actualAsString   = $this->nodeToText($actual, true, $ignoreCase);
+
+        if ($expectedAsString !== $actualAsString) {
+            $type = $expected instanceof DOMDocument ? 'documents' : '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.
+     */
+    private function nodeToText(DOMNode $node, bool $canonicalize, bool $ignoreCase): string
+    {
+        if ($canonicalize) {
+            $document = new DOMDocument;
+            @$document->loadXML($node->C14N());
+
+            $node = $document;
+        }
+
+        $document = $node instanceof DOMDocument ? $node : $node->ownerDocument;
+
+        $document->formatOutput = true;
+        $document->normalizeDocument();
+
+        $text = $node instanceof DOMDocument ? $node->saveXML() : $document->saveXML($node);
+
+        return $ignoreCase ? $text : strtolower($text);
+    }
+}

Laravel/vendor/sebastian/comparator/src/DateTimeComparator.php

@@ -0,0 +1,75 @@
+<?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 = [])
+    {
+        $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.
+     */
+    private function dateTimeToString(\DateTimeInterface $datetime): string
+    {
+        $string = $datetime->format('Y-m-d\TH:i:s.uO');
+
+        return $string ?: 'Invalid DateTimeInterface object';
+    }
+}

Laravel/vendor/sebastian/comparator/src/DoubleComparator.php

@@ -0,0 +1,57 @@
+<?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_float($expected) || is_float($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);
+    }
+}

Laravel/vendor/sebastian/comparator/src/ExceptionComparator.php

@@ -0,0 +1,53 @@
+<?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;
+    }
+}

Laravel/vendor/sebastian/comparator/src/Factory.php

@@ -0,0 +1,108 @@
+<?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 = [];
+
+    /**
+     * @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]);
+            }
+        }
+    }
+}

Laravel/vendor/sebastian/comparator/src/MockObjectComparator.php

@@ -0,0 +1,47 @@
+<?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;
+    }
+}

Laravel/vendor/sebastian/comparator/src/NumericComparator.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 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_float($expected) || is_float($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)
+                )
+            );
+        }
+    }
+}

Laravel/vendor/sebastian/comparator/src/ObjectComparator.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;
+
+/**
+ * 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 = [])
+    {
+        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([$actual, $expected], $processed, true) ||
+            in_array([$expected, $actual], $processed, true)) {
+            return;
+        }
+
+        $processed[] = [$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);
+    }
+}

Laravel/vendor/sebastian/comparator/src/ResourceComparator.php

@@ -0,0 +1,53 @@
+<?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)
+            );
+        }
+    }
+}

Laravel/vendor/sebastian/comparator/src/ScalarComparator.php

@@ -0,0 +1,92 @@
+<?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)
+                )
+            );
+        }
+    }
+}

Laravel/vendor/sebastian/comparator/src/SplObjectStorageComparator.php

@@ -0,0 +1,70 @@
+<?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.'
+                );
+            }
+        }
+    }
+}

Laravel/vendor/sebastian/comparator/src/TypeComparator.php

@@ -0,0 +1,60 @@
+<?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)
+                )
+            );
+        }
+    }
+}

Laravel/vendor/sebastian/comparator/tests/ArrayComparatorTest.php

@@ -0,0 +1,167 @@
+<?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 PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\ArrayComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class ArrayComparatorTest extends TestCase
+{
+    /**
+     * @var ArrayComparator
+     */
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new ArrayComparator;
+        $this->comparator->setFactory(new Factory);
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return [
+          [[], null],
+          [null, []],
+          [null, null]
+        ];
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return [
+          [
+            ['a' => 1, 'b' => 2],
+            ['b' => 2, 'a' => 1]
+          ],
+          [
+            [1],
+            ['1']
+          ],
+          [
+            [3, 2, 1],
+            [2, 3, 1],
+            0,
+            true
+          ],
+          [
+            [2.3],
+            [2.5],
+            0.5
+          ],
+          [
+            [[2.3]],
+            [[2.5]],
+            0.5
+          ],
+          [
+            [new Struct(2.3)],
+            [new Struct(2.5)],
+            0.5
+          ],
+        ];
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return [
+          [
+            [],
+            [0 => 1]
+          ],
+          [
+            [0 => 1],
+            []
+          ],
+          [
+            [0 => null],
+            []
+          ],
+          [
+            [0 => 1, 1 => 2],
+            [0 => 1, 1 => 3]
+          ],
+          [
+            ['a', 'b' => [1, 2]],
+            ['a', 'b' => [2, 1]]
+          ],
+          [
+            [2.3],
+            [4.2],
+            0.5
+          ],
+          [
+            [[2.3]],
+            [[4.2]],
+            0.5
+          ],
+          [
+            [new Struct(2.3)],
+            [new Struct(4.2)],
+            0.5
+          ]
+        ];
+    }
+
+    /**
+     * @covers  ::accepts
+     */
+    public function testAcceptsSucceeds()
+    {
+        $this->assertTrue(
+          $this->comparator->accepts([], [])
+        );
+    }
+
+    /**
+     * @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->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage('Failed asserting that two arrays are equal');
+
+        $this->comparator->assertEquals($expected, $actual, $delta, $canonicalize);
+    }
+}

Laravel/vendor/sebastian/comparator/tests/ComparisonFailureTest.php

@@ -0,0 +1,58 @@
+<?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 PHPUnit\Framework\TestCase;
+
+/**
+ * @covers SebastianBergmann\Comparator\ComparisonFailure
+ */
+final class ComparisonFailureTest extends TestCase
+{
+    public function testComparisonFailure()
+    {
+        $actual   = "\nB\n";
+        $expected = "\nA\n";
+        $message  = 'Test message';
+
+        $failure = new ComparisonFailure(
+            $expected,
+            $actual,
+            '|' . $expected,
+            '|' . $actual,
+            false,
+            $message
+        );
+
+        $this->assertSame($actual, $failure->getActual());
+        $this->assertSame($expected, $failure->getExpected());
+        $this->assertSame('|' . $actual, $failure->getActualAsString());
+        $this->assertSame('|' . $expected, $failure->getExpectedAsString());
+
+        $diff = '
+--- Expected
++++ Actual
+@@ @@
+ |
+-A
++B
+';
+        $this->assertSame($diff, $failure->getDiff());
+        $this->assertSame($message . $diff, $failure->toString());
+    }
+
+    public function testDiffNotPossible()
+    {
+        $failure = new ComparisonFailure('a', 'b', false, false, true, 'test');
+        $this->assertSame('', $failure->getDiff());
+        $this->assertSame('test', $failure->toString());
+    }
+}

Laravel/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;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\DOMNodeComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class DOMNodeComparatorTest extends TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new DOMNodeComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        $document = new DOMDocument;
+        $node     = new DOMNode;
+
+        return [
+          [$document, $document],
+          [$node, $node],
+          [$document, $node],
+          [$node, $document]
+        ];
+    }
+
+    public function acceptsFailsProvider()
+    {
+        $document = new DOMDocument;
+
+        return [
+          [$document, null],
+          [null, $document],
+          [null, null]
+        ];
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return [
+          [
+            $this->createDOMDocument('<root></root>'),
+            $this->createDOMDocument('<root/>')
+          ],
+          [
+            $this->createDOMDocument('<root attr="bar"></root>'),
+            $this->createDOMDocument('<root attr="bar"/>')
+          ],
+          [
+            $this->createDOMDocument('<root><foo attr="bar"></foo></root>'),
+            $this->createDOMDocument('<root><foo attr="bar"/></root>')
+          ],
+          [
+            $this->createDOMDocument("<root>\n  <child/>\n</root>"),
+            $this->createDOMDocument('<root><child/></root>')
+          ],
+        ];
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return [
+          [
+            $this->createDOMDocument('<root></root>'),
+            $this->createDOMDocument('<bar/>')
+          ],
+          [
+            $this->createDOMDocument('<foo attr1="bar"/>'),
+            $this->createDOMDocument('<foo attr1="foobar"/>')
+          ],
+          [
+            $this->createDOMDocument('<foo> bar </foo>'),
+            $this->createDOMDocument('<foo />')
+          ],
+          [
+            $this->createDOMDocument('<foo xmlns="urn:myns:bar"/>'),
+            $this->createDOMDocument('<foo xmlns="urn:notmyns:bar"/>')
+          ],
+          [
+            $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->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage('Failed asserting that two DOM');
+
+        $this->comparator->assertEquals($expected, $actual);
+    }
+}

Laravel/vendor/sebastian/comparator/tests/DateTimeComparatorTest.php

@@ -0,0 +1,221 @@
+<?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;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\DateTimeComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class DateTimeComparatorTest extends TestCase
+{
+    /**
+     * @var DateTimeComparator
+     */
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new DateTimeComparator;
+    }
+
+    public function acceptsFailsProvider()
+    {
+        $datetime = new DateTime;
+
+        return [
+          [$datetime, null],
+          [null, $datetime],
+          [null, null]
+        ];
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return [
+          [
+            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'))
+          ],
+          [
+            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
+          ],
+          [
+            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
+          ],
+          [
+            new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29', new DateTimeZone('America/New_York'))
+          ],
+          [
+            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'))
+          ],
+          [
+            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
+          ],
+          [
+            new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago'))
+          ],
+          [
+            new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-29 23:01:30', new DateTimeZone('America/Chicago')),
+            100
+          ],
+          [
+            new DateTime('@1364616000'),
+            new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago'))
+          ],
+          [
+            new DateTime('2013-03-29T05:13:35-0500'),
+            new DateTime('2013-03-29T04:13:35-0600')
+          ]
+        ];
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return [
+          [
+            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'))
+          ],
+          [
+            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
+          ],
+          [
+            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
+          ],
+          [
+            new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-30', new DateTimeZone('America/New_York'))
+          ],
+          [
+            new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
+            43200
+          ],
+          [
+            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')),
+          ],
+          [
+            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
+          ],
+          [
+            new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
+            new DateTime('2013-03-30', new DateTimeZone('America/Chicago'))
+          ],
+          [
+            new DateTime('2013-03-29T05:13:35-0600'),
+            new DateTime('2013-03-29T04:13:35-0600')
+          ],
+          [
+            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->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage('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->assertNull(
+            $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'))
+            )
+        );
+    }
+}

Laravel/vendor/sebastian/comparator/tests/DoubleComparatorTest.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 PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\DoubleComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class DoubleComparatorTest extends TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new DoubleComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return [
+          [0, 5.0],
+          [5.0, 0],
+          ['5', 4.5],
+          [1.2e3, 7E-10],
+          [3, acos(8)],
+          [acos(8), 3],
+          [acos(8), acos(8)]
+        ];
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return [
+          [5, 5],
+          ['4.5', 5],
+          [0x539, 02471],
+          [5.0, false],
+          [null, 5.0]
+        ];
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return [
+          [2.3, 2.3],
+          ['2.3', 2.3],
+          [5.0, 5],
+          [5, 5.0],
+          [5.0, '5'],
+          [1.2e3, 1200],
+          [2.3, 2.5, 0.5],
+          [3, 3.05, 0.05],
+          [1.2e3, 1201, 1],
+          [(string) (1 / 3), 1 - 2 / 3],
+          [1 / 3, (string) (1 - 2 / 3)]
+        ];
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return [
+          [2.3, 4.2],
+          ['2.3', 4.2],
+          [5.0, '4'],
+          [5.0, 6],
+          [1.2e3, 1201],
+          [2.3, 2.5, 0.2],
+          [3, 3.05, 0.04],
+          [3, acos(8)],
+          [acos(8), 3],
+          [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->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage('matches expected');
+
+        $this->comparator->assertEquals($expected, $actual, $delta);
+    }
+}

Laravel/vendor/sebastian/comparator/tests/ExceptionComparatorTest.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 \Exception;
+use \RuntimeException;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\ExceptionComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class ExceptionComparatorTest extends TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new ExceptionComparator;
+        $this->comparator->setFactory(new Factory);
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return [
+          [new Exception, new Exception],
+          [new RuntimeException, new RuntimeException],
+          [new Exception, new RuntimeException]
+        ];
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return [
+          [new Exception, null],
+          [null, new Exception],
+          [null, null]
+        ];
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        $exception1 = new Exception;
+        $exception2 = new Exception;
+
+        $exception3 = new RuntimeException('Error', 100);
+        $exception4 = new RuntimeException('Error', 100);
+
+        return [
+          [$exception1, $exception1],
+          [$exception1, $exception2],
+          [$exception3, $exception3],
+          [$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 [
+          [$exception1, $exception2, $equalMessage],
+          [$exception1, $exception3, $equalMessage],
+          [$exception1, $exception4, $typeMessage],
+          [$exception2, $exception3, $equalMessage],
+          [$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->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage($message);
+
+        $this->comparator->assertEquals($expected, $actual);
+    }
+}

Laravel/vendor/sebastian/comparator/tests/FactoryTest.php

@@ -0,0 +1,125 @@
+<?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 PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class FactoryTest extends TestCase
+{
+    public function instanceProvider()
+    {
+        $tmpfile = tmpfile();
+
+        return [
+            [null, null, 'SebastianBergmann\\Comparator\\ScalarComparator'],
+            [null, true, 'SebastianBergmann\\Comparator\\ScalarComparator'],
+            [true, null, 'SebastianBergmann\\Comparator\\ScalarComparator'],
+            [true, true, 'SebastianBergmann\\Comparator\\ScalarComparator'],
+            [false, false, 'SebastianBergmann\\Comparator\\ScalarComparator'],
+            [true, false, 'SebastianBergmann\\Comparator\\ScalarComparator'],
+            [false, true, 'SebastianBergmann\\Comparator\\ScalarComparator'],
+            ['', '', 'SebastianBergmann\\Comparator\\ScalarComparator'],
+            ['0', '0', 'SebastianBergmann\\Comparator\\ScalarComparator'],
+            ['0', 0, 'SebastianBergmann\\Comparator\\NumericComparator'],
+            [0, '0', 'SebastianBergmann\\Comparator\\NumericComparator'],
+            [0, 0, 'SebastianBergmann\\Comparator\\NumericComparator'],
+            [1.0, 0, 'SebastianBergmann\\Comparator\\DoubleComparator'],
+            [0, 1.0, 'SebastianBergmann\\Comparator\\DoubleComparator'],
+            [1.0, 1.0, 'SebastianBergmann\\Comparator\\DoubleComparator'],
+            [[1], [1], 'SebastianBergmann\\Comparator\\ArrayComparator'],
+            [$tmpfile, $tmpfile, 'SebastianBergmann\\Comparator\\ResourceComparator'],
+            [new \stdClass, new \stdClass, 'SebastianBergmann\\Comparator\\ObjectComparator'],
+            [new \DateTime, new \DateTime, 'SebastianBergmann\\Comparator\\DateTimeComparator'],
+            [new \SplObjectStorage, new \SplObjectStorage, 'SebastianBergmann\\Comparator\\SplObjectStorageComparator'],
+            [new \Exception, new \Exception, 'SebastianBergmann\\Comparator\\ExceptionComparator'],
+            [new \DOMDocument, new \DOMDocument, 'SebastianBergmann\\Comparator\\DOMNodeComparator'],
+            // mixed types
+            [$tmpfile, [1], 'SebastianBergmann\\Comparator\\TypeComparator'],
+            [[1], $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'],
+            [$tmpfile, '1', 'SebastianBergmann\\Comparator\\TypeComparator'],
+            ['1', $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'],
+            [$tmpfile, new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'],
+            [new \stdClass, $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'],
+            [new \stdClass, [1], 'SebastianBergmann\\Comparator\\TypeComparator'],
+            [[1], new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'],
+            [new \stdClass, '1', 'SebastianBergmann\\Comparator\\TypeComparator'],
+            ['1', new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'],
+            [new ClassWithToString, '1', 'SebastianBergmann\\Comparator\\ScalarComparator'],
+            ['1', new ClassWithToString, 'SebastianBergmann\\Comparator\\ScalarComparator'],
+            [1.0, new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'],
+            [new \stdClass, 1.0, 'SebastianBergmann\\Comparator\\TypeComparator'],
+            [1.0, [1], 'SebastianBergmann\\Comparator\\TypeComparator'],
+            [[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);
+    }
+
+    public function testIsSingleton()
+    {
+        $f = Factory::getInstance();
+        $this->assertSame($f, Factory::getInstance());
+    }
+}

Laravel/vendor/sebastian/comparator/tests/MockObjectComparatorTest.php

@@ -0,0 +1,169 @@
+<?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 PHPUnit\Framework\TestCase;
+use stdClass;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\MockObjectComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class MockObjectComparatorTest extends TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new MockObjectComparator;
+        $this->comparator->setFactory(new Factory);
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        $testmock = $this->createMock(TestClass::class);
+        $stdmock  = $this->createMock(stdClass::class);
+
+        return [
+          [$testmock, $testmock],
+          [$stdmock, $stdmock],
+          [$stdmock, $testmock]
+        ];
+    }
+
+    public function acceptsFailsProvider()
+    {
+        $stdmock = $this->createMock(stdClass::class);
+
+        return [
+          [$stdmock, null],
+          [null, $stdmock],
+          [null, null]
+        ];
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        // cyclic dependencies
+        $book1                  = $this->getMockBuilder(Book::class)->setMethods(null)->getMock();
+        $book1->author          = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratchett'])->getMock();
+        $book1->author->books[] = $book1;
+        $book2                  = $this->getMockBuilder(Book::class)->setMethods(null)->getMock();
+        $book2->author          = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratchett'])->getMock();
+        $book2->author->books[] = $book2;
+
+        $object1 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock();
+        $object2 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock();
+
+        return [
+          [$object1, $object1],
+          [$object1, $object2],
+          [$book1, $book1],
+          [$book1, $book2],
+          [
+            $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([2.3])->getMock(),
+            $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([2.5])->getMock(),
+            0.5
+          ]
+        ];
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        $typeMessage  = 'is not instance of expected class';
+        $equalMessage = 'Failed asserting that two objects are equal.';
+
+        // cyclic dependencies
+        $book1                  = $this->getMockBuilder(Book::class)->setMethods(null)->getMock();
+        $book1->author          = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratchett'])->getMock();
+        $book1->author->books[] = $book1;
+        $book2                  = $this->getMockBuilder(Book::class)->setMethods(null)->getMock();
+        $book1->author          = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratch'])->getMock();
+        $book2->author->books[] = $book2;
+
+        $book3         = $this->getMockBuilder(Book::class)->setMethods(null)->getMock();
+        $book3->author = 'Terry Pratchett';
+        $book4         = $this->createMock(stdClass::class);
+        $book4->author = 'Terry Pratchett';
+
+        $object1 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock();
+        $object2 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([16, 23, 42])->getMock();
+
+        return [
+          [
+            $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock(),
+            $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([16, 23, 42])->getMock(),
+            $equalMessage
+          ],
+          [$object1, $object2, $equalMessage],
+          [$book1, $book2, $equalMessage],
+          [$book3, $book4, $typeMessage],
+          [
+            $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([2.3])->getMock(),
+            $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([4.2])->getMock(),
+            $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->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage($message);
+
+        $this->comparator->assertEquals($expected, $actual, $delta);
+    }
+}

Laravel/vendor/sebastian/comparator/tests/NumericComparatorTest.php

@@ -0,0 +1,124 @@
+<?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 PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\NumericComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class NumericComparatorTest extends TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new NumericComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return [
+          [5, 10],
+          [8, '0'],
+          ['10', 0],
+          [0x74c3b00c, 42],
+          [0755, 0777]
+        ];
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return [
+          ['5', '10'],
+          [8, 5.0],
+          [5.0, 8],
+          [10, null],
+          [false, 12]
+        ];
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return [
+          [1337, 1337],
+          ['1337', 1337],
+          [0x539, 1337],
+          [02471, 1337],
+          [1337, 1338, 1],
+          ['1337', 1340, 5],
+        ];
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return [
+          [1337, 1338],
+          ['1338', 1337],
+          [0x539, 1338],
+          [1337, 1339, 1],
+          ['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->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage('matches expected');
+
+        $this->comparator->assertEquals($expected, $actual, $delta);
+    }
+}

Laravel/vendor/sebastian/comparator/tests/ObjectComparatorTest.php

@@ -0,0 +1,151 @@
+<?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;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\ObjectComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class ObjectComparatorTest extends TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new ObjectComparator;
+        $this->comparator->setFactory(new Factory);
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return [
+          [new TestClass, new TestClass],
+          [new stdClass, new stdClass],
+          [new stdClass, new TestClass]
+        ];
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return [
+          [new stdClass, null],
+          [null, new stdClass],
+          [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 [
+          [$object1, $object1],
+          [$object1, $object2],
+          [$book1, $book1],
+          [$book1, $book2],
+          [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 [
+          [new SampleClass(4, 8, 15), new SampleClass(16, 23, 42), $equalMessage],
+          [$object1, $object2, $equalMessage],
+          [$book1, $book2, $equalMessage],
+          [$book3, $book4, $typeMessage],
+          [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->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage($message);
+
+        $this->comparator->assertEquals($expected, $actual, $delta);
+    }
+}

Laravel/vendor/sebastian/comparator/tests/ResourceComparatorTest.php

@@ -0,0 +1,123 @@
+<?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 PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\ResourceComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class ResourceComparatorTest extends TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new ResourceComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        $tmpfile1 = tmpfile();
+        $tmpfile2 = tmpfile();
+
+        return [
+          [$tmpfile1, $tmpfile1],
+          [$tmpfile2, $tmpfile2],
+          [$tmpfile1, $tmpfile2]
+        ];
+    }
+
+    public function acceptsFailsProvider()
+    {
+        $tmpfile1 = tmpfile();
+
+        return [
+          [$tmpfile1, null],
+          [null, $tmpfile1],
+          [null, null]
+        ];
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        $tmpfile1 = tmpfile();
+        $tmpfile2 = tmpfile();
+
+        return [
+          [$tmpfile1, $tmpfile1],
+          [$tmpfile2, $tmpfile2]
+        ];
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        $tmpfile1 = tmpfile();
+        $tmpfile2 = tmpfile();
+
+        return [
+          [$tmpfile1, $tmpfile2],
+          [$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->expectException(ComparisonFailure::class);
+
+        $this->comparator->assertEquals($expected, $actual);
+    }
+}

Laravel/vendor/sebastian/comparator/tests/ScalarComparatorTest.php

@@ -0,0 +1,160 @@
+<?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 PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\ScalarComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class ScalarComparatorTest extends TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new ScalarComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return [
+          ['string', 'string'],
+          [new ClassWithToString, 'string'],
+          ['string', new ClassWithToString],
+          ['string', null],
+          [false, 'string'],
+          [false, true],
+          [null, false],
+          [null, null],
+          ['10', 10],
+          ['', false],
+          ['1', true],
+          [1, true],
+          [0, false],
+          [0.1, '0.1']
+        ];
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return [
+          [[], []],
+          ['string', []],
+          [new ClassWithToString, new ClassWithToString],
+          [false, new ClassWithToString],
+          [tmpfile(), tmpfile()]
+        ];
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return [
+          ['string', 'string'],
+          [new ClassWithToString, new ClassWithToString],
+          ['string representation', new ClassWithToString],
+          [new ClassWithToString, 'string representation'],
+          ['string', 'STRING', true],
+          ['STRING', 'string', true],
+          ['String Representation', new ClassWithToString, true],
+          [new ClassWithToString, 'String Representation', true],
+          ['10', 10],
+          ['', false],
+          ['1', true],
+          [1, true],
+          [0, false],
+          [0.1, '0.1'],
+          [false, null],
+          [false, false],
+          [true, true],
+          [null, null]
+        ];
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        $stringException = 'Failed asserting that two strings are equal.';
+        $otherException  = 'matches expected';
+
+        return [
+          ['string', 'other string', $stringException],
+          ['string', 'STRING', $stringException],
+          ['STRING', 'string', $stringException],
+          ['string', 'other string', $stringException],
+          // https://github.com/sebastianbergmann/phpunit/issues/1023
+          ['9E6666666','9E7777777', $stringException],
+          [new ClassWithToString, 'does not match', $otherException],
+          ['does not match', new ClassWithToString, $otherException],
+          [0, 'Foobar', $otherException],
+          ['Foobar', 0, $otherException],
+          ['10', 25, $otherException],
+          ['1', false, $otherException],
+          ['', true, $otherException],
+          [false, true, $otherException],
+          [true, false, $otherException],
+          [null, true, $otherException],
+          [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->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage($message);
+
+        $this->comparator->assertEquals($expected, $actual);
+    }
+}

Laravel/vendor/sebastian/comparator/tests/SplObjectStorageComparatorTest.php

@@ -0,0 +1,148 @@
+<?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;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\SplObjectStorageComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class SplObjectStorageComparatorTest extends TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new SplObjectStorageComparator;
+    }
+
+    public function acceptsFailsProvider()
+    {
+        return [
+          [new SplObjectStorage, new stdClass],
+          [new stdClass, new SplObjectStorage],
+          [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 [
+          [$storage1, $storage1],
+          [$storage1, $storage2],
+          [$storage3, $storage3],
+          [$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 [
+          [$storage1, $storage2],
+          [$storage1, $storage3],
+          [$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->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage('Failed asserting that two objects are equal.');
+
+        $this->comparator->assertEquals($expected, $actual);
+    }
+
+    public function testAssertEqualsFails2()
+    {
+        $this->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage('Failed asserting that two objects are equal.');
+
+        $t = new SplObjectStorage();
+        $t->attach(new \stdClass());
+
+        $this->comparator->assertEquals($t, new \SplObjectStorage());
+    }
+}

Laravel/vendor/sebastian/comparator/tests/TypeComparatorTest.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 stdClass;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass SebastianBergmann\Comparator\TypeComparator
+ * @uses SebastianBergmann\Comparator\Comparator
+ * @uses SebastianBergmann\Comparator\Factory
+ * @uses SebastianBergmann\Comparator\ComparisonFailure
+ */
+class TypeComparatorTest extends TestCase
+{
+    private $comparator;
+
+    protected function setUp()
+    {
+        $this->comparator = new TypeComparator;
+    }
+
+    public function acceptsSucceedsProvider()
+    {
+        return [
+          [true, 1],
+          [false, [1]],
+          [null, new stdClass],
+          [1.0, 5],
+          ['', '']
+        ];
+    }
+
+    public function assertEqualsSucceedsProvider()
+    {
+        return [
+          [true, true],
+          [true, false],
+          [false, false],
+          [null, null],
+          [new stdClass, new stdClass],
+          [0, 0],
+          [1.0, 2.0],
+          ['hello', 'world'],
+          ['', ''],
+          [[], [1,2,3]]
+        ];
+    }
+
+    public function assertEqualsFailsProvider()
+    {
+        return [
+          [true, null],
+          [null, false],
+          [1.0, 0],
+          [new stdClass, []],
+          ['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->expectException(ComparisonFailure::class);
+        $this->expectExceptionMessage('does not match expected type');
+
+        $this->comparator->assertEquals($expected, $actual);
+    }
+}

Laravel/vendor/sebastian/comparator/tests/_fixture/Author.php

@@ -0,0 +1,27 @@
+<?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 = [];
+
+    private $name = '';
+
+    public function __construct($name)
+    {
+        $this->name = $name;
+    }
+}

Laravel/vendor/sebastian/comparator/tests/_fixture/Book.php

@@ -0,0 +1,20 @@
+<?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;
+}

Laravel/vendor/sebastian/comparator/tests/_fixture/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';
+    }
+}

Laravel/vendor/sebastian/comparator/tests/_fixture/SampleClass.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;
+
+/**
+ * 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;
+    }
+}

Laravel/vendor/sebastian/comparator/tests/_fixture/Struct.php

@@ -0,0 +1,24 @@
+<?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;
+    }
+}

Laravel/vendor/sebastian/comparator/tests/_fixture/TestClass.php

@@ -0,0 +1,15 @@
+<?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
+{
+}

Laravel/vendor/sebastian/comparator/tests/_fixture/TestClassComparator.php

@@ -0,0 +1,15 @@
+<?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
+{
+}