pax_global_header00006660000000000000000000000064133216677560014532gustar00rootroot0000000000000052 comment=5de4fc177adf9bce8df98d8d141a7559d7ccf6da comparator-3.0.2/000077500000000000000000000000001332166775600137035ustar00rootroot00000000000000comparator-3.0.2/.github/000077500000000000000000000000001332166775600152435ustar00rootroot00000000000000comparator-3.0.2/.github/stale.yml000066400000000000000000000026771332166775600171120ustar00rootroot00000000000000# Configuration for probot-stale - https://github.com/probot/stale # Number of days of inactivity before an Issue or Pull Request becomes stale daysUntilStale: 60 # Number of days of inactivity before a stale Issue or Pull Request is closed. # Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale. daysUntilClose: 7 # Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable exemptLabels: - enhancement # Set to true to ignore issues in a project (defaults to false) exemptProjects: false # Set to true to ignore issues in a milestone (defaults to false) exemptMilestones: false # Label to use when marking as stale staleLabel: stale # Comment to post when marking as stale. Set to `false` to disable markComment: > This issue has been automatically marked as stale because it has not had activity within the last 60 days. It will be closed after 7 days if no further activity occurs. Thank you for your contributions. # Comment to post when removing the stale label. # unmarkComment: > # Your comment here. # Comment to post when closing a stale Issue or Pull Request. closeComment: > This issue has been automatically closed because it has not had activity since it was marked as stale. Thank you for your contributions. # Limit the number of actions per hour, from 1-30. Default is 30 limitPerRun: 30 # Limit to only `issues` or `pulls` only: issues comparator-3.0.2/.gitignore000066400000000000000000000000551332166775600156730ustar00rootroot00000000000000/.idea /.php_cs.cache /composer.lock /vendor comparator-3.0.2/.php_cs.dist000066400000000000000000000170131332166775600161240ustar00rootroot00000000000000 For the full copyright and license information, please view the LICENSE file that was distributed with this source code. EOF; return PhpCsFixer\Config::create() ->setRiskyAllowed(true) ->setRules( [ 'align_multiline_comment' => true, 'array_indentation' => true, 'array_syntax' => ['syntax' => 'short'], 'binary_operator_spaces' => [ 'operators' => [ '=' => 'align', '=>' => 'align', ], ], 'blank_line_after_namespace' => true, 'blank_line_before_statement' => [ 'statements' => [ 'break', 'continue', 'declare', 'do', 'for', 'foreach', 'if', 'include', 'include_once', 'require', 'require_once', 'return', 'switch', 'throw', 'try', 'while', 'yield', ], ], 'braces' => true, 'cast_spaces' => true, 'class_attributes_separation' => ['elements' => ['const', 'method', 'property']], 'combine_consecutive_issets' => true, 'combine_consecutive_unsets' => true, 'compact_nullable_typehint' => true, 'concat_space' => ['spacing' => 'one'], 'declare_equal_normalize' => ['space' => 'none'], 'dir_constant' => true, 'elseif' => true, 'encoding' => true, 'full_opening_tag' => true, 'function_declaration' => true, 'header_comment' => ['header' => $header, 'separate' => 'none'], 'indentation_type' => true, 'is_null' => true, 'line_ending' => true, 'list_syntax' => ['syntax' => 'short'], 'logical_operators' => true, 'lowercase_cast' => true, 'lowercase_constants' => true, 'lowercase_keywords' => true, 'lowercase_static_reference' => true, 'magic_constant_casing' => true, 'method_argument_space' => ['ensure_fully_multiline' => true], 'modernize_types_casting' => true, 'multiline_comment_opening_closing' => true, 'multiline_whitespace_before_semicolons' => true, 'native_constant_invocation' => true, 'native_function_casing' => true, 'native_function_invocation' => true, 'new_with_braces' => false, 'no_alias_functions' => true, 'no_alternative_syntax' => true, 'no_blank_lines_after_class_opening' => true, 'no_blank_lines_after_phpdoc' => true, 'no_blank_lines_before_namespace' => true, 'no_closing_tag' => true, 'no_empty_comment' => true, 'no_empty_phpdoc' => true, 'no_empty_statement' => true, 'no_extra_blank_lines' => true, 'no_homoglyph_names' => true, 'no_leading_import_slash' => true, 'no_leading_namespace_whitespace' => true, 'no_mixed_echo_print' => ['use' => 'print'], 'no_multiline_whitespace_around_double_arrow' => true, 'no_null_property_initialization' => true, 'no_php4_constructor' => true, 'no_short_bool_cast' => true, 'no_short_echo_tag' => true, 'no_singleline_whitespace_before_semicolons' => true, 'no_spaces_after_function_name' => true, 'no_spaces_inside_parenthesis' => true, 'no_superfluous_elseif' => true, 'no_superfluous_phpdoc_tags' => true, 'no_trailing_comma_in_list_call' => true, 'no_trailing_comma_in_singleline_array' => true, 'no_trailing_whitespace' => true, 'no_trailing_whitespace_in_comment' => true, 'no_unneeded_control_parentheses' => true, 'no_unneeded_curly_braces' => true, 'no_unneeded_final_method' => true, 'no_unreachable_default_argument_value' => true, 'no_unset_on_property' => true, 'no_unused_imports' => true, 'no_useless_else' => true, 'no_useless_return' => true, 'no_whitespace_before_comma_in_array' => true, 'no_whitespace_in_blank_line' => true, 'non_printable_character' => true, 'normalize_index_brace' => true, 'object_operator_without_whitespace' => true, 'ordered_class_elements' => [ 'order' => [ 'use_trait', 'constant_public', 'constant_protected', 'constant_private', 'property_public_static', 'property_protected_static', 'property_private_static', 'property_public', 'property_protected', 'property_private', 'method_public_static', 'construct', 'destruct', 'magic', 'phpunit', 'method_public', 'method_protected', 'method_private', 'method_protected_static', 'method_private_static', ], ], 'ordered_imports' => true, 'phpdoc_add_missing_param_annotation' => true, 'phpdoc_align' => true, 'phpdoc_annotation_without_dot' => true, 'phpdoc_indent' => true, 'phpdoc_no_access' => true, 'phpdoc_no_empty_return' => true, 'phpdoc_no_package' => true, 'phpdoc_order' => true, 'phpdoc_return_self_reference' => true, 'phpdoc_scalar' => true, 'phpdoc_separation' => true, 'phpdoc_single_line_var_spacing' => true, 'phpdoc_to_comment' => true, 'phpdoc_trim' => true, 'phpdoc_trim_consecutive_blank_line_separation' => true, 'phpdoc_types' => true, 'phpdoc_types_order' => true, 'phpdoc_var_without_name' => true, 'pow_to_exponentiation' => true, 'protected_to_private' => true, 'return_assignment' => true, 'return_type_declaration' => ['space_before' => 'none'], 'self_accessor' => true, 'semicolon_after_instruction' => true, 'set_type_to_cast' => true, 'short_scalar_cast' => true, 'simplified_null_return' => true, 'single_blank_line_at_eof' => true, 'single_import_per_statement' => true, 'single_line_after_imports' => true, 'single_quote' => true, 'standardize_not_equals' => true, 'ternary_to_null_coalescing' => true, 'trim_array_spaces' => true, 'unary_operator_spaces' => true, 'visibility_required' => true, //'void_return' => true, 'whitespace_after_comma_in_array' => true, ] ) ->setFinder( PhpCsFixer\Finder::create() ->files() ->in(__DIR__ . '/src') ->in(__DIR__ . '/tests') ); comparator-3.0.2/.travis.yml000066400000000000000000000012411332166775600160120ustar00rootroot00000000000000language: php sudo: false php: - 7.1 - 7.2 - master env: matrix: - DEPENDENCIES="high" - DEPENDENCIES="low" global: - DEFAULT_COMPOSER_FLAGS="--no-interaction --no-ansi --no-progress --no-suggest" before_install: - composer self-update - composer clear-cache install: - if [[ "$DEPENDENCIES" = 'high' ]]; then travis_retry composer update $DEFAULT_COMPOSER_FLAGS; fi - if [[ "$DEPENDENCIES" = 'low' ]]; then travis_retry composer update $DEFAULT_COMPOSER_FLAGS --prefer-lowest; fi script: - ./vendor/bin/phpunit --coverage-clover=coverage.xml after_success: - bash <(curl -s https://codecov.io/bash) notifications: email: false comparator-3.0.2/ChangeLog.md000066400000000000000000000035411332166775600160570ustar00rootroot00000000000000# ChangeLog All notable changes are documented in this file using the [Keep a CHANGELOG](http://keepachangelog.com/) principles. ## [3.0.2] - 2018-07-12 ### Changed * By default, `MockObjectComparator` is now tried before all other (default) comparators ## [3.0.1] - 2018-06-14 ### Fixed * Fixed [#53](https://github.com/sebastianbergmann/comparator/pull/53): `DOMNodeComparator` ignores `$ignoreCase` parameter * Fixed [#58](https://github.com/sebastianbergmann/comparator/pull/58): `ScalarComparator` does not handle extremely ugly string comparison edge cases ## [3.0.0] - 2018-04-18 ### Fixed * Fixed [#48](https://github.com/sebastianbergmann/comparator/issues/48): `DateTimeComparator` does not support fractional second deltas ### Removed * Removed support for PHP 7.0 ## [2.1.3] - 2018-02-01 ### Changed * This component is now compatible with version 3 of `sebastian/diff` ## [2.1.2] - 2018-01-12 ### Fixed * Fix comparison of `DateTimeImmutable` objects ## [2.1.1] - 2017-12-22 ### Fixed * Fixed [phpunit/#2923](https://github.com/sebastianbergmann/phpunit/issues/2923): Unexpected failed date matching ## [2.1.0] - 2017-11-03 ### Added * Added `SebastianBergmann\Comparator\Factory::reset()` to unregister all non-default comparators * Added support for `phpunit/phpunit-mock-objects` version `^5.0` [3.0.2]: https://github.com/sebastianbergmann/comparator/compare/3.0.1...3.0.2 [3.0.1]: https://github.com/sebastianbergmann/comparator/compare/3.0.0...3.0.1 [3.0.0]: https://github.com/sebastianbergmann/comparator/compare/2.1.3...3.0.0 [2.1.3]: https://github.com/sebastianbergmann/comparator/compare/2.1.2...2.1.3 [2.1.2]: https://github.com/sebastianbergmann/comparator/compare/2.1.1...2.1.2 [2.1.1]: https://github.com/sebastianbergmann/comparator/compare/2.1.0...2.1.1 [2.1.0]: https://github.com/sebastianbergmann/comparator/compare/2.0.2...2.1.0 comparator-3.0.2/LICENSE000066400000000000000000000030111332166775600147030ustar00rootroot00000000000000Comparator Copyright (c) 2002-2018, 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. comparator-3.0.2/README.md000066400000000000000000000021671332166775600151700ustar00rootroot00000000000000[![Build Status](https://travis-ci.org/sebastianbergmann/comparator.svg?branch=master)](https://travis-ci.org/sebastianbergmann/comparator) # Comparator This component provides the functionality to compare PHP values for equality. ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): composer require sebastian/comparator If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: composer require --dev sebastian/comparator ## Usage ```php getComparatorFor($date1, $date2); try { $comparator->assertEquals($date1, $date2); print "Dates match"; } catch (ComparisonFailure $failure) { print "Dates don't match"; } ``` comparator-3.0.2/build.xml000066400000000000000000000013701332166775600155250ustar00rootroot00000000000000 comparator-3.0.2/composer.json000066400000000000000000000023711332166775600164300ustar00rootroot00000000000000{ "name": "sebastian/comparator", "description": "Provides the functionality to compare PHP values for equality", "keywords": ["comparator","compare","equality"], "homepage": "https://github.com/sebastianbergmann/comparator", "license": "BSD-3-Clause", "authors": [ { "name": "Sebastian Bergmann", "email": "sebastian@phpunit.de" }, { "name": "Jeff Welch", "email": "whatthejeff@gmail.com" }, { "name": "Volker Dusch", "email": "github@wallbash.com" }, { "name": "Bernhard Schussek", "email": "bschussek@2bepublished.at" } ], "prefer-stable": true, "require": { "php": "^7.1", "sebastian/diff": "^3.0", "sebastian/exporter": "^3.1" }, "require-dev": { "phpunit/phpunit": "^7.1" }, "config": { "optimize-autoloader": true, "sort-packages": true }, "autoload": { "classmap": [ "src/" ] }, "autoload-dev": { "classmap": [ "tests/_fixture" ] }, "extra": { "branch-alias": { "dev-master": "3.0-dev" } } } comparator-3.0.2/phpunit.xml000066400000000000000000000013631332166775600161170ustar00rootroot00000000000000 tests src comparator-3.0.2/src/000077500000000000000000000000001332166775600144725ustar00rootroot00000000000000comparator-3.0.2/src/ArrayComparator.php000066400000000000000000000102101332166775600203030ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares arrays for equality. */ class ArrayComparator extends Comparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return \is_array($expected) && \is_array($actual); } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * @param array $processed List of already processed elements (used to prevent infinite recursion) * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = []) { if ($canonicalize) { \sort($expected); \sort($actual); } $remaining = $actual; $actualAsString = "Array (\n"; $expectedAsString = "Array (\n"; $equal = true; foreach ($expected as $key => $value) { unset($remaining[$key]); if (!\array_key_exists($key, $actual)) { $expectedAsString .= \sprintf( " %s => %s\n", $this->exporter->export($key), $this->exporter->shortenedExport($value) ); $equal = false; continue; } try { $comparator = $this->factory->getComparatorFor($value, $actual[$key]); $comparator->assertEquals($value, $actual[$key], $delta, $canonicalize, $ignoreCase, $processed); $expectedAsString .= \sprintf( " %s => %s\n", $this->exporter->export($key), $this->exporter->shortenedExport($value) ); $actualAsString .= \sprintf( " %s => %s\n", $this->exporter->export($key), $this->exporter->shortenedExport($actual[$key]) ); } catch (ComparisonFailure $e) { $expectedAsString .= \sprintf( " %s => %s\n", $this->exporter->export($key), $e->getExpectedAsString() ? $this->indent($e->getExpectedAsString()) : $this->exporter->shortenedExport($e->getExpected()) ); $actualAsString .= \sprintf( " %s => %s\n", $this->exporter->export($key), $e->getActualAsString() ? $this->indent($e->getActualAsString()) : $this->exporter->shortenedExport($e->getActual()) ); $equal = false; } } foreach ($remaining as $key => $value) { $actualAsString .= \sprintf( " %s => %s\n", $this->exporter->export($key), $this->exporter->shortenedExport($value) ); $equal = false; } $expectedAsString .= ')'; $actualAsString .= ')'; if (!$equal) { throw new ComparisonFailure( $expected, $actual, $expectedAsString, $actualAsString, false, 'Failed asserting that two arrays are equal.' ); } } protected function indent($lines) { return \trim(\str_replace("\n", "\n ", $lines)); } } comparator-3.0.2/src/Comparator.php000066400000000000000000000031341332166775600173130ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use SebastianBergmann\Exporter\Exporter; /** * Abstract base class for comparators which compare values for equality. */ abstract class Comparator { /** * @var Factory */ protected $factory; /** * @var Exporter */ protected $exporter; public function __construct() { $this->exporter = new Exporter; } public function setFactory(Factory $factory) { $this->factory = $factory; } /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ abstract public function accepts($expected, $actual); /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * * @throws ComparisonFailure */ abstract public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false); } comparator-3.0.2/src/ComparisonFailure.php000066400000000000000000000056551332166775600206400ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use SebastianBergmann\Diff\Differ; use SebastianBergmann\Diff\Output\UnifiedDiffOutputBuilder; /** * Thrown when an assertion for string equality failed. */ class ComparisonFailure extends \RuntimeException { /** * Expected value of the retrieval which does not match $actual. * * @var mixed */ protected $expected; /** * Actually retrieved value which does not match $expected. * * @var mixed */ protected $actual; /** * The string representation of the expected value * * @var string */ protected $expectedAsString; /** * The string representation of the actual value * * @var string */ protected $actualAsString; /** * @var bool */ protected $identical; /** * Optional message which is placed in front of the first line * returned by toString(). * * @var string */ protected $message; /** * Initialises with the expected value and the actual value. * * @param mixed $expected expected value retrieved * @param mixed $actual actual value retrieved * @param string $expectedAsString * @param string $actualAsString * @param bool $identical * @param string $message a string which is prefixed on all returned lines * in the difference output */ public function __construct($expected, $actual, $expectedAsString, $actualAsString, $identical = false, $message = '') { $this->expected = $expected; $this->actual = $actual; $this->expectedAsString = $expectedAsString; $this->actualAsString = $actualAsString; $this->message = $message; } public function getActual() { return $this->actual; } public function getExpected() { return $this->expected; } /** * @return string */ public function getActualAsString() { return $this->actualAsString; } /** * @return string */ public function getExpectedAsString() { return $this->expectedAsString; } /** * @return string */ public function getDiff() { if (!$this->actualAsString && !$this->expectedAsString) { return ''; } $differ = new Differ(new UnifiedDiffOutputBuilder("\n--- Expected\n+++ Actual\n")); return $differ->diff($this->expectedAsString, $this->actualAsString); } /** * @return string */ public function toString() { return $this->message . $this->getDiff(); } } comparator-3.0.2/src/DOMNodeComparator.php000066400000000000000000000053471332166775600204710ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use DOMDocument; use DOMNode; /** * Compares DOMNode instances for equality. */ class DOMNodeComparator extends ObjectComparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return $expected instanceof DOMNode && $actual instanceof DOMNode; } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * @param array $processed List of already processed elements (used to prevent infinite recursion) * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = []) { $expectedAsString = $this->nodeToText($expected, true, $ignoreCase); $actualAsString = $this->nodeToText($actual, true, $ignoreCase); if ($expectedAsString !== $actualAsString) { $type = $expected instanceof DOMDocument ? 'documents' : 'nodes'; throw new ComparisonFailure( $expected, $actual, $expectedAsString, $actualAsString, false, \sprintf("Failed asserting that two DOM %s are equal.\n", $type) ); } } /** * Returns the normalized, whitespace-cleaned, and indented textual * representation of a DOMNode. */ private function nodeToText(DOMNode $node, bool $canonicalize, bool $ignoreCase): string { if ($canonicalize) { $document = new DOMDocument; @$document->loadXML($node->C14N()); $node = $document; } $document = $node instanceof DOMDocument ? $node : $node->ownerDocument; $document->formatOutput = true; $document->normalizeDocument(); $text = $node instanceof DOMDocument ? $node->saveXML() : $document->saveXML($node); return $ignoreCase ? \strtolower($text) : $text; } } comparator-3.0.2/src/DateTimeComparator.php000066400000000000000000000057141332166775600207360ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares DateTimeInterface instances for equality. */ class DateTimeComparator extends ObjectComparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return ($expected instanceof \DateTime || $expected instanceof \DateTimeInterface) && ($actual instanceof \DateTime || $actual instanceof \DateTimeInterface); } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * @param array $processed List of already processed elements (used to prevent infinite recursion) * * @throws \Exception * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = []) { /** @var \DateTimeInterface $expected */ /** @var \DateTimeInterface $actual */ $absDelta = \abs($delta); $delta = new \DateInterval(\sprintf('PT%dS', $absDelta)); $delta->f = $absDelta - \floor($absDelta); $actualClone = (clone $actual) ->setTimezone(new \DateTimeZone('UTC')); $expectedLower = (clone $expected) ->setTimezone(new \DateTimeZone('UTC')) ->sub($delta); $expectedUpper = (clone $expected) ->setTimezone(new \DateTimeZone('UTC')) ->add($delta); if ($actualClone < $expectedLower || $actualClone > $expectedUpper) { throw new ComparisonFailure( $expected, $actual, $this->dateTimeToString($expected), $this->dateTimeToString($actual), false, 'Failed asserting that two DateTime objects are equal.' ); } } /** * Returns an ISO 8601 formatted string representation of a datetime or * 'Invalid DateTimeInterface object' if the provided DateTimeInterface was not properly * initialized. */ private function dateTimeToString(\DateTimeInterface $datetime): string { $string = $datetime->format('Y-m-d\TH:i:s.uO'); return $string ?: 'Invalid DateTimeInterface object'; } } comparator-3.0.2/src/DoubleComparator.php000066400000000000000000000031641332166775600204510ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares doubles for equality. */ class DoubleComparator extends NumericComparator { /** * Smallest value available in PHP. * * @var float */ const EPSILON = 0.0000000001; /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return (\is_float($expected) || \is_float($actual)) && \is_numeric($expected) && \is_numeric($actual); } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) { if ($delta == 0) { $delta = self::EPSILON; } parent::assertEquals($expected, $actual, $delta, $canonicalize, $ignoreCase); } } comparator-3.0.2/src/ExceptionComparator.php000066400000000000000000000023371332166775600211760ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares Exception instances for equality. */ class ExceptionComparator extends ObjectComparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return $expected instanceof \Exception && $actual instanceof \Exception; } /** * Converts an object to an array containing all of its private, protected * and public properties. * * @param object $object * * @return array */ protected function toArray($object) { $array = parent::toArray($object); unset( $array['file'], $array['line'], $array['trace'], $array['string'], $array['xdebug_message'] ); return $array; } } comparator-3.0.2/src/Factory.php000066400000000000000000000074151332166775600166210ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Factory for comparators which compare values for equality. */ class Factory { /** * @var Factory */ private static $instance; /** * @var Comparator[] */ private $customComparators = []; /** * @var Comparator[] */ private $defaultComparators = []; /** * @return Factory */ public static function getInstance() { if (self::$instance === null) { self::$instance = new self; } return self::$instance; } /** * Constructs a new factory. */ public function __construct() { $this->registerDefaultComparators(); } /** * Returns the correct comparator for comparing two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return Comparator */ public function getComparatorFor($expected, $actual) { foreach ($this->customComparators as $comparator) { if ($comparator->accepts($expected, $actual)) { return $comparator; } } foreach ($this->defaultComparators as $comparator) { if ($comparator->accepts($expected, $actual)) { return $comparator; } } } /** * Registers a new comparator. * * This comparator will be returned by getComparatorFor() if its accept() method * returns TRUE for the compared values. It has higher priority than the * existing comparators, meaning that its accept() method will be invoked * before those of the other comparators. * * @param Comparator $comparator The comparator to be registered */ public function register(Comparator $comparator) { \array_unshift($this->customComparators, $comparator); $comparator->setFactory($this); } /** * Unregisters a comparator. * * This comparator will no longer be considered by getComparatorFor(). * * @param Comparator $comparator The comparator to be unregistered */ public function unregister(Comparator $comparator) { foreach ($this->customComparators as $key => $_comparator) { if ($comparator === $_comparator) { unset($this->customComparators[$key]); } } } /** * Unregisters all non-default comparators. */ public function reset() { $this->customComparators = []; } private function registerDefaultComparators() { $this->registerDefaultComparator(new MockObjectComparator); $this->registerDefaultComparator(new DateTimeComparator); $this->registerDefaultComparator(new DOMNodeComparator); $this->registerDefaultComparator(new SplObjectStorageComparator); $this->registerDefaultComparator(new ExceptionComparator); $this->registerDefaultComparator(new ObjectComparator); $this->registerDefaultComparator(new ResourceComparator); $this->registerDefaultComparator(new ArrayComparator); $this->registerDefaultComparator(new DoubleComparator); $this->registerDefaultComparator(new NumericComparator); $this->registerDefaultComparator(new ScalarComparator); $this->registerDefaultComparator(new TypeComparator); } private function registerDefaultComparator(Comparator $comparator) { $this->defaultComparators[] = $comparator; $comparator->setFactory($this); } } comparator-3.0.2/src/MockObjectComparator.php000066400000000000000000000025201332166775600212520ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares PHPUnit_Framework_MockObject_MockObject instances for equality. */ class MockObjectComparator extends ObjectComparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return ($expected instanceof \PHPUnit_Framework_MockObject_MockObject || $expected instanceof \PHPUnit\Framework\MockObject\MockObject) && ($actual instanceof \PHPUnit_Framework_MockObject_MockObject || $actual instanceof \PHPUnit\Framework\MockObject\MockObject); } /** * Converts an object to an array containing all of its private, protected * and public properties. * * @param object $object * * @return array */ protected function toArray($object) { $array = parent::toArray($object); unset($array['__phpunit_invocationMocker']); return $array; } } comparator-3.0.2/src/NumericComparator.php000066400000000000000000000043341332166775600206410ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares numerical values for equality. */ class NumericComparator extends ScalarComparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { // all numerical values, but not if one of them is a double // or both of them are strings return \is_numeric($expected) && \is_numeric($actual) && !(\is_float($expected) || \is_float($actual)) && !(\is_string($expected) && \is_string($actual)); } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) { if (\is_infinite($actual) && \is_infinite($expected)) { return; // @codeCoverageIgnore } if ((\is_infinite($actual) xor \is_infinite($expected)) || (\is_nan($actual) || \is_nan($expected)) || \abs($actual - $expected) > $delta) { throw new ComparisonFailure( $expected, $actual, '', '', false, \sprintf( 'Failed asserting that %s matches expected %s.', $this->exporter->export($actual), $this->exporter->export($expected) ) ); } } } comparator-3.0.2/src/ObjectComparator.php000066400000000000000000000070301332166775600204410ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares objects for equality. */ class ObjectComparator extends ArrayComparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return \is_object($expected) && \is_object($actual); } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * @param array $processed List of already processed elements (used to prevent infinite recursion) * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = []) { if (\get_class($actual) !== \get_class($expected)) { throw new ComparisonFailure( $expected, $actual, $this->exporter->export($expected), $this->exporter->export($actual), false, \sprintf( '%s is not instance of expected class "%s".', $this->exporter->export($actual), \get_class($expected) ) ); } // don't compare twice to allow for cyclic dependencies if (\in_array([$actual, $expected], $processed, true) || \in_array([$expected, $actual], $processed, true)) { return; } $processed[] = [$actual, $expected]; // don't compare objects if they are identical // this helps to avoid the error "maximum function nesting level reached" // CAUTION: this conditional clause is not tested if ($actual !== $expected) { try { parent::assertEquals( $this->toArray($expected), $this->toArray($actual), $delta, $canonicalize, $ignoreCase, $processed ); } catch (ComparisonFailure $e) { throw new ComparisonFailure( $expected, $actual, // replace "Array" with "MyClass object" \substr_replace($e->getExpectedAsString(), \get_class($expected) . ' Object', 0, 5), \substr_replace($e->getActualAsString(), \get_class($actual) . ' Object', 0, 5), false, 'Failed asserting that two objects are equal.' ); } } } /** * Converts an object to an array containing all of its private, protected * and public properties. * * @param object $object * * @return array */ protected function toArray($object) { return $this->exporter->toArray($object); } } comparator-3.0.2/src/ResourceComparator.php000066400000000000000000000030561332166775600210260ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares resources for equality. */ class ResourceComparator extends Comparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return \is_resource($expected) && \is_resource($actual); } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) { if ($actual != $expected) { throw new ComparisonFailure( $expected, $actual, $this->exporter->export($expected), $this->exporter->export($actual) ); } } } comparator-3.0.2/src/ScalarComparator.php000066400000000000000000000062221332166775600204420ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares scalar or NULL values for equality. */ class ScalarComparator extends Comparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool * * @since Method available since Release 3.6.0 */ public function accepts($expected, $actual) { return ((\is_scalar($expected) xor null === $expected) && (\is_scalar($actual) xor null === $actual)) // allow comparison between strings and objects featuring __toString() || (\is_string($expected) && \is_object($actual) && \method_exists($actual, '__toString')) || (\is_object($expected) && \method_exists($expected, '__toString') && \is_string($actual)); } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) { $expectedToCompare = $expected; $actualToCompare = $actual; // always compare as strings to avoid strange behaviour // otherwise 0 == 'Foobar' if (\is_string($expected) || \is_string($actual)) { $expectedToCompare = (string) $expectedToCompare; $actualToCompare = (string) $actualToCompare; if ($ignoreCase) { $expectedToCompare = \strtolower($expectedToCompare); $actualToCompare = \strtolower($actualToCompare); } } if ($expectedToCompare !== $actualToCompare && \is_string($expected) && \is_string($actual)) { throw new ComparisonFailure( $expected, $actual, $this->exporter->export($expected), $this->exporter->export($actual), false, 'Failed asserting that two strings are equal.' ); } if ($expectedToCompare != $actualToCompare) { throw new ComparisonFailure( $expected, $actual, // no diff is required '', '', false, \sprintf( 'Failed asserting that %s matches expected %s.', $this->exporter->export($actual), $this->exporter->export($expected) ) ); } } } comparator-3.0.2/src/SplObjectStorageComparator.php000066400000000000000000000043301332166775600224450ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares \SplObjectStorage instances for equality. */ class SplObjectStorageComparator extends Comparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return $expected instanceof \SplObjectStorage && $actual instanceof \SplObjectStorage; } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) { foreach ($actual as $object) { if (!$expected->contains($object)) { throw new ComparisonFailure( $expected, $actual, $this->exporter->export($expected), $this->exporter->export($actual), false, 'Failed asserting that two objects are equal.' ); } } foreach ($expected as $object) { if (!$actual->contains($object)) { throw new ComparisonFailure( $expected, $actual, $this->exporter->export($expected), $this->exporter->export($actual), false, 'Failed asserting that two objects are equal.' ); } } } } comparator-3.0.2/src/TypeComparator.php000066400000000000000000000033461332166775600201620ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares values for type equality. */ class TypeComparator extends Comparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return true; } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) { if (\gettype($expected) != \gettype($actual)) { throw new ComparisonFailure( $expected, $actual, // we don't need a diff '', '', false, \sprintf( '%s does not match expected type "%s".', $this->exporter->shortenedExport($actual), \gettype($expected) ) ); } } } comparator-3.0.2/tests/000077500000000000000000000000001332166775600150455ustar00rootroot00000000000000comparator-3.0.2/tests/ArrayComparatorTest.php000066400000000000000000000072321332166775600215300ustar00rootroot00000000000000 * * 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); } } comparator-3.0.2/tests/ComparisonFailureTest.php000066400000000000000000000030071332166775600220400ustar00rootroot00000000000000 * * 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()); } } comparator-3.0.2/tests/DOMNodeComparatorTest.php000066400000000000000000000117331332166775600217000ustar00rootroot00000000000000 * * 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; } } comparator-3.0.2/tests/DateTimeComparatorTest.php000066400000000000000000000161351332166775600221500ustar00rootroot00000000000000 * * 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')) ) ); } } comparator-3.0.2/tests/DoubleComparatorTest.php000066400000000000000000000062431332166775600216650ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @covers \SebastianBergmann\Comparator\DoubleComparator * * @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); } } comparator-3.0.2/tests/ExceptionComparatorTest.php000066400000000000000000000071331332166775600224100ustar00rootroot00000000000000 * * 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); } } comparator-3.0.2/tests/FactoryTest.php000066400000000000000000000121251332166775600200260ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @covers \SebastianBergmann\Comparator\Factory * * @uses \SebastianBergmann\Comparator\Comparator * @uses \SebastianBergmann\Comparator\Factory * @uses \SebastianBergmann\Comparator\ComparisonFailure */ final class FactoryTest extends TestCase { public function instanceProvider() { $tmpfile = \tmpfile(); return [ [null, null, 'SebastianBergmann\\Comparator\\ScalarComparator'], [null, true, 'SebastianBergmann\\Comparator\\ScalarComparator'], [true, null, 'SebastianBergmann\\Comparator\\ScalarComparator'], [true, true, 'SebastianBergmann\\Comparator\\ScalarComparator'], [false, false, 'SebastianBergmann\\Comparator\\ScalarComparator'], [true, false, 'SebastianBergmann\\Comparator\\ScalarComparator'], [false, true, 'SebastianBergmann\\Comparator\\ScalarComparator'], ['', '', 'SebastianBergmann\\Comparator\\ScalarComparator'], ['0', '0', 'SebastianBergmann\\Comparator\\ScalarComparator'], ['0', 0, 'SebastianBergmann\\Comparator\\NumericComparator'], [0, '0', 'SebastianBergmann\\Comparator\\NumericComparator'], [0, 0, 'SebastianBergmann\\Comparator\\NumericComparator'], [1.0, 0, 'SebastianBergmann\\Comparator\\DoubleComparator'], [0, 1.0, 'SebastianBergmann\\Comparator\\DoubleComparator'], [1.0, 1.0, 'SebastianBergmann\\Comparator\\DoubleComparator'], [[1], [1], 'SebastianBergmann\\Comparator\\ArrayComparator'], [$tmpfile, $tmpfile, 'SebastianBergmann\\Comparator\\ResourceComparator'], [new \stdClass, new \stdClass, 'SebastianBergmann\\Comparator\\ObjectComparator'], [new \DateTime, new \DateTime, 'SebastianBergmann\\Comparator\\DateTimeComparator'], [new \SplObjectStorage, new \SplObjectStorage, 'SebastianBergmann\\Comparator\\SplObjectStorageComparator'], [new \Exception, new \Exception, 'SebastianBergmann\\Comparator\\ExceptionComparator'], [new \DOMDocument, new \DOMDocument, 'SebastianBergmann\\Comparator\\DOMNodeComparator'], // mixed types [$tmpfile, [1], 'SebastianBergmann\\Comparator\\TypeComparator'], [[1], $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'], [$tmpfile, '1', 'SebastianBergmann\\Comparator\\TypeComparator'], ['1', $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'], [$tmpfile, new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'], [new \stdClass, $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'], [new \stdClass, [1], 'SebastianBergmann\\Comparator\\TypeComparator'], [[1], new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'], [new \stdClass, '1', 'SebastianBergmann\\Comparator\\TypeComparator'], ['1', new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'], [new ClassWithToString, '1', 'SebastianBergmann\\Comparator\\ScalarComparator'], ['1', new ClassWithToString, 'SebastianBergmann\\Comparator\\ScalarComparator'], [1.0, new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'], [new \stdClass, 1.0, 'SebastianBergmann\\Comparator\\TypeComparator'], [1.0, [1], 'SebastianBergmann\\Comparator\\TypeComparator'], [[1], 1.0, 'SebastianBergmann\\Comparator\\TypeComparator'], ]; } /** * @dataProvider instanceProvider */ public function testGetComparatorFor($a, $b, $expected): void { $factory = new Factory; $actual = $factory->getComparatorFor($a, $b); $this->assertInstanceOf($expected, $actual); } public function testRegister(): void { $comparator = new TestClassComparator; $factory = new Factory; $factory->register($comparator); $a = new TestClass; $b = new TestClass; $expected = 'SebastianBergmann\\Comparator\\TestClassComparator'; $actual = $factory->getComparatorFor($a, $b); $factory->unregister($comparator); $this->assertInstanceOf($expected, $actual); } public function testUnregister(): void { $comparator = new TestClassComparator; $factory = new Factory; $factory->register($comparator); $factory->unregister($comparator); $a = new TestClass; $b = new TestClass; $expected = 'SebastianBergmann\\Comparator\\ObjectComparator'; $actual = $factory->getComparatorFor($a, $b); $this->assertInstanceOf($expected, $actual); } public function testIsSingleton(): void { $f = Factory::getInstance(); $this->assertSame($f, Factory::getInstance()); } } comparator-3.0.2/tests/MockObjectComparatorTest.php000066400000000000000000000135361332166775600224760ustar00rootroot00000000000000 * * 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); } public function acceptsSucceedsProvider() { $testmock = $this->createMock(TestClass::class); $stdmock = $this->createMock(stdClass::class); return [ [$testmock, $testmock], [$stdmock, $stdmock], [$stdmock, $testmock] ]; } public function acceptsFailsProvider() { $stdmock = $this->createMock(stdClass::class); return [ [$stdmock, null], [null, $stdmock], [null, null] ]; } public function assertEqualsSucceedsProvider() { // cyclic dependencies $book1 = $this->getMockBuilder(Book::class)->setMethods(null)->getMock(); $book1->author = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratchett'])->getMock(); $book1->author->books[] = $book1; $book2 = $this->getMockBuilder(Book::class)->setMethods(null)->getMock(); $book2->author = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratchett'])->getMock(); $book2->author->books[] = $book2; $object1 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock(); $object2 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock(); return [ [$object1, $object1], [$object1, $object2], [$book1, $book1], [$book1, $book2], [ $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([2.3])->getMock(), $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([2.5])->getMock(), 0.5 ] ]; } public function assertEqualsFailsProvider() { $typeMessage = 'is not instance of expected class'; $equalMessage = 'Failed asserting that two objects are equal.'; // cyclic dependencies $book1 = $this->getMockBuilder(Book::class)->setMethods(null)->getMock(); $book1->author = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratchett'])->getMock(); $book1->author->books[] = $book1; $book2 = $this->getMockBuilder(Book::class)->setMethods(null)->getMock(); $book1->author = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratch'])->getMock(); $book2->author->books[] = $book2; $book3 = $this->getMockBuilder(Book::class)->setMethods(null)->getMock(); $book3->author = 'Terry Pratchett'; $book4 = $this->createMock(stdClass::class); $book4->author = 'Terry Pratchett'; $object1 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock(); $object2 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([16, 23, 42])->getMock(); return [ [ $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock(), $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([16, 23, 42])->getMock(), $equalMessage ], [$object1, $object2, $equalMessage], [$book1, $book2, $equalMessage], [$book3, $book4, $typeMessage], [ $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([2.3])->getMock(), $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([4.2])->getMock(), $equalMessage, 0.5 ] ]; } /** * @dataProvider acceptsSucceedsProvider */ public function testAcceptsSucceeds($expected, $actual): void { $this->assertTrue( $this->comparator->accepts($expected, $actual) ); } /** * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual): void { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void { $exception = null; try { $this->comparator->assertEquals($expected, $actual, $delta); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0): void { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage($message); $this->comparator->assertEquals($expected, $actual, $delta); } } comparator-3.0.2/tests/NumericComparatorTest.php000066400000000000000000000055171332166775600220600ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @covers \SebastianBergmann\Comparator\NumericComparator * * @uses \SebastianBergmann\Comparator\Comparator * @uses \SebastianBergmann\Comparator\Factory * @uses \SebastianBergmann\Comparator\ComparisonFailure */ final class NumericComparatorTest extends TestCase { /** * @var NumericComparator */ private $comparator; protected function setUp(): void { $this->comparator = new NumericComparator; } public function acceptsSucceedsProvider() { return [ [5, 10], [8, '0'], ['10', 0], [0x74c3b00c, 42], [0755, 0777] ]; } public function acceptsFailsProvider() { return [ ['5', '10'], [8, 5.0], [5.0, 8], [10, null], [false, 12] ]; } public function assertEqualsSucceedsProvider() { return [ [1337, 1337], ['1337', 1337], [0x539, 1337], [02471, 1337], [1337, 1338, 1], ['1337', 1340, 5], ]; } public function assertEqualsFailsProvider() { return [ [1337, 1338], ['1338', 1337], [0x539, 1338], [1337, 1339, 1], ['1337', 1340, 2], ]; } /** * @dataProvider acceptsSucceedsProvider */ public function testAcceptsSucceeds($expected, $actual): void { $this->assertTrue( $this->comparator->accepts($expected, $actual) ); } /** * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual): void { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0): void { $exception = null; try { $this->comparator->assertEquals($expected, $actual, $delta); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual, $delta = 0.0): void { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage('matches expected'); $this->comparator->assertEquals($expected, $actual, $delta); } } comparator-3.0.2/tests/ObjectComparatorTest.php000066400000000000000000000102331332166775600216530ustar00rootroot00000000000000 * * 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); } } comparator-3.0.2/tests/ResourceComparatorTest.php000066400000000000000000000053751332166775600222470ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @covers \SebastianBergmann\Comparator\ResourceComparator * * @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); } } comparator-3.0.2/tests/ScalarComparatorTest.php000066400000000000000000000114411332166775600216540ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @covers \SebastianBergmann\Comparator\ScalarComparator * * @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); } } comparator-3.0.2/tests/SplObjectStorageComparatorTest.php000066400000000000000000000072461332166775600236710ustar00rootroot00000000000000 * * 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()); } } comparator-3.0.2/tests/TypeComparatorTest.php000066400000000000000000000047451332166775600214010ustar00rootroot00000000000000 * * 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); } } comparator-3.0.2/tests/_fixture/000077500000000000000000000000001332166775600166725ustar00rootroot00000000000000comparator-3.0.2/tests/_fixture/Author.php000066400000000000000000000010061332166775600206420ustar00rootroot00000000000000 * * 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; } } comparator-3.0.2/tests/_fixture/Book.php000066400000000000000000000006231332166775600202760ustar00rootroot00000000000000 * * 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; } comparator-3.0.2/tests/_fixture/ClassWithToString.php000066400000000000000000000006131332166775600227760ustar00rootroot00000000000000 * * 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'; } } comparator-3.0.2/tests/_fixture/SampleClass.php000066400000000000000000000007761332166775600216240ustar00rootroot00000000000000 * * 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; } } comparator-3.0.2/tests/_fixture/Struct.php000066400000000000000000000006371332166775600206750ustar00rootroot00000000000000 * * 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; } } comparator-3.0.2/tests/_fixture/TestClass.php000066400000000000000000000004561332166775600213150ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; class TestClass { } comparator-3.0.2/tests/_fixture/TestClassComparator.php000066400000000000000000000005211332166775600233360ustar00rootroot00000000000000 * * 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 { }