Vendor lock
This commit is contained in:
40
vendor/sebastian/comparator/.github/stale.yml
vendored
Normal file
40
vendor/sebastian/comparator/.github/stale.yml
vendored
Normal file
@ -0,0 +1,40 @@
|
||||
# Configuration for probot-stale - https://github.com/probot/stale
|
||||
|
||||
# Number of days of inactivity before an Issue or Pull Request becomes stale
|
||||
daysUntilStale: 60
|
||||
|
||||
# Number of days of inactivity before a stale Issue or Pull Request is closed.
|
||||
# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
|
||||
daysUntilClose: 7
|
||||
|
||||
# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
|
||||
exemptLabels:
|
||||
- enhancement
|
||||
|
||||
# Set to true to ignore issues in a project (defaults to false)
|
||||
exemptProjects: false
|
||||
|
||||
# Set to true to ignore issues in a milestone (defaults to false)
|
||||
exemptMilestones: false
|
||||
|
||||
# Label to use when marking as stale
|
||||
staleLabel: stale
|
||||
|
||||
# Comment to post when marking as stale. Set to `false` to disable
|
||||
markComment: >
|
||||
This issue has been automatically marked as stale because it has not had activity within the last 60 days. It will be closed after 7 days if no further activity occurs. Thank you for your contributions.
|
||||
|
||||
# Comment to post when removing the stale label.
|
||||
# unmarkComment: >
|
||||
# Your comment here.
|
||||
|
||||
# Comment to post when closing a stale Issue or Pull Request.
|
||||
closeComment: >
|
||||
This issue has been automatically closed because it has not had activity since it was marked as stale. Thank you for your contributions.
|
||||
|
||||
# Limit the number of actions per hour, from 1-30. Default is 30
|
||||
limitPerRun: 30
|
||||
|
||||
# Limit to only `issues` or `pulls`
|
||||
only: issues
|
||||
|
||||
4
vendor/sebastian/comparator/.gitignore
vendored
Normal file
4
vendor/sebastian/comparator/.gitignore
vendored
Normal file
@ -0,0 +1,4 @@
|
||||
/.idea
|
||||
/.php_cs.cache
|
||||
/composer.lock
|
||||
/vendor
|
||||
189
vendor/sebastian/comparator/.php_cs.dist
vendored
Normal file
189
vendor/sebastian/comparator/.php_cs.dist
vendored
Normal file
@ -0,0 +1,189 @@
|
||||
<?php
|
||||
$header = <<<'EOF'
|
||||
This file is part of sebastian/comparator.
|
||||
|
||||
(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(
|
||||
[
|
||||
'align_multiline_comment' => true,
|
||||
'array_indentation' => true,
|
||||
'array_syntax' => ['syntax' => 'short'],
|
||||
'binary_operator_spaces' => [
|
||||
'operators' => [
|
||||
'=' => 'align',
|
||||
'=>' => 'align',
|
||||
],
|
||||
],
|
||||
'blank_line_after_namespace' => true,
|
||||
'blank_line_before_statement' => [
|
||||
'statements' => [
|
||||
'break',
|
||||
'continue',
|
||||
'declare',
|
||||
'do',
|
||||
'for',
|
||||
'foreach',
|
||||
'if',
|
||||
'include',
|
||||
'include_once',
|
||||
'require',
|
||||
'require_once',
|
||||
'return',
|
||||
'switch',
|
||||
'throw',
|
||||
'try',
|
||||
'while',
|
||||
'yield',
|
||||
],
|
||||
],
|
||||
'braces' => true,
|
||||
'cast_spaces' => true,
|
||||
'class_attributes_separation' => ['elements' => ['const', 'method', 'property']],
|
||||
'combine_consecutive_issets' => true,
|
||||
'combine_consecutive_unsets' => true,
|
||||
'compact_nullable_typehint' => true,
|
||||
'concat_space' => ['spacing' => 'one'],
|
||||
'declare_equal_normalize' => ['space' => 'none'],
|
||||
'dir_constant' => true,
|
||||
'elseif' => true,
|
||||
'encoding' => true,
|
||||
'full_opening_tag' => true,
|
||||
'function_declaration' => true,
|
||||
'header_comment' => ['header' => $header, 'separate' => 'none'],
|
||||
'indentation_type' => true,
|
||||
'is_null' => true,
|
||||
'line_ending' => true,
|
||||
'list_syntax' => ['syntax' => 'short'],
|
||||
'logical_operators' => true,
|
||||
'lowercase_cast' => true,
|
||||
'lowercase_constants' => true,
|
||||
'lowercase_keywords' => true,
|
||||
'lowercase_static_reference' => true,
|
||||
'magic_constant_casing' => true,
|
||||
'method_argument_space' => ['ensure_fully_multiline' => true],
|
||||
'modernize_types_casting' => true,
|
||||
'multiline_comment_opening_closing' => true,
|
||||
'multiline_whitespace_before_semicolons' => true,
|
||||
'native_constant_invocation' => true,
|
||||
'native_function_casing' => true,
|
||||
'native_function_invocation' => true,
|
||||
'new_with_braces' => false,
|
||||
'no_alias_functions' => true,
|
||||
'no_alternative_syntax' => true,
|
||||
'no_blank_lines_after_class_opening' => true,
|
||||
'no_blank_lines_after_phpdoc' => true,
|
||||
'no_blank_lines_before_namespace' => true,
|
||||
'no_closing_tag' => true,
|
||||
'no_empty_comment' => true,
|
||||
'no_empty_phpdoc' => true,
|
||||
'no_empty_statement' => true,
|
||||
'no_extra_blank_lines' => true,
|
||||
'no_homoglyph_names' => true,
|
||||
'no_leading_import_slash' => true,
|
||||
'no_leading_namespace_whitespace' => true,
|
||||
'no_mixed_echo_print' => ['use' => 'print'],
|
||||
'no_multiline_whitespace_around_double_arrow' => true,
|
||||
'no_null_property_initialization' => true,
|
||||
'no_php4_constructor' => true,
|
||||
'no_short_bool_cast' => true,
|
||||
'no_short_echo_tag' => true,
|
||||
'no_singleline_whitespace_before_semicolons' => true,
|
||||
'no_spaces_after_function_name' => true,
|
||||
'no_spaces_inside_parenthesis' => true,
|
||||
'no_superfluous_elseif' => true,
|
||||
'no_superfluous_phpdoc_tags' => true,
|
||||
'no_trailing_comma_in_list_call' => true,
|
||||
'no_trailing_comma_in_singleline_array' => true,
|
||||
'no_trailing_whitespace' => true,
|
||||
'no_trailing_whitespace_in_comment' => true,
|
||||
'no_unneeded_control_parentheses' => true,
|
||||
'no_unneeded_curly_braces' => true,
|
||||
'no_unneeded_final_method' => true,
|
||||
'no_unreachable_default_argument_value' => true,
|
||||
'no_unset_on_property' => true,
|
||||
'no_unused_imports' => true,
|
||||
'no_useless_else' => true,
|
||||
'no_useless_return' => true,
|
||||
'no_whitespace_before_comma_in_array' => true,
|
||||
'no_whitespace_in_blank_line' => true,
|
||||
'non_printable_character' => true,
|
||||
'normalize_index_brace' => true,
|
||||
'object_operator_without_whitespace' => true,
|
||||
'ordered_class_elements' => [
|
||||
'order' => [
|
||||
'use_trait',
|
||||
'constant_public',
|
||||
'constant_protected',
|
||||
'constant_private',
|
||||
'property_public_static',
|
||||
'property_protected_static',
|
||||
'property_private_static',
|
||||
'property_public',
|
||||
'property_protected',
|
||||
'property_private',
|
||||
'method_public_static',
|
||||
'construct',
|
||||
'destruct',
|
||||
'magic',
|
||||
'phpunit',
|
||||
'method_public',
|
||||
'method_protected',
|
||||
'method_private',
|
||||
'method_protected_static',
|
||||
'method_private_static',
|
||||
],
|
||||
],
|
||||
'ordered_imports' => true,
|
||||
'phpdoc_add_missing_param_annotation' => true,
|
||||
'phpdoc_align' => true,
|
||||
'phpdoc_annotation_without_dot' => true,
|
||||
'phpdoc_indent' => true,
|
||||
'phpdoc_no_access' => true,
|
||||
'phpdoc_no_empty_return' => true,
|
||||
'phpdoc_no_package' => true,
|
||||
'phpdoc_order' => true,
|
||||
'phpdoc_return_self_reference' => true,
|
||||
'phpdoc_scalar' => true,
|
||||
'phpdoc_separation' => true,
|
||||
'phpdoc_single_line_var_spacing' => true,
|
||||
'phpdoc_to_comment' => true,
|
||||
'phpdoc_trim' => true,
|
||||
'phpdoc_trim_consecutive_blank_line_separation' => true,
|
||||
'phpdoc_types' => true,
|
||||
'phpdoc_types_order' => true,
|
||||
'phpdoc_var_without_name' => true,
|
||||
'pow_to_exponentiation' => true,
|
||||
'protected_to_private' => true,
|
||||
'return_assignment' => true,
|
||||
'return_type_declaration' => ['space_before' => 'none'],
|
||||
'self_accessor' => true,
|
||||
'semicolon_after_instruction' => true,
|
||||
'set_type_to_cast' => true,
|
||||
'short_scalar_cast' => true,
|
||||
'simplified_null_return' => true,
|
||||
'single_blank_line_at_eof' => true,
|
||||
'single_import_per_statement' => true,
|
||||
'single_line_after_imports' => true,
|
||||
'single_quote' => true,
|
||||
'standardize_not_equals' => true,
|
||||
'ternary_to_null_coalescing' => true,
|
||||
'trim_array_spaces' => true,
|
||||
'unary_operator_spaces' => true,
|
||||
'visibility_required' => true,
|
||||
//'void_return' => true,
|
||||
'whitespace_after_comma_in_array' => true,
|
||||
]
|
||||
)
|
||||
->setFinder(
|
||||
PhpCsFixer\Finder::create()
|
||||
->files()
|
||||
->in(__DIR__ . '/src')
|
||||
->in(__DIR__ . '/tests')
|
||||
);
|
||||
33
vendor/sebastian/comparator/.travis.yml
vendored
Normal file
33
vendor/sebastian/comparator/.travis.yml
vendored
Normal file
@ -0,0 +1,33 @@
|
||||
language: php
|
||||
|
||||
sudo: false
|
||||
|
||||
php:
|
||||
- 7.1
|
||||
- 7.2
|
||||
- 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
|
||||
|
||||
59
vendor/sebastian/comparator/ChangeLog.md
vendored
Normal file
59
vendor/sebastian/comparator/ChangeLog.md
vendored
Normal file
@ -0,0 +1,59 @@
|
||||
# ChangeLog
|
||||
|
||||
All notable changes are documented in this file using the [Keep a CHANGELOG](http://keepachangelog.com/) principles.
|
||||
|
||||
## [3.0.2] - 2018-07-12
|
||||
|
||||
### Changed
|
||||
|
||||
* By default, `MockObjectComparator` is now tried before all other (default) comparators
|
||||
|
||||
## [3.0.1] - 2018-06-14
|
||||
|
||||
### Fixed
|
||||
|
||||
* Fixed [#53](https://github.com/sebastianbergmann/comparator/pull/53): `DOMNodeComparator` ignores `$ignoreCase` parameter
|
||||
* Fixed [#58](https://github.com/sebastianbergmann/comparator/pull/58): `ScalarComparator` does not handle extremely ugly string comparison edge cases
|
||||
|
||||
## [3.0.0] - 2018-04-18
|
||||
|
||||
### Fixed
|
||||
|
||||
* Fixed [#48](https://github.com/sebastianbergmann/comparator/issues/48): `DateTimeComparator` does not support fractional second deltas
|
||||
|
||||
### Removed
|
||||
|
||||
* Removed support for PHP 7.0
|
||||
|
||||
## [2.1.3] - 2018-02-01
|
||||
|
||||
### Changed
|
||||
|
||||
* This component is now compatible with version 3 of `sebastian/diff`
|
||||
|
||||
## [2.1.2] - 2018-01-12
|
||||
|
||||
### Fixed
|
||||
|
||||
* Fix comparison of `DateTimeImmutable` objects
|
||||
|
||||
## [2.1.1] - 2017-12-22
|
||||
|
||||
### Fixed
|
||||
|
||||
* Fixed [phpunit/#2923](https://github.com/sebastianbergmann/phpunit/issues/2923): Unexpected failed date matching
|
||||
|
||||
## [2.1.0] - 2017-11-03
|
||||
|
||||
### Added
|
||||
|
||||
* Added `SebastianBergmann\Comparator\Factory::reset()` to unregister all non-default comparators
|
||||
* Added support for `phpunit/phpunit-mock-objects` version `^5.0`
|
||||
|
||||
[3.0.2]: https://github.com/sebastianbergmann/comparator/compare/3.0.1...3.0.2
|
||||
[3.0.1]: https://github.com/sebastianbergmann/comparator/compare/3.0.0...3.0.1
|
||||
[3.0.0]: https://github.com/sebastianbergmann/comparator/compare/2.1.3...3.0.0
|
||||
[2.1.3]: https://github.com/sebastianbergmann/comparator/compare/2.1.2...2.1.3
|
||||
[2.1.2]: https://github.com/sebastianbergmann/comparator/compare/2.1.1...2.1.2
|
||||
[2.1.1]: https://github.com/sebastianbergmann/comparator/compare/2.1.0...2.1.1
|
||||
[2.1.0]: https://github.com/sebastianbergmann/comparator/compare/2.0.2...2.1.0
|
||||
33
vendor/sebastian/comparator/LICENSE
vendored
Normal file
33
vendor/sebastian/comparator/LICENSE
vendored
Normal file
@ -0,0 +1,33 @@
|
||||
Comparator
|
||||
|
||||
Copyright (c) 2002-2018, 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.
|
||||
37
vendor/sebastian/comparator/README.md
vendored
Normal file
37
vendor/sebastian/comparator/README.md
vendored
Normal file
@ -0,0 +1,37 @@
|
||||
[](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";
|
||||
}
|
||||
```
|
||||
|
||||
21
vendor/sebastian/comparator/build.xml
vendored
Normal file
21
vendor/sebastian/comparator/build.xml
vendored
Normal file
@ -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>
|
||||
|
||||
54
vendor/sebastian/comparator/composer.json
vendored
Normal file
54
vendor/sebastian/comparator/composer.json
vendored
Normal file
@ -0,0 +1,54 @@
|
||||
{
|
||||
"name": "sebastian/comparator",
|
||||
"description": "Provides the functionality to compare PHP values for equality",
|
||||
"keywords": ["comparator","compare","equality"],
|
||||
"homepage": "https://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.1",
|
||||
"sebastian/diff": "^3.0",
|
||||
"sebastian/exporter": "^3.1"
|
||||
},
|
||||
"require-dev": {
|
||||
"phpunit/phpunit": "^7.1"
|
||||
},
|
||||
"config": {
|
||||
"optimize-autoloader": true,
|
||||
"sort-packages": true
|
||||
},
|
||||
"autoload": {
|
||||
"classmap": [
|
||||
"src/"
|
||||
]
|
||||
},
|
||||
"autoload-dev": {
|
||||
"classmap": [
|
||||
"tests/_fixture"
|
||||
]
|
||||
},
|
||||
"extra": {
|
||||
"branch-alias": {
|
||||
"dev-master": "3.0-dev"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
21
vendor/sebastian/comparator/phpunit.xml
vendored
Normal file
21
vendor/sebastian/comparator/phpunit.xml
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/7.2/phpunit.xsd"
|
||||
bootstrap="vendor/autoload.php"
|
||||
forceCoversAnnotation="true"
|
||||
beStrictAboutCoversAnnotation="true"
|
||||
beStrictAboutOutputDuringTests="true"
|
||||
beStrictAboutTodoAnnotatedTests="true"
|
||||
verbose="true">
|
||||
<testsuites>
|
||||
<testsuite name="default">
|
||||
<directory suffix="Test.php">tests</directory>
|
||||
</testsuite>
|
||||
</testsuites>
|
||||
|
||||
<filter>
|
||||
<whitelist processUncoveredFilesFromWhitelist="true">
|
||||
<directory suffix=".php">src</directory>
|
||||
</whitelist>
|
||||
</filter>
|
||||
</phpunit>
|
||||
130
vendor/sebastian/comparator/src/ArrayComparator.php
vendored
Normal file
130
vendor/sebastian/comparator/src/ArrayComparator.php
vendored
Normal file
@ -0,0 +1,130 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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));
|
||||
}
|
||||
}
|
||||
61
vendor/sebastian/comparator/src/Comparator.php
vendored
Normal file
61
vendor/sebastian/comparator/src/Comparator.php
vendored
Normal file
@ -0,0 +1,61 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
128
vendor/sebastian/comparator/src/ComparisonFailure.php
vendored
Normal file
128
vendor/sebastian/comparator/src/ComparisonFailure.php
vendored
Normal file
@ -0,0 +1,128 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
}
|
||||
|
||||
public function getActual()
|
||||
{
|
||||
return $this->actual;
|
||||
}
|
||||
|
||||
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();
|
||||
}
|
||||
}
|
||||
86
vendor/sebastian/comparator/src/DOMNodeComparator.php
vendored
Normal file
86
vendor/sebastian/comparator/src/DOMNodeComparator.php
vendored
Normal file
@ -0,0 +1,86 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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 ? \strtolower($text) : $text;
|
||||
}
|
||||
}
|
||||
86
vendor/sebastian/comparator/src/DateTimeComparator.php
vendored
Normal file
86
vendor/sebastian/comparator/src/DateTimeComparator.php
vendored
Normal file
@ -0,0 +1,86 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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 \Exception
|
||||
* @throws ComparisonFailure
|
||||
*/
|
||||
public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])
|
||||
{
|
||||
/** @var \DateTimeInterface $expected */
|
||||
/** @var \DateTimeInterface $actual */
|
||||
$absDelta = \abs($delta);
|
||||
$delta = new \DateInterval(\sprintf('PT%dS', $absDelta));
|
||||
$delta->f = $absDelta - \floor($absDelta);
|
||||
|
||||
$actualClone = (clone $actual)
|
||||
->setTimezone(new \DateTimeZone('UTC'));
|
||||
|
||||
$expectedLower = (clone $expected)
|
||||
->setTimezone(new \DateTimeZone('UTC'))
|
||||
->sub($delta);
|
||||
|
||||
$expectedUpper = (clone $expected)
|
||||
->setTimezone(new \DateTimeZone('UTC'))
|
||||
->add($delta);
|
||||
|
||||
if ($actualClone < $expectedLower || $actualClone > $expectedUpper) {
|
||||
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';
|
||||
}
|
||||
}
|
||||
56
vendor/sebastian/comparator/src/DoubleComparator.php
vendored
Normal file
56
vendor/sebastian/comparator/src/DoubleComparator.php
vendored
Normal file
@ -0,0 +1,56 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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);
|
||||
}
|
||||
}
|
||||
52
vendor/sebastian/comparator/src/ExceptionComparator.php
vendored
Normal file
52
vendor/sebastian/comparator/src/ExceptionComparator.php
vendored
Normal file
@ -0,0 +1,52 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
}
|
||||
}
|
||||
138
vendor/sebastian/comparator/src/Factory.php
vendored
Normal file
138
vendor/sebastian/comparator/src/Factory.php
vendored
Normal file
@ -0,0 +1,138 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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 Factory
|
||||
*/
|
||||
private static $instance;
|
||||
|
||||
/**
|
||||
* @var Comparator[]
|
||||
*/
|
||||
private $customComparators = [];
|
||||
|
||||
/**
|
||||
* @var Comparator[]
|
||||
*/
|
||||
private $defaultComparators = [];
|
||||
|
||||
/**
|
||||
* @return Factory
|
||||
*/
|
||||
public static function getInstance()
|
||||
{
|
||||
if (self::$instance === null) {
|
||||
self::$instance = new self;
|
||||
}
|
||||
|
||||
return self::$instance;
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a new factory.
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
$this->registerDefaultComparators();
|
||||
}
|
||||
|
||||
/**
|
||||
* 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->customComparators as $comparator) {
|
||||
if ($comparator->accepts($expected, $actual)) {
|
||||
return $comparator;
|
||||
}
|
||||
}
|
||||
|
||||
foreach ($this->defaultComparators as $comparator) {
|
||||
if ($comparator->accepts($expected, $actual)) {
|
||||
return $comparator;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a new comparator.
|
||||
*
|
||||
* This comparator will be returned by getComparatorFor() 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 invoked
|
||||
* before those of the other comparators.
|
||||
*
|
||||
* @param Comparator $comparator The comparator to be registered
|
||||
*/
|
||||
public function register(Comparator $comparator)
|
||||
{
|
||||
\array_unshift($this->customComparators, $comparator);
|
||||
|
||||
$comparator->setFactory($this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregisters a comparator.
|
||||
*
|
||||
* This comparator will no longer be considered by getComparatorFor().
|
||||
*
|
||||
* @param Comparator $comparator The comparator to be unregistered
|
||||
*/
|
||||
public function unregister(Comparator $comparator)
|
||||
{
|
||||
foreach ($this->customComparators as $key => $_comparator) {
|
||||
if ($comparator === $_comparator) {
|
||||
unset($this->customComparators[$key]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregisters all non-default comparators.
|
||||
*/
|
||||
public function reset()
|
||||
{
|
||||
$this->customComparators = [];
|
||||
}
|
||||
|
||||
private function registerDefaultComparators()
|
||||
{
|
||||
$this->registerDefaultComparator(new MockObjectComparator);
|
||||
$this->registerDefaultComparator(new DateTimeComparator);
|
||||
$this->registerDefaultComparator(new DOMNodeComparator);
|
||||
$this->registerDefaultComparator(new SplObjectStorageComparator);
|
||||
$this->registerDefaultComparator(new ExceptionComparator);
|
||||
$this->registerDefaultComparator(new ObjectComparator);
|
||||
$this->registerDefaultComparator(new ResourceComparator);
|
||||
$this->registerDefaultComparator(new ArrayComparator);
|
||||
$this->registerDefaultComparator(new DoubleComparator);
|
||||
$this->registerDefaultComparator(new NumericComparator);
|
||||
$this->registerDefaultComparator(new ScalarComparator);
|
||||
$this->registerDefaultComparator(new TypeComparator);
|
||||
}
|
||||
|
||||
private function registerDefaultComparator(Comparator $comparator)
|
||||
{
|
||||
$this->defaultComparators[] = $comparator;
|
||||
|
||||
$comparator->setFactory($this);
|
||||
}
|
||||
}
|
||||
47
vendor/sebastian/comparator/src/MockObjectComparator.php
vendored
Normal file
47
vendor/sebastian/comparator/src/MockObjectComparator.php
vendored
Normal file
@ -0,0 +1,47 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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 || $expected instanceof \PHPUnit\Framework\MockObject\MockObject) &&
|
||||
($actual 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;
|
||||
}
|
||||
}
|
||||
68
vendor/sebastian/comparator/src/NumericComparator.php
vendored
Normal file
68
vendor/sebastian/comparator/src/NumericComparator.php
vendored
Normal file
@ -0,0 +1,68 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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; // @codeCoverageIgnore
|
||||
}
|
||||
|
||||
if ((\is_infinite($actual) xor \is_infinite($expected)) ||
|
||||
(\is_nan($actual) || \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)
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
106
vendor/sebastian/comparator/src/ObjectComparator.php
vendored
Normal file
106
vendor/sebastian/comparator/src/ObjectComparator.php
vendored
Normal file
@ -0,0 +1,106 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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);
|
||||
}
|
||||
}
|
||||
52
vendor/sebastian/comparator/src/ResourceComparator.php
vendored
Normal file
52
vendor/sebastian/comparator/src/ResourceComparator.php
vendored
Normal file
@ -0,0 +1,52 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
91
vendor/sebastian/comparator/src/ScalarComparator.php
vendored
Normal file
91
vendor/sebastian/comparator/src/ScalarComparator.php
vendored
Normal file
@ -0,0 +1,91 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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 && \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.'
|
||||
);
|
||||
}
|
||||
|
||||
if ($expectedToCompare != $actualToCompare) {
|
||||
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)
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
69
vendor/sebastian/comparator/src/SplObjectStorageComparator.php
vendored
Normal file
69
vendor/sebastian/comparator/src/SplObjectStorageComparator.php
vendored
Normal file
@ -0,0 +1,69 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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.'
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
59
vendor/sebastian/comparator/src/TypeComparator.php
vendored
Normal file
59
vendor/sebastian/comparator/src/TypeComparator.php
vendored
Normal file
@ -0,0 +1,59 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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)
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
161
vendor/sebastian/comparator/tests/ArrayComparatorTest.php
vendored
Normal file
161
vendor/sebastian/comparator/tests/ArrayComparatorTest.php
vendored
Normal file
@ -0,0 +1,161 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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\ArrayComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class ArrayComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var ArrayComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
public function testAcceptsSucceeds(): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts([], [])
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsFailsProvider
|
||||
*/
|
||||
public function testAcceptsFails($expected, $actual): void
|
||||
{
|
||||
$this->assertFalse(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0, $canonicalize = false): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta, $canonicalize);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $delta = 0.0, $canonicalize = false): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('Failed asserting that two arrays are equal');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta, $canonicalize);
|
||||
}
|
||||
}
|
||||
59
vendor/sebastian/comparator/tests/ComparisonFailureTest.php
vendored
Normal file
59
vendor/sebastian/comparator/tests/ComparisonFailureTest.php
vendored
Normal file
@ -0,0 +1,59 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
*/
|
||||
final class ComparisonFailureTest extends TestCase
|
||||
{
|
||||
public function testComparisonFailure(): void
|
||||
{
|
||||
$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(): void
|
||||
{
|
||||
$failure = new ComparisonFailure('a', 'b', false, false, true, 'test');
|
||||
$this->assertSame('', $failure->getDiff());
|
||||
$this->assertSame('test', $failure->toString());
|
||||
}
|
||||
}
|
||||
180
vendor/sebastian/comparator/tests/DOMNodeComparatorTest.php
vendored
Normal file
180
vendor/sebastian/comparator/tests/DOMNodeComparatorTest.php
vendored
Normal file
@ -0,0 +1,180 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* @covers \SebastianBergmann\Comparator\DOMNodeComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class DOMNodeComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var DOMNodeComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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>')
|
||||
],
|
||||
[
|
||||
$this->createDOMDocument('<Root></Root>'),
|
||||
$this->createDOMDocument('<root></root>'),
|
||||
$ignoreCase = true
|
||||
],
|
||||
[
|
||||
$this->createDOMDocument("<a x='' a=''/>"),
|
||||
$this->createDOMDocument("<a a='' x=''/>"),
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
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>')
|
||||
],
|
||||
[
|
||||
$this->createDOMDocument('<Root></Root>'),
|
||||
$this->createDOMDocument('<root></root>')
|
||||
],
|
||||
[
|
||||
$this->createDOMDocument('<root> bar </root>'),
|
||||
$this->createDOMDocument('<root> BAR </root>')
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsSucceedsProvider
|
||||
*/
|
||||
public function testAcceptsSucceeds($expected, $actual): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsFailsProvider
|
||||
*/
|
||||
public function testAcceptsFails($expected, $actual): void
|
||||
{
|
||||
$this->assertFalse(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual, $ignoreCase = false): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$delta = 0.0;
|
||||
$canonicalize = false;
|
||||
$this->comparator->assertEquals($expected, $actual, $delta, $canonicalize, $ignoreCase);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('Failed asserting that two DOM');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
|
||||
private function createDOMDocument($content)
|
||||
{
|
||||
$document = new DOMDocument;
|
||||
$document->preserveWhiteSpace = false;
|
||||
$document->loadXML($content);
|
||||
|
||||
return $document;
|
||||
}
|
||||
}
|
||||
213
vendor/sebastian/comparator/tests/DateTimeComparatorTest.php
vendored
Normal file
213
vendor/sebastian/comparator/tests/DateTimeComparatorTest.php
vendored
Normal file
@ -0,0 +1,213 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
|
||||
/**
|
||||
* @covers \SebastianBergmann\Comparator\DateTimeComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class DateTimeComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var DateTimeComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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: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')
|
||||
],
|
||||
[
|
||||
new DateTimeImmutable('2013-03-30', new DateTimeZone('America/New_York')),
|
||||
new DateTimeImmutable('2013-03-29 23:01:30', new DateTimeZone('America/Chicago')),
|
||||
100
|
||||
],
|
||||
[
|
||||
new DateTimeImmutable('2013-03-30 12:00:00', new DateTimeZone('UTC')),
|
||||
new DateTimeImmutable('2013-03-30 12:00:00.5', new DateTimeZone('UTC')),
|
||||
0.5
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
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')
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
public function testAcceptsSucceeds(): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts(
|
||||
new DateTime,
|
||||
new DateTime
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsFailsProvider
|
||||
*/
|
||||
public function testAcceptsFails($expected, $actual): void
|
||||
{
|
||||
$this->assertFalse(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $delta = 0.0): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('Failed asserting that two DateTime objects are equal.');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
|
||||
public function testAcceptsDateTimeInterface(): void
|
||||
{
|
||||
$this->assertTrue($this->comparator->accepts(new DateTime, new DateTimeImmutable));
|
||||
}
|
||||
|
||||
public function testSupportsDateTimeInterface(): void
|
||||
{
|
||||
$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'))
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
135
vendor/sebastian/comparator/tests/DoubleComparatorTest.php
vendored
Normal file
135
vendor/sebastian/comparator/tests/DoubleComparatorTest.php
vendored
Normal file
@ -0,0 +1,135 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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\DoubleComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class DoubleComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var DoubleComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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)]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsSucceedsProvider
|
||||
*/
|
||||
public function testAcceptsSucceeds($expected, $actual): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsFailsProvider
|
||||
*/
|
||||
public function testAcceptsFails($expected, $actual): void
|
||||
{
|
||||
$this->assertFalse(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $delta = 0.0): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('matches expected');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
}
|
||||
136
vendor/sebastian/comparator/tests/ExceptionComparatorTest.php
vendored
Normal file
136
vendor/sebastian/comparator/tests/ExceptionComparatorTest.php
vendored
Normal file
@ -0,0 +1,136 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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 PHPUnit\Framework\TestCase;
|
||||
use RuntimeException;
|
||||
|
||||
/**
|
||||
* @covers \SebastianBergmann\Comparator\ExceptionComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class ExceptionComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var ExceptionComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsSucceedsProvider
|
||||
*/
|
||||
public function testAcceptsSucceeds($expected, $actual): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsFailsProvider
|
||||
*/
|
||||
public function testAcceptsFails($expected, $actual): void
|
||||
{
|
||||
$this->assertFalse(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $message): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage($message);
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
}
|
||||
117
vendor/sebastian/comparator/tests/FactoryTest.php
vendored
Normal file
117
vendor/sebastian/comparator/tests/FactoryTest.php
vendored
Normal file
@ -0,0 +1,117 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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\Factory
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final 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
|
||||
*/
|
||||
public function testGetComparatorFor($a, $b, $expected): void
|
||||
{
|
||||
$factory = new Factory;
|
||||
$actual = $factory->getComparatorFor($a, $b);
|
||||
$this->assertInstanceOf($expected, $actual);
|
||||
}
|
||||
|
||||
public function testRegister(): void
|
||||
{
|
||||
$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);
|
||||
}
|
||||
|
||||
public function testUnregister(): void
|
||||
{
|
||||
$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(): void
|
||||
{
|
||||
$f = Factory::getInstance();
|
||||
$this->assertSame($f, Factory::getInstance());
|
||||
}
|
||||
}
|
||||
168
vendor/sebastian/comparator/tests/MockObjectComparatorTest.php
vendored
Normal file
168
vendor/sebastian/comparator/tests/MockObjectComparatorTest.php
vendored
Normal file
@ -0,0 +1,168 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
|
||||
/**
|
||||
* @covers \SebastianBergmann\Comparator\MockObjectComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class MockObjectComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var MockObjectComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsSucceedsProvider
|
||||
*/
|
||||
public function testAcceptsSucceeds($expected, $actual): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsFailsProvider
|
||||
*/
|
||||
public function testAcceptsFails($expected, $actual): void
|
||||
{
|
||||
$this->assertFalse(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage($message);
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
}
|
||||
123
vendor/sebastian/comparator/tests/NumericComparatorTest.php
vendored
Normal file
123
vendor/sebastian/comparator/tests/NumericComparatorTest.php
vendored
Normal file
@ -0,0 +1,123 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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\NumericComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class NumericComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var NumericComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsSucceedsProvider
|
||||
*/
|
||||
public function testAcceptsSucceeds($expected, $actual): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsFailsProvider
|
||||
*/
|
||||
public function testAcceptsFails($expected, $actual): void
|
||||
{
|
||||
$this->assertFalse(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $delta = 0.0): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('matches expected');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
}
|
||||
150
vendor/sebastian/comparator/tests/ObjectComparatorTest.php
vendored
Normal file
150
vendor/sebastian/comparator/tests/ObjectComparatorTest.php
vendored
Normal file
@ -0,0 +1,150 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
|
||||
/**
|
||||
* @covers \SebastianBergmann\Comparator\ObjectComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class ObjectComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var ObjectComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsSucceedsProvider
|
||||
*/
|
||||
public function testAcceptsSucceeds($expected, $actual): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsFailsProvider
|
||||
*/
|
||||
public function testAcceptsFails($expected, $actual): void
|
||||
{
|
||||
$this->assertFalse(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage($message);
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
}
|
||||
122
vendor/sebastian/comparator/tests/ResourceComparatorTest.php
vendored
Normal file
122
vendor/sebastian/comparator/tests/ResourceComparatorTest.php
vendored
Normal file
@ -0,0 +1,122 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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\ResourceComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class ResourceComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var ResourceComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsSucceedsProvider
|
||||
*/
|
||||
public function testAcceptsSucceeds($expected, $actual): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsFailsProvider
|
||||
*/
|
||||
public function testAcceptsFails($expected, $actual): void
|
||||
{
|
||||
$this->assertFalse(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
}
|
||||
164
vendor/sebastian/comparator/tests/ScalarComparatorTest.php
vendored
Normal file
164
vendor/sebastian/comparator/tests/ScalarComparatorTest.php
vendored
Normal file
@ -0,0 +1,164 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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\ScalarComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class ScalarComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var ScalarComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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],
|
||||
['0', '0.0', $stringException],
|
||||
['0.', '0.0', $stringException],
|
||||
['0e1', '0e2', $stringException],
|
||||
["\n\n\n0.0", ' 0.', $stringException],
|
||||
['0.0', '25e-10000', $stringException],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsSucceedsProvider
|
||||
*/
|
||||
public function testAcceptsSucceeds($expected, $actual): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsFailsProvider
|
||||
*/
|
||||
public function testAcceptsFails($expected, $actual): void
|
||||
{
|
||||
$this->assertFalse(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual, $ignoreCase = false): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, 0.0, false, $ignoreCase);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $message): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage($message);
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
}
|
||||
145
vendor/sebastian/comparator/tests/SplObjectStorageComparatorTest.php
vendored
Normal file
145
vendor/sebastian/comparator/tests/SplObjectStorageComparatorTest.php
vendored
Normal file
@ -0,0 +1,145 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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 SplObjectStorage;
|
||||
use stdClass;
|
||||
|
||||
/**
|
||||
* @covers \SebastianBergmann\Comparator\SplObjectStorageComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class SplObjectStorageComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var SplObjectStorageComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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],
|
||||
];
|
||||
}
|
||||
|
||||
public function testAcceptsSucceeds(): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts(
|
||||
new SplObjectStorage,
|
||||
new SplObjectStorage
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsFailsProvider
|
||||
*/
|
||||
public function testAcceptsFails($expected, $actual): void
|
||||
{
|
||||
$this->assertFalse(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('Failed asserting that two objects are equal.');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
|
||||
public function testAssertEqualsFails2(): void
|
||||
{
|
||||
$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());
|
||||
}
|
||||
}
|
||||
107
vendor/sebastian/comparator/tests/TypeComparatorTest.php
vendored
Normal file
107
vendor/sebastian/comparator/tests/TypeComparatorTest.php
vendored
Normal file
@ -0,0 +1,107 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
|
||||
/**
|
||||
* @covers \SebastianBergmann\Comparator\TypeComparator<extended>
|
||||
*
|
||||
* @uses \SebastianBergmann\Comparator\Comparator
|
||||
* @uses \SebastianBergmann\Comparator\Factory
|
||||
* @uses \SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
final class TypeComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var TypeComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$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]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider acceptsSucceedsProvider
|
||||
*/
|
||||
public function testAcceptsSucceeds($expected, $actual): void
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts($expected, $actual)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsSucceedsProvider
|
||||
*/
|
||||
public function testAssertEqualsSucceeds($expected, $actual): void
|
||||
{
|
||||
$exception = null;
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual): void
|
||||
{
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('does not match expected type');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
}
|
||||
26
vendor/sebastian/comparator/tests/_fixture/Author.php
vendored
Normal file
26
vendor/sebastian/comparator/tests/_fixture/Author.php
vendored
Normal file
@ -0,0 +1,26 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
}
|
||||
}
|
||||
19
vendor/sebastian/comparator/tests/_fixture/Book.php
vendored
Normal file
19
vendor/sebastian/comparator/tests/_fixture/Book.php
vendored
Normal file
@ -0,0 +1,19 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
}
|
||||
18
vendor/sebastian/comparator/tests/_fixture/ClassWithToString.php
vendored
Normal file
18
vendor/sebastian/comparator/tests/_fixture/ClassWithToString.php
vendored
Normal file
@ -0,0 +1,18 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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';
|
||||
}
|
||||
}
|
||||
29
vendor/sebastian/comparator/tests/_fixture/SampleClass.php
vendored
Normal file
29
vendor/sebastian/comparator/tests/_fixture/SampleClass.php
vendored
Normal file
@ -0,0 +1,29 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
}
|
||||
}
|
||||
23
vendor/sebastian/comparator/tests/_fixture/Struct.php
vendored
Normal file
23
vendor/sebastian/comparator/tests/_fixture/Struct.php
vendored
Normal file
@ -0,0 +1,23 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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;
|
||||
}
|
||||
}
|
||||
14
vendor/sebastian/comparator/tests/_fixture/TestClass.php
vendored
Normal file
14
vendor/sebastian/comparator/tests/_fixture/TestClass.php
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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
|
||||
{
|
||||
}
|
||||
14
vendor/sebastian/comparator/tests/_fixture/TestClassComparator.php
vendored
Normal file
14
vendor/sebastian/comparator/tests/_fixture/TestClassComparator.php
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of sebastian/comparator.
|
||||
*
|
||||
* (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
|
||||
{
|
||||
}
|
||||
Reference in New Issue
Block a user