pax_global_header00006660000000000000000000000064137677153710014533gustar00rootroot0000000000000052 comment=b2e4b1d7e2baac487f95b6e3c75597ce4614d4fe phpunit-comparator-4.0.6/000077500000000000000000000000001376771537100153765ustar00rootroot00000000000000phpunit-comparator-4.0.6/.github/000077500000000000000000000000001376771537100167365ustar00rootroot00000000000000phpunit-comparator-4.0.6/.github/FUNDING.yml000066400000000000000000000000321376771537100205460ustar00rootroot00000000000000github: sebastianbergmann phpunit-comparator-4.0.6/.github/workflows/000077500000000000000000000000001376771537100207735ustar00rootroot00000000000000phpunit-comparator-4.0.6/.github/workflows/ci.yml000066400000000000000000000052441376771537100221160ustar00rootroot00000000000000# https://help.github.com/en/categories/automating-your-workflow-with-github-actions on: - "pull_request" - "push" name: "CI" jobs: coding-guidelines: name: "Coding Guidelines" runs-on: "ubuntu-latest" steps: - name: "Checkout" uses: "actions/checkout@v2" - name: "Run friendsofphp/php-cs-fixer" run: "php7.4 ./tools/php-cs-fixer fix --diff-format=udiff --dry-run --show-progress=dots --using-cache=no --verbose" type-checker: name: "Type Checker" runs-on: "ubuntu-latest" steps: - name: "Checkout" uses: "actions/checkout@v2" - name: "Update dependencies with composer" run: "php7.4 ./tools/composer update --no-ansi --no-interaction --no-progress" - name: "Run vimeo/psalm" run: "php7.4 ./tools/psalm --config=.psalm/config.xml --no-progress --shepherd --show-info=false --stats" backward-compatibility: name: Backward Compatibility runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v2 with: fetch-depth: 0 - name: Fetch tags run: git fetch --depth=1 origin +refs/tags/*:refs/tags/* - name: Install PHP with extensions uses: shivammathur/setup-php@v2 with: php-version: 7.4 coverage: none extensions: intl - name: Run roave/backward-compatibility-check run: ./tools/roave-backward-compatibility-check --from=4.0.0 tests: name: "Tests" runs-on: "ubuntu-latest" strategy: fail-fast: false matrix: php-version: - "7.3" - "7.4" - "8.0" - "8.1" steps: - name: "Checkout" uses: "actions/checkout@v2" - name: "Install PHP with extensions" uses: "shivammathur/setup-php@v2" with: php-version: "${{ matrix.php-version }}" coverage: "pcov" - name: "Cache dependencies installed with composer" uses: "actions/cache@v1" with: path: "~/.composer/cache" key: "php${{ matrix.php-version }}-composer-${{ matrix.dependencies }}-${{ hashFiles('**/composer.json') }}" restore-keys: "php${{ matrix.php-version }}-composer-${{ matrix.dependencies }}-" - name: "Install dependencies with composer" run: "./tools/composer update --no-ansi --no-interaction --no-progress" - name: "Run tests with phpunit/phpunit" run: "vendor/bin/phpunit --coverage-clover=coverage.xml" - name: "Send code coverage report to Codecov.io" env: CODECOV_TOKEN: "${{ secrets.CODECOV_TOKEN }}" run: "bash <(curl -s https://codecov.io/bash) || true" phpunit-comparator-4.0.6/.gitignore000066400000000000000000000001331376771537100173630ustar00rootroot00000000000000/.idea /.php_cs /.php_cs.cache /.phpunit.result.cache /.psalm/cache /composer.lock /vendor phpunit-comparator-4.0.6/.phive/000077500000000000000000000000001376771537100165675ustar00rootroot00000000000000phpunit-comparator-4.0.6/.phive/phars.xml000066400000000000000000000006671376771537100204370ustar00rootroot00000000000000 phpunit-comparator-4.0.6/.php_cs.dist000066400000000000000000000173751376771537100176320ustar00rootroot00000000000000 For the full copyright and license information, please view the LICENSE file that was distributed with this source code. EOF; $finder = PhpCsFixer\Finder::create() ->files() ->in(__DIR__ . '/src') ->in(__DIR__ . '/tests'); return PhpCsFixer\Config::create() ->setFinder($finder) ->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'], 'declare_strict_types' => true, 'dir_constant' => true, 'elseif' => true, 'encoding' => true, 'full_opening_tag' => true, 'function_declaration' => true, 'global_namespace_import' => [ 'import_classes' => true, 'import_constants' => true, 'import_functions' => 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' => false, 'native_function_casing' => false, 'native_function_invocation' => false, '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' => [ 'allow_mixed' => 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' => [ 'imports_order' => [ PhpCsFixer\Fixer\Import\OrderedImportsFixer::IMPORT_TYPE_CONST, PhpCsFixer\Fixer\Import\OrderedImportsFixer::IMPORT_TYPE_FUNCTION, PhpCsFixer\Fixer\Import\OrderedImportsFixer::IMPORT_TYPE_CLASS, ] ], 'ordered_interfaces' => [ 'direction' => 'ascend', 'order' => 'alpha', ], 'phpdoc_add_missing_param_annotation' => false, '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_summary' => true, 'phpdoc_to_comment' => true, 'phpdoc_trim' => true, 'phpdoc_trim_consecutive_blank_line_separation' => true, 'phpdoc_types' => ['groups' => ['simple', 'meta']], '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' => false, '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, 'trailing_comma_in_multiline_array' => true, 'trim_array_spaces' => true, 'unary_operator_spaces' => true, 'visibility_required' => [ 'elements' => [ 'const', 'method', 'property', ], ], 'void_return' => false, 'whitespace_after_comma_in_array' => true, ]); phpunit-comparator-4.0.6/.psalm/000077500000000000000000000000001376771537100165705ustar00rootroot00000000000000phpunit-comparator-4.0.6/.psalm/baseline.xml000066400000000000000000000114161376771537100210770ustar00rootroot00000000000000 $lines assertEquals indent ArrayComparator assertEquals assertEquals setFactory $factory getActual getExpected $identical assertEquals $document normalizeDocument DOMNodeComparator assertEquals DateTimeComparator setTimezone assertEquals DoubleComparator ExceptionComparator self::$instance === null register reset unregister MockObjectComparator $value $value assertEquals NumericComparator is_float($actual) is_float($expected) assertEquals ObjectComparator assertEquals ResourceComparator assertEquals ScalarComparator assertEquals SplObjectStorageComparator assertEquals TypeComparator phpunit-comparator-4.0.6/.psalm/config.xml000066400000000000000000000010151376771537100205540ustar00rootroot00000000000000 phpunit-comparator-4.0.6/ChangeLog.md000066400000000000000000000061721376771537100175550ustar00rootroot00000000000000# ChangeLog All notable changes are documented in this file using the [Keep a CHANGELOG](http://keepachangelog.com/) principles. ## [4.0.6] - 2020-10-26 ### Fixed * `SebastianBergmann\Comparator\Exception` now correctly extends `\Throwable` ## [4.0.5] - 2020-09-30 ### Fixed * [#89](https://github.com/sebastianbergmann/comparator/pull/89): Handle PHP 8 `ValueError` ## [4.0.4] - 2020-09-28 ### Changed * Changed PHP version constraint in `composer.json` from `^7.3 || ^8.0` to `>=7.3` ## [4.0.3] - 2020-06-26 ### Added * This component is now supported on PHP 8 ## [4.0.2] - 2020-06-15 ### Fixed * [#85](https://github.com/sebastianbergmann/comparator/issues/85): Version 4.0.1 breaks backward compatibility ## [4.0.1] - 2020-06-15 ### Changed * Tests etc. are now ignored for archive exports ## [4.0.0] - 2020-02-07 ### Removed * Removed support for PHP 7.1 and PHP 7.2 ## [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 * [#53](https://github.com/sebastianbergmann/comparator/pull/53): `DOMNodeComparator` ignores `$ignoreCase` parameter * [#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` [4.0.6]: https://github.com/sebastianbergmann/comparator/compare/4.0.5...4.0.6 [4.0.5]: https://github.com/sebastianbergmann/comparator/compare/4.0.4...4.0.5 [4.0.4]: https://github.com/sebastianbergmann/comparator/compare/4.0.3...4.0.4 [4.0.3]: https://github.com/sebastianbergmann/comparator/compare/4.0.2...4.0.3 [4.0.2]: https://github.com/sebastianbergmann/comparator/compare/4.0.1...4.0.2 [4.0.1]: https://github.com/sebastianbergmann/comparator/compare/4.0.0...4.0.1 [4.0.0]: https://github.com/sebastianbergmann/comparator/compare/3.0.2...4.0.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 phpunit-comparator-4.0.6/LICENSE000066400000000000000000000030111376771537100163760ustar00rootroot00000000000000Comparator Copyright (c) 2002-2020, Sebastian Bergmann . 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. phpunit-comparator-4.0.6/README.md000066400000000000000000000024401376771537100166550ustar00rootroot00000000000000# sebastian/comparator [![CI Status](https://github.com/sebastianbergmann/comparator/workflows/CI/badge.svg)](https://github.com/sebastianbergmann/comparator/actions) [![Type Coverage](https://shepherd.dev/github/sebastianbergmann/comparator/coverage.svg)](https://shepherd.dev/github/sebastianbergmann/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 getComparatorFor($date1, $date2); try { $comparator->assertEquals($date1, $date2); print "Dates match"; } catch (ComparisonFailure $failure) { print "Dates don't match"; } ``` phpunit-comparator-4.0.6/build.xml000066400000000000000000000021541376771537100172210ustar00rootroot00000000000000 phpunit-comparator-4.0.6/composer.json000066400000000000000000000024661376771537100201300ustar00rootroot00000000000000{ "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.3", "sebastian/diff": "^4.0", "sebastian/exporter": "^4.0" }, "require-dev": { "phpunit/phpunit": "^9.3" }, "config": { "platform": { "php": "7.3.0" }, "optimize-autoloader": true, "sort-packages": true }, "autoload": { "classmap": [ "src/" ] }, "autoload-dev": { "classmap": [ "tests/_fixture" ] }, "extra": { "branch-alias": { "dev-master": "4.0-dev" } } } phpunit-comparator-4.0.6/phpunit.xml000066400000000000000000000015121376771537100176060ustar00rootroot00000000000000 tests src phpunit-comparator-4.0.6/src/000077500000000000000000000000001376771537100161655ustar00rootroot00000000000000phpunit-comparator-4.0.6/src/ArrayComparator.php000066400000000000000000000107051376771537100220070ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function array_key_exists; use function is_array; use function sort; use function sprintf; use function str_replace; use function trim; /** * Compares arrays for equality. * * Arrays are equal if they contain the same key-value pairs. * The order of the keys does not matter. * The types of key-value pairs do not matter. */ 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 arrays 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 = [])/*: void*/ { 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)); } } phpunit-comparator-4.0.6/src/Comparator.php000066400000000000000000000031771376771537100210150ustar00rootroot00000000000000 * * 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)/*: void*/ { $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); } phpunit-comparator-4.0.6/src/ComparisonFailure.php000066400000000000000000000057351376771537100223320ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use RuntimeException; 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(); } } phpunit-comparator-4.0.6/src/DOMNodeComparator.php000066400000000000000000000056221376771537100221600ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function sprintf; use function strtolower; use DOMDocument; use DOMNode; use ValueError; /** * 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 = [])/*: void*/ { $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; try { @$document->loadXML($node->C14N()); } catch (ValueError $e) { } $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; } } phpunit-comparator-4.0.6/src/DateTimeComparator.php000066400000000000000000000061651376771537100224320ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function abs; use function floor; use function sprintf; use DateInterval; use DateTime; use DateTimeInterface; use DateTimeZone; use Exception; /** * 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 = [])/*: void*/ { /** @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'; } } phpunit-comparator-4.0.6/src/DoubleComparator.php000066400000000000000000000033131376771537100221400ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function is_float; use function is_numeric; /** * Compares doubles for equality. */ class DoubleComparator extends NumericComparator { /** * Smallest value available in PHP. * * @var float */ public 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)/*: void*/ { if ($delta == 0) { $delta = self::EPSILON; } parent::assertEquals($expected, $actual, $delta, $canonicalize, $ignoreCase); } } phpunit-comparator-4.0.6/src/ExceptionComparator.php000066400000000000000000000024061376771537100226660ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use Exception; /** * 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; } } phpunit-comparator-4.0.6/src/Factory.php000066400000000000000000000077271376771537100203220ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function array_unshift; /** * 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; // @codeCoverageIgnore } 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; } } throw new RuntimeException('No suitable Comparator implementation found'); } /** * 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)/*: void*/ { 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)/*: void*/ { foreach ($this->customComparators as $key => $_comparator) { if ($comparator === $_comparator) { unset($this->customComparators[$key]); } } } /** * Unregisters all non-default comparators. */ public function reset()/*: void*/ { $this->customComparators = []; } private function registerDefaultComparators(): void { $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): void { $this->defaultComparators[] = $comparator; $comparator->setFactory($this); } } phpunit-comparator-4.0.6/src/MockObjectComparator.php000066400000000000000000000023101376771537100227420ustar00rootroot00000000000000 * * 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\MockObject\MockObject; /** * 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 MockObject && $actual instanceof 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; } } phpunit-comparator-4.0.6/src/NumericComparator.php000066400000000000000000000051721376771537100223350ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function abs; use function is_float; use function is_infinite; use function is_nan; use function is_numeric; use function is_string; use function sprintf; /** * 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)/*: void*/ { if ($this->isInfinite($actual) && $this->isInfinite($expected)) { return; } if (($this->isInfinite($actual) xor $this->isInfinite($expected)) || ($this->isNan($actual) || $this->isNan($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) ) ); } } private function isInfinite($value): bool { return is_float($value) && is_infinite($value); } private function isNan($value): bool { return is_float($value) && is_nan($value); } } phpunit-comparator-4.0.6/src/ObjectComparator.php000066400000000000000000000072521376771537100221420ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function get_class; use function in_array; use function is_object; use function sprintf; use function substr_replace; /** * 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 = [])/*: void*/ { 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); } } phpunit-comparator-4.0.6/src/ResourceComparator.php000066400000000000000000000031521376771537100225160ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function is_resource; /** * 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)/*: void*/ { if ($actual != $expected) { throw new ComparisonFailure( $expected, $actual, $this->exporter->export($expected), $this->exporter->export($actual) ); } } } phpunit-comparator-4.0.6/src/ScalarComparator.php000066400000000000000000000064721376771537100221440ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function is_object; use function is_scalar; use function is_string; use function method_exists; use function sprintf; use function strtolower; /** * 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)/*: void*/ { $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) ) ); } } } phpunit-comparator-4.0.6/src/SplObjectStorageComparator.php000066400000000000000000000044201376771537100241400ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use SplObjectStorage; /** * 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)/*: void*/ { 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.' ); } } } } phpunit-comparator-4.0.6/src/TypeComparator.php000066400000000000000000000034621376771537100216540ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function gettype; use function sprintf; /** * 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)/*: void*/ { 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) ) ); } } } phpunit-comparator-4.0.6/src/exceptions/000077500000000000000000000000001376771537100203465ustar00rootroot00000000000000phpunit-comparator-4.0.6/src/exceptions/Exception.php000066400000000000000000000005551376771537100230220ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use Throwable; interface Exception extends Throwable { } phpunit-comparator-4.0.6/src/exceptions/RuntimeException.php000066400000000000000000000006031376771537100243600ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; final class RuntimeException extends \RuntimeException implements Exception { } phpunit-comparator-4.0.6/tests/000077500000000000000000000000001376771537100165405ustar00rootroot00000000000000phpunit-comparator-4.0.6/tests/ArrayComparatorTest.php000066400000000000000000000073071376771537100232260ustar00rootroot00000000000000 * * 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 * * @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); } } phpunit-comparator-4.0.6/tests/ComparisonFailureTest.php000066400000000000000000000030401376771537100235300ustar00rootroot00000000000000 * * 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()); } } phpunit-comparator-4.0.6/tests/DOMNodeComparatorTest.php000066400000000000000000000120071376771537100233660ustar00rootroot00000000000000 * * 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 * * @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(''), $this->createDOMDocument(''), ], [ $this->createDOMDocument(''), $this->createDOMDocument(''), ], [ $this->createDOMDocument(''), $this->createDOMDocument(''), ], [ $this->createDOMDocument("\n \n"), $this->createDOMDocument(''), ], [ $this->createDOMDocument(''), $this->createDOMDocument(''), $ignoreCase = true, ], [ $this->createDOMDocument(""), $this->createDOMDocument(""), ], ]; } public function assertEqualsFailsProvider() { return [ [ $this->createDOMDocument(''), $this->createDOMDocument(''), ], [ $this->createDOMDocument(''), $this->createDOMDocument(''), ], [ $this->createDOMDocument(' bar '), $this->createDOMDocument(''), ], [ $this->createDOMDocument(''), $this->createDOMDocument(''), ], [ $this->createDOMDocument(' bar '), $this->createDOMDocument(' bir '), ], [ $this->createDOMDocument(''), $this->createDOMDocument(''), ], [ $this->createDOMDocument(' bar '), $this->createDOMDocument(' BAR '), ], ]; } /** * @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; } } phpunit-comparator-4.0.6/tests/DateTimeComparatorTest.php000066400000000000000000000162131376771537100236400ustar00rootroot00000000000000 * * 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 * * @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')) ) ); } } phpunit-comparator-4.0.6/tests/DoubleComparatorTest.php000066400000000000000000000063171376771537100233620ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function acos; use PHPUnit\Framework\TestCase; /** * @covers \SebastianBergmann\Comparator\DoubleComparator * * @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); } } phpunit-comparator-4.0.6/tests/ExceptionComparatorTest.php000066400000000000000000000071741376771537100241100ustar00rootroot00000000000000 * * 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 * * @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); } } phpunit-comparator-4.0.6/tests/FactoryTest.php000066400000000000000000000112401376771537100215160ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function tmpfile; use DateTime; use DOMDocument; use Exception; use PHPUnit\Framework\TestCase; use SplObjectStorage; use stdClass; /** * @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, ScalarComparator::class], [null, true, ScalarComparator::class], [true, null, ScalarComparator::class], [true, true, ScalarComparator::class], [false, false, ScalarComparator::class], [true, false, ScalarComparator::class], [false, true, ScalarComparator::class], ['', '', ScalarComparator::class], ['0', '0', ScalarComparator::class], ['0', 0, NumericComparator::class], [0, '0', NumericComparator::class], [0, 0, NumericComparator::class], [1.0, 0, DoubleComparator::class], [0, 1.0, DoubleComparator::class], [1.0, 1.0, DoubleComparator::class], [[1], [1], ArrayComparator::class], [$tmpfile, $tmpfile, ResourceComparator::class], [new stdClass, new stdClass, ObjectComparator::class], [new DateTime, new DateTime, DateTimeComparator::class], [new SplObjectStorage, new SplObjectStorage, SplObjectStorageComparator::class], [new Exception, new Exception, ExceptionComparator::class], [new DOMDocument, new DOMDocument, DOMNodeComparator::class], // mixed types [$tmpfile, [1], TypeComparator::class], [[1], $tmpfile, TypeComparator::class], [$tmpfile, '1', TypeComparator::class], ['1', $tmpfile, TypeComparator::class], [$tmpfile, new stdClass, TypeComparator::class], [new stdClass, $tmpfile, TypeComparator::class], [new stdClass, [1], TypeComparator::class], [[1], new stdClass, TypeComparator::class], [new stdClass, '1', TypeComparator::class], ['1', new stdClass, TypeComparator::class], [new ClassWithToString, '1', ScalarComparator::class], ['1', new ClassWithToString, ScalarComparator::class], [1.0, new stdClass, TypeComparator::class], [new stdClass, 1.0, TypeComparator::class], [1.0, [1], TypeComparator::class], [[1], 1.0, TypeComparator::class], ]; } /** * @dataProvider instanceProvider */ public function testGetComparatorFor($a, $b, $expected): void { $factory = new Factory; $actual = $factory->getComparatorFor($a, $b); $this->assertInstanceOf($expected, $actual); } public function testCustomComparatorCanBeRegistered(): void { $comparator = new TestClassComparator; $factory = new Factory; $factory->register($comparator); $a = new TestClass; $b = new TestClass; $expected = TestClassComparator::class; $actual = $factory->getComparatorFor($a, $b); $factory->unregister($comparator); $this->assertInstanceOf($expected, $actual); } public function testCustomComparatorCanBeUnregistered(): void { $comparator = new TestClassComparator; $factory = new Factory; $factory->register($comparator); $factory->unregister($comparator); $a = new TestClass; $b = new TestClass; $expected = ObjectComparator::class; $actual = $factory->getComparatorFor($a, $b); $this->assertInstanceOf($expected, $actual); } public function testCustomComparatorsCanBeReset(): void { $comparator = new TestClassComparator; $factory = new Factory; $factory->register($comparator); $factory->reset(); $a = new TestClass; $b = new TestClass; $expected = ObjectComparator::class; $actual = $factory->getComparatorFor($a, $b); $this->assertInstanceOf($expected, $actual); } public function testIsSingleton(): void { $f = Factory::getInstance(); $this->assertSame($f, Factory::getInstance()); } } phpunit-comparator-4.0.6/tests/MockObjectComparatorTest.php000066400000000000000000000136361376771537100241720ustar00rootroot00000000000000 * * 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 * * @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); } /** * @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); } public function acceptsSucceedsProvider(): array { $testmock = $this->createMock(TestClass::class); $stdmock = $this->createMock(stdClass::class); return [ [$testmock, $testmock], [$stdmock, $stdmock], [$stdmock, $testmock], ]; } public function acceptsFailsProvider(): array { $stdmock = $this->createMock(stdClass::class); return [ [$stdmock, null], [null, $stdmock], [null, null], ]; } public function assertEqualsSucceedsProvider(): array { // 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(): array { $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(); $book2->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, ], ]; } } phpunit-comparator-4.0.6/tests/NumericComparatorTest.php000066400000000000000000000056251376771537100235530ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use const INF; use PHPUnit\Framework\TestCase; /** * @covers \SebastianBergmann\Comparator\NumericComparator * * @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], [INF, INF], ]; } 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); } } phpunit-comparator-4.0.6/tests/ObjectComparatorTest.php000066400000000000000000000102741376771537100233530ustar00rootroot00000000000000 * * 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 * * @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); } } phpunit-comparator-4.0.6/tests/ResourceComparatorTest.php000066400000000000000000000054551376771537100237410ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function tmpfile; use PHPUnit\Framework\TestCase; /** * @covers \SebastianBergmann\Comparator\ResourceComparator * * @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); } } phpunit-comparator-4.0.6/tests/ScalarComparatorTest.php000066400000000000000000000115251376771537100233520ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use function tmpfile; use PHPUnit\Framework\TestCase; /** * @covers \SebastianBergmann\Comparator\ScalarComparator * * @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); } } phpunit-comparator-4.0.6/tests/SplObjectStorageComparatorTest.php000066400000000000000000000073151376771537100253610ustar00rootroot00000000000000 * * 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 * * @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()); } } phpunit-comparator-4.0.6/tests/TypeComparatorTest.php000066400000000000000000000050031376771537100230600ustar00rootroot00000000000000 * * 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 * * @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); } } phpunit-comparator-4.0.6/tests/_fixture/000077500000000000000000000000001376771537100203655ustar00rootroot00000000000000phpunit-comparator-4.0.6/tests/_fixture/Author.php000066400000000000000000000010371376771537100223410ustar00rootroot00000000000000 * * 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; } } phpunit-comparator-4.0.6/tests/_fixture/Book.php000066400000000000000000000006541376771537100217750ustar00rootroot00000000000000 * * 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; } phpunit-comparator-4.0.6/tests/_fixture/ClassWithToString.php000066400000000000000000000006441376771537100244750ustar00rootroot00000000000000 * * 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'; } } phpunit-comparator-4.0.6/tests/_fixture/SampleClass.php000066400000000000000000000010271376771537100233050ustar00rootroot00000000000000 * * 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; } } phpunit-comparator-4.0.6/tests/_fixture/Struct.php000066400000000000000000000006701376771537100223650ustar00rootroot00000000000000 * * 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; } } phpunit-comparator-4.0.6/tests/_fixture/TestClass.php000066400000000000000000000005071376771537100230050ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; class TestClass { } phpunit-comparator-4.0.6/tests/_fixture/TestClassComparator.php000066400000000000000000000005521376771537100250350ustar00rootroot00000000000000 * * 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 { }