pax_global_header00006660000000000000000000000064132346151060014513gustar00rootroot0000000000000052 comment=34369daee48eafb2651bea869b4b15d75ccc35f9 comparator-2.1.3/000077500000000000000000000000001323461510600136655ustar00rootroot00000000000000comparator-2.1.3/.gitignore000066400000000000000000000000551323461510600156550ustar00rootroot00000000000000/.idea /.php_cs.cache /composer.lock /vendor comparator-2.1.3/.php_cs.dist000066400000000000000000000062421323461510600161100ustar00rootroot00000000000000 For the full copyright and license information, please view the LICENSE file that was distributed with this source code. EOF; return PhpCsFixer\Config::create() ->setRiskyAllowed(true) ->setRules( [ 'array_syntax' => ['syntax' => 'short'], 'binary_operator_spaces' => [ 'align_double_arrow' => true, 'align_equals' => true ], 'blank_line_after_namespace' => true, 'blank_line_before_statement' => [ 'statements' => [ 'break', 'continue', 'return', 'throw', 'try', ], ], 'braces' => true, 'cast_spaces' => true, 'concat_space' => ['spacing' => 'one'], 'elseif' => true, 'encoding' => true, 'full_opening_tag' => true, 'function_declaration' => true, 'header_comment' => ['header' => $header, 'separate' => 'none'], 'indentation_type' => true, 'line_ending' => true, 'lowercase_constants' => true, 'lowercase_keywords' => true, 'method_argument_space' => true, 'native_function_invocation' => true, 'no_alias_functions' => true, 'no_blank_lines_after_class_opening' => true, 'no_blank_lines_after_phpdoc' => true, 'no_closing_tag' => true, 'no_empty_phpdoc' => true, 'no_empty_statement' => true, 'no_extra_consecutive_blank_lines' => true, 'no_leading_namespace_whitespace' => true, 'no_singleline_whitespace_before_semicolons' => true, 'no_spaces_after_function_name' => true, 'no_spaces_inside_parenthesis' => true, 'no_trailing_comma_in_list_call' => true, 'no_trailing_whitespace' => true, 'no_unused_imports' => true, 'no_whitespace_in_blank_line' => true, 'ordered_imports' => true, 'phpdoc_align' => true, 'phpdoc_indent' => true, 'phpdoc_no_access' => true, 'phpdoc_no_empty_return' => true, 'phpdoc_no_package' => true, 'phpdoc_scalar' => true, 'phpdoc_separation' => true, 'phpdoc_to_comment' => true, 'phpdoc_trim' => true, 'phpdoc_types' => true, 'phpdoc_var_without_name' => true, 'self_accessor' => true, 'simplified_null_return' => true, 'single_blank_line_at_eof' => true, 'single_import_per_statement' => true, 'single_line_after_imports' => true, 'single_quote' => true, 'ternary_operator_spaces' => true, 'trim_array_spaces' => true, 'visibility_required' => true, ] ) ->setFinder( PhpCsFixer\Finder::create() ->files() ->in(__DIR__ . '/src') ->in(__DIR__ . '/tests') ->name('*.php') ); comparator-2.1.3/.travis.yml000066400000000000000000000012511323461510600157750ustar00rootroot00000000000000language: php sudo: false php: - 7.0 - 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-2.1.3/ChangeLog.md000066400000000000000000000017401323461510600160400ustar00rootroot00000000000000# ChangeLog All notable changes are documented in this file using the [Keep a CHANGELOG](http://keepachangelog.com/) principles. ## [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` [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-2.1.3/LICENSE000066400000000000000000000030111323461510600146650ustar00rootroot00000000000000Comparator Copyright (c) 2002-2017, 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-2.1.3/README.md000066400000000000000000000021671323461510600151520ustar00rootroot00000000000000[![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-2.1.3/build.xml000066400000000000000000000013701323461510600155070ustar00rootroot00000000000000 comparator-2.1.3/composer.json000066400000000000000000000024031323461510600164060ustar00rootroot00000000000000{ "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.0", "sebastian/diff": "^2.0 || ^3.0", "sebastian/exporter": "^3.1" }, "require-dev": { "phpunit/phpunit": "^6.4" }, "config": { "optimize-autoloader": true, "sort-packages": true }, "autoload": { "classmap": [ "src/" ] }, "autoload-dev": { "classmap": [ "tests/_fixture" ] }, "extra": { "branch-alias": { "dev-master": "2.1.x-dev" } } } comparator-2.1.3/phpunit.xml000066400000000000000000000012171323461510600160770ustar00rootroot00000000000000 tests src comparator-2.1.3/src/000077500000000000000000000000001323461510600144545ustar00rootroot00000000000000comparator-2.1.3/src/ArrayComparator.php000066400000000000000000000102111323461510600202660ustar00rootroot00000000000000 * * 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-2.1.3/src/Comparator.php000066400000000000000000000032141323461510600172740ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use SebastianBergmann\Exporter\Exporter; /** * Abstract base class for comparators which compare values for equality. */ abstract class Comparator { /** * @var Factory */ protected $factory; /** * @var Exporter */ protected $exporter; public function __construct() { $this->exporter = new Exporter; } /** * @param Factory $factory */ public function setFactory(Factory $factory) { $this->factory = $factory; } /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ abstract public function accepts($expected, $actual); /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * * @throws ComparisonFailure */ abstract public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false); } comparator-2.1.3/src/ComparisonFailure.php000066400000000000000000000057731323461510600206230ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use SebastianBergmann\Diff\Differ; use SebastianBergmann\Diff\Output\UnifiedDiffOutputBuilder; /** * Thrown when an assertion for string equality failed. */ class ComparisonFailure extends \RuntimeException { /** * Expected value of the retrieval which does not match $actual. * * @var mixed */ protected $expected; /** * Actually retrieved value which does not match $expected. * * @var mixed */ protected $actual; /** * The string representation of the expected value * * @var string */ protected $expectedAsString; /** * The string representation of the actual value * * @var string */ protected $actualAsString; /** * @var bool */ protected $identical; /** * Optional message which is placed in front of the first line * returned by toString(). * * @var string */ protected $message; /** * Initialises with the expected value and the actual value. * * @param mixed $expected Expected value retrieved. * @param mixed $actual Actual value retrieved. * @param string $expectedAsString * @param string $actualAsString * @param bool $identical * @param string $message A string which is prefixed on all returned lines * in the difference output. */ public function __construct($expected, $actual, $expectedAsString, $actualAsString, $identical = false, $message = '') { $this->expected = $expected; $this->actual = $actual; $this->expectedAsString = $expectedAsString; $this->actualAsString = $actualAsString; $this->message = $message; } /** * @return mixed */ public function getActual() { return $this->actual; } /** * @return mixed */ public function getExpected() { return $this->expected; } /** * @return string */ public function getActualAsString() { return $this->actualAsString; } /** * @return string */ public function getExpectedAsString() { return $this->expectedAsString; } /** * @return string */ public function getDiff() { if (!$this->actualAsString && !$this->expectedAsString) { return ''; } $differ = new Differ(new UnifiedDiffOutputBuilder("\n--- Expected\n+++ Actual\n")); return $differ->diff($this->expectedAsString, $this->actualAsString); } /** * @return string */ public function toString() { return $this->message . $this->getDiff(); } } comparator-2.1.3/src/DOMNodeComparator.php000066400000000000000000000053501323461510600204450ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use DOMDocument; use DOMNode; /** * Compares DOMNode instances for equality. */ class DOMNodeComparator extends ObjectComparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return $expected instanceof DOMNode && $actual instanceof DOMNode; } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * @param array $processed List of already processed elements (used to prevent infinite recursion) * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = []) { $expectedAsString = $this->nodeToText($expected, true, $ignoreCase); $actualAsString = $this->nodeToText($actual, true, $ignoreCase); if ($expectedAsString !== $actualAsString) { $type = $expected instanceof DOMDocument ? 'documents' : 'nodes'; throw new ComparisonFailure( $expected, $actual, $expectedAsString, $actualAsString, false, \sprintf("Failed asserting that two DOM %s are equal.\n", $type) ); } } /** * Returns the normalized, whitespace-cleaned, and indented textual * representation of a DOMNode. */ private function nodeToText(DOMNode $node, bool $canonicalize, bool $ignoreCase): string { if ($canonicalize) { $document = new DOMDocument; @$document->loadXML($node->C14N()); $node = $document; } $document = $node instanceof DOMDocument ? $node : $node->ownerDocument; $document->formatOutput = true; $document->normalizeDocument(); $text = $node instanceof DOMDocument ? $node->saveXML() : $document->saveXML($node); return $ignoreCase ? $text : \strtolower($text); } } comparator-2.1.3/src/DateTimeComparator.php000066400000000000000000000055331323461510600207170ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares DateTimeInterface instances for equality. */ class DateTimeComparator extends ObjectComparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { return ($expected instanceof \DateTime || $expected instanceof \DateTimeInterface) && ($actual instanceof \DateTime || $actual instanceof \DateTimeInterface); } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * @param array $processed List of already processed elements (used to prevent infinite recursion) * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = []) { /** @var \DateTimeInterface $expected */ /** @var \DateTimeInterface $actual */ $delta = new \DateInterval(\sprintf('PT%dS', \abs($delta))); $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-2.1.3/src/DoubleComparator.php000066400000000000000000000031651323461510600204340ustar00rootroot00000000000000 * * 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-2.1.3/src/ExceptionComparator.php000066400000000000000000000023401323461510600211520ustar00rootroot00000000000000 * * 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-2.1.3/src/Factory.php000066400000000000000000000074331323461510600166030ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Factory for comparators which compare values for equality. */ class Factory { /** * @var Comparator[] */ private $customComparators = []; /** * @var Comparator[] */ private $defaultComparators = []; /** * @var Factory */ private static $instance; /** * @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 TypeComparator); $this->registerDefaultComparator(new ScalarComparator); $this->registerDefaultComparator(new NumericComparator); $this->registerDefaultComparator(new DoubleComparator); $this->registerDefaultComparator(new ArrayComparator); $this->registerDefaultComparator(new ResourceComparator); $this->registerDefaultComparator(new ObjectComparator); $this->registerDefaultComparator(new ExceptionComparator); $this->registerDefaultComparator(new SplObjectStorageComparator); $this->registerDefaultComparator(new DOMNodeComparator); $this->registerDefaultComparator(new MockObjectComparator); $this->registerDefaultComparator(new DateTimeComparator); } private function registerDefaultComparator(Comparator $comparator) { \array_unshift($this->defaultComparators, $comparator); $comparator->setFactory($this); } } comparator-2.1.3/src/MockObjectComparator.php000066400000000000000000000025211323461510600212350ustar00rootroot00000000000000 * * 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-2.1.3/src/NumericComparator.php000066400000000000000000000043061323461510600206220ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares numerical values for equality. */ class NumericComparator extends ScalarComparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool */ public function accepts($expected, $actual) { // all numerical values, but not if one of them is a double // or both of them are strings return \is_numeric($expected) && \is_numeric($actual) && !(\is_float($expected) || \is_float($actual)) && !(\is_string($expected) && \is_string($actual)); } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) { if (\is_infinite($actual) && \is_infinite($expected)) { return; } if ((\is_infinite($actual) xor \is_infinite($expected)) || (\is_nan($actual) or \is_nan($expected)) || \abs($actual - $expected) > $delta) { throw new ComparisonFailure( $expected, $actual, '', '', false, \sprintf( 'Failed asserting that %s matches expected %s.', $this->exporter->export($actual), $this->exporter->export($expected) ) ); } } } comparator-2.1.3/src/ObjectComparator.php000066400000000000000000000070311323461510600204240ustar00rootroot00000000000000 * * 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-2.1.3/src/ResourceComparator.php000066400000000000000000000030571323461510600210110ustar00rootroot00000000000000 * * 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-2.1.3/src/ScalarComparator.php000066400000000000000000000062201323461510600204220ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares scalar or NULL values for equality. */ class ScalarComparator extends Comparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * * @return bool * * @since Method available since Release 3.6.0 */ public function accepts($expected, $actual) { return ((\is_scalar($expected) xor null === $expected) && (\is_scalar($actual) xor null === $actual)) // allow comparison between strings and objects featuring __toString() || (\is_string($expected) && \is_object($actual) && \method_exists($actual, '__toString')) || (\is_object($expected) && \method_exists($expected, '__toString') && \is_string($actual)); } /** * Asserts that two values are equal. * * @param mixed $expected First value to compare * @param mixed $actual Second value to compare * @param float $delta Allowed numerical distance between two values to consider them equal * @param bool $canonicalize Arrays are sorted before comparison when set to true * @param bool $ignoreCase Case is ignored when set to true * * @throws ComparisonFailure */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) { $expectedToCompare = $expected; $actualToCompare = $actual; // always compare as strings to avoid strange behaviour // otherwise 0 == 'Foobar' if (\is_string($expected) || \is_string($actual)) { $expectedToCompare = (string) $expectedToCompare; $actualToCompare = (string) $actualToCompare; if ($ignoreCase) { $expectedToCompare = \strtolower($expectedToCompare); $actualToCompare = \strtolower($actualToCompare); } } if ($expectedToCompare != $actualToCompare) { if (\is_string($expected) && \is_string($actual)) { throw new ComparisonFailure( $expected, $actual, $this->exporter->export($expected), $this->exporter->export($actual), false, 'Failed asserting that two strings are equal.' ); } throw new ComparisonFailure( $expected, $actual, // no diff is required '', '', false, \sprintf( 'Failed asserting that %s matches expected %s.', $this->exporter->export($actual), $this->exporter->export($expected) ) ); } } } comparator-2.1.3/src/SplObjectStorageComparator.php000066400000000000000000000043311323461510600224300ustar00rootroot00000000000000 * * 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-2.1.3/src/TypeComparator.php000066400000000000000000000033471323461510600201450ustar00rootroot00000000000000 * * 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-2.1.3/tests/000077500000000000000000000000001323461510600150275ustar00rootroot00000000000000comparator-2.1.3/tests/ArrayComparatorTest.php000066400000000000000000000070701323461510600215120ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @coversDefaultClass SebastianBergmann\Comparator\ArrayComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class ArrayComparatorTest extends TestCase { /** * @var ArrayComparator */ private $comparator; protected function setUp() { $this->comparator = new ArrayComparator; $this->comparator->setFactory(new Factory); } public function acceptsFailsProvider() { return [ [[], null], [null, []], [null, null] ]; } public function assertEqualsSucceedsProvider() { return [ [ ['a' => 1, 'b' => 2], ['b' => 2, 'a' => 1] ], [ [1], ['1'] ], [ [3, 2, 1], [2, 3, 1], 0, true ], [ [2.3], [2.5], 0.5 ], [ [[2.3]], [[2.5]], 0.5 ], [ [new Struct(2.3)], [new Struct(2.5)], 0.5 ], ]; } public function assertEqualsFailsProvider() { return [ [ [], [0 => 1] ], [ [0 => 1], [] ], [ [0 => null], [] ], [ [0 => 1, 1 => 2], [0 => 1, 1 => 3] ], [ ['a', 'b' => [1, 2]], ['a', 'b' => [2, 1]] ], [ [2.3], [4.2], 0.5 ], [ [[2.3]], [[4.2]], 0.5 ], [ [new Struct(2.3)], [new Struct(4.2)], 0.5 ] ]; } /** * @covers ::accepts */ public function testAcceptsSucceeds() { $this->assertTrue( $this->comparator->accepts([], []) ); } /** * @covers ::accepts * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual) { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0, $canonicalize = false) { $exception = null; try { $this->comparator->assertEquals($expected, $actual, $delta, $canonicalize); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual, $delta = 0.0, $canonicalize = false) { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage('Failed asserting that two arrays are equal'); $this->comparator->assertEquals($expected, $actual, $delta, $canonicalize); } } comparator-2.1.3/tests/ComparisonFailureTest.php000066400000000000000000000027111323461510600220230ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @covers SebastianBergmann\Comparator\ComparisonFailure */ final class ComparisonFailureTest extends TestCase { public function testComparisonFailure() { $actual = "\nB\n"; $expected = "\nA\n"; $message = 'Test message'; $failure = new ComparisonFailure( $expected, $actual, '|' . $expected, '|' . $actual, false, $message ); $this->assertSame($actual, $failure->getActual()); $this->assertSame($expected, $failure->getExpected()); $this->assertSame('|' . $actual, $failure->getActualAsString()); $this->assertSame('|' . $expected, $failure->getExpectedAsString()); $diff = ' --- Expected +++ Actual @@ @@ | -A +B '; $this->assertSame($diff, $failure->getDiff()); $this->assertSame($message . $diff, $failure->toString()); } public function testDiffNotPossible() { $failure = new ComparisonFailure('a', 'b', false, false, true, 'test'); $this->assertSame('', $failure->getDiff()); $this->assertSame('test', $failure->toString()); } } comparator-2.1.3/tests/DOMNodeComparatorTest.php000066400000000000000000000102361323461510600216570ustar00rootroot00000000000000 * * 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; /** * @coversDefaultClass SebastianBergmann\Comparator\DOMNodeComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class DOMNodeComparatorTest extends TestCase { private $comparator; protected function setUp() { $this->comparator = new DOMNodeComparator; } public function acceptsSucceedsProvider() { $document = new DOMDocument; $node = new DOMNode; return [ [$document, $document], [$node, $node], [$document, $node], [$node, $document] ]; } public function acceptsFailsProvider() { $document = new DOMDocument; return [ [$document, null], [null, $document], [null, null] ]; } public function assertEqualsSucceedsProvider() { return [ [ $this->createDOMDocument(''), $this->createDOMDocument('') ], [ $this->createDOMDocument(''), $this->createDOMDocument('') ], [ $this->createDOMDocument(''), $this->createDOMDocument('') ], [ $this->createDOMDocument("\n \n"), $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 ') ] ]; } private function createDOMDocument($content) { $document = new DOMDocument; $document->preserveWhiteSpace = false; $document->loadXML($content); return $document; } /** * @covers ::accepts * @dataProvider acceptsSucceedsProvider */ public function testAcceptsSucceeds($expected, $actual) { $this->assertTrue( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::accepts * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual) { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual) { $exception = null; try { $this->comparator->assertEquals($expected, $actual); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual) { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage('Failed asserting that two DOM'); $this->comparator->assertEquals($expected, $actual); } } comparator-2.1.3/tests/DateTimeComparatorTest.php000066400000000000000000000161431323461510600221310ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use DateTime; use DateTimeImmutable; use DateTimeZone; use PHPUnit\Framework\TestCase; /** * @coversDefaultClass SebastianBergmann\Comparator\DateTimeComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class DateTimeComparatorTest extends TestCase { /** * @var DateTimeComparator */ private $comparator; protected function setUp() { $this->comparator = new DateTimeComparator; } public function acceptsFailsProvider() { $datetime = new DateTime; return [ [$datetime, null], [null, $datetime], [null, null] ]; } public function assertEqualsSucceedsProvider() { return [ [ new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')), new DateTime('2013-03-29 04:13: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 ], ]; } public function assertEqualsFailsProvider() { return [ [ new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')), new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/New_York')) ], [ new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')), new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/New_York')), 3500 ], [ new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')), new DateTime('2013-03-29 05:13:35', new DateTimeZone('America/New_York')), 3500 ], [ new DateTime('2013-03-29', new DateTimeZone('America/New_York')), new DateTime('2013-03-30', new DateTimeZone('America/New_York')) ], [ new DateTime('2013-03-29', new DateTimeZone('America/New_York')), new DateTime('2013-03-30', new DateTimeZone('America/New_York')), 43200 ], [ new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')), new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/Chicago')), ], [ new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')), new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/Chicago')), 3500 ], [ new DateTime('2013-03-30', new DateTimeZone('America/New_York')), new DateTime('2013-03-30', new DateTimeZone('America/Chicago')) ], [ new DateTime('2013-03-29T05:13:35-0600'), new DateTime('2013-03-29T04:13:35-0600') ], [ new DateTime('2013-03-29T05:13:35-0600'), new DateTime('2013-03-29T05:13:35-0500') ], ]; } /** * @covers ::accepts */ public function testAcceptsSucceeds() { $this->assertTrue( $this->comparator->accepts( new DateTime, new DateTime ) ); } /** * @covers ::accepts * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual) { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0) { $exception = null; try { $this->comparator->assertEquals($expected, $actual, $delta); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual, $delta = 0.0) { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage('Failed asserting that two DateTime objects are equal.'); $this->comparator->assertEquals($expected, $actual, $delta); } /** * @requires PHP 5.5 * @covers ::accepts */ public function testAcceptsDateTimeInterface() { $this->assertTrue($this->comparator->accepts(new DateTime, new DateTimeImmutable)); } /** * @requires PHP 5.5 * @covers ::assertEquals */ public function testSupportsDateTimeInterface() { $this->assertNull( $this->comparator->assertEquals( new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')), new DateTimeImmutable('2013-03-29 04:13:35', new DateTimeZone('America/New_York')) ) ); } } comparator-2.1.3/tests/DoubleComparatorTest.php000066400000000000000000000062251323461510600216470ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @coversDefaultClass SebastianBergmann\Comparator\DoubleComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class DoubleComparatorTest extends TestCase { private $comparator; protected function setUp() { $this->comparator = new DoubleComparator; } public function acceptsSucceedsProvider() { return [ [0, 5.0], [5.0, 0], ['5', 4.5], [1.2e3, 7E-10], [3, \acos(8)], [\acos(8), 3], [\acos(8), \acos(8)] ]; } public function acceptsFailsProvider() { return [ [5, 5], ['4.5', 5], [0x539, 02471], [5.0, false], [null, 5.0] ]; } public function assertEqualsSucceedsProvider() { return [ [2.3, 2.3], ['2.3', 2.3], [5.0, 5], [5, 5.0], [5.0, '5'], [1.2e3, 1200], [2.3, 2.5, 0.5], [3, 3.05, 0.05], [1.2e3, 1201, 1], [(string) (1 / 3), 1 - 2 / 3], [1 / 3, (string) (1 - 2 / 3)] ]; } public function assertEqualsFailsProvider() { return [ [2.3, 4.2], ['2.3', 4.2], [5.0, '4'], [5.0, 6], [1.2e3, 1201], [2.3, 2.5, 0.2], [3, 3.05, 0.04], [3, \acos(8)], [\acos(8), 3], [\acos(8), \acos(8)] ]; } /** * @covers ::accepts * @dataProvider acceptsSucceedsProvider */ public function testAcceptsSucceeds($expected, $actual) { $this->assertTrue( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::accepts * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual) { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0) { $exception = null; try { $this->comparator->assertEquals($expected, $actual, $delta); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual, $delta = 0.0) { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage('matches expected'); $this->comparator->assertEquals($expected, $actual, $delta); } } comparator-2.1.3/tests/ExceptionComparatorTest.php000066400000000000000000000071601323461510600223720ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use \Exception; use \RuntimeException; use PHPUnit\Framework\TestCase; /** * @coversDefaultClass SebastianBergmann\Comparator\ExceptionComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class ExceptionComparatorTest extends TestCase { private $comparator; protected function setUp() { $this->comparator = new ExceptionComparator; $this->comparator->setFactory(new Factory); } public function acceptsSucceedsProvider() { return [ [new Exception, new Exception], [new RuntimeException, new RuntimeException], [new Exception, new RuntimeException] ]; } public function acceptsFailsProvider() { return [ [new Exception, null], [null, new Exception], [null, null] ]; } public function assertEqualsSucceedsProvider() { $exception1 = new Exception; $exception2 = new Exception; $exception3 = new RuntimeException('Error', 100); $exception4 = new RuntimeException('Error', 100); return [ [$exception1, $exception1], [$exception1, $exception2], [$exception3, $exception3], [$exception3, $exception4] ]; } public function assertEqualsFailsProvider() { $typeMessage = 'not instance of expected class'; $equalMessage = 'Failed asserting that two objects are equal.'; $exception1 = new Exception('Error', 100); $exception2 = new Exception('Error', 101); $exception3 = new Exception('Errors', 101); $exception4 = new RuntimeException('Error', 100); $exception5 = new RuntimeException('Error', 101); return [ [$exception1, $exception2, $equalMessage], [$exception1, $exception3, $equalMessage], [$exception1, $exception4, $typeMessage], [$exception2, $exception3, $equalMessage], [$exception4, $exception5, $equalMessage] ]; } /** * @covers ::accepts * @dataProvider acceptsSucceedsProvider */ public function testAcceptsSucceeds($expected, $actual) { $this->assertTrue( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::accepts * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual) { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual) { $exception = null; try { $this->comparator->assertEquals($expected, $actual); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual, $message) { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage($message); $this->comparator->assertEquals($expected, $actual); } } comparator-2.1.3/tests/FactoryTest.php000066400000000000000000000123411323461510600200100ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @coversDefaultClass SebastianBergmann\Comparator\Factory * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class FactoryTest extends TestCase { public function instanceProvider() { $tmpfile = \tmpfile(); return [ [null, null, 'SebastianBergmann\\Comparator\\ScalarComparator'], [null, true, 'SebastianBergmann\\Comparator\\ScalarComparator'], [true, null, 'SebastianBergmann\\Comparator\\ScalarComparator'], [true, true, 'SebastianBergmann\\Comparator\\ScalarComparator'], [false, false, 'SebastianBergmann\\Comparator\\ScalarComparator'], [true, false, 'SebastianBergmann\\Comparator\\ScalarComparator'], [false, true, 'SebastianBergmann\\Comparator\\ScalarComparator'], ['', '', 'SebastianBergmann\\Comparator\\ScalarComparator'], ['0', '0', 'SebastianBergmann\\Comparator\\ScalarComparator'], ['0', 0, 'SebastianBergmann\\Comparator\\NumericComparator'], [0, '0', 'SebastianBergmann\\Comparator\\NumericComparator'], [0, 0, 'SebastianBergmann\\Comparator\\NumericComparator'], [1.0, 0, 'SebastianBergmann\\Comparator\\DoubleComparator'], [0, 1.0, 'SebastianBergmann\\Comparator\\DoubleComparator'], [1.0, 1.0, 'SebastianBergmann\\Comparator\\DoubleComparator'], [[1], [1], 'SebastianBergmann\\Comparator\\ArrayComparator'], [$tmpfile, $tmpfile, 'SebastianBergmann\\Comparator\\ResourceComparator'], [new \stdClass, new \stdClass, 'SebastianBergmann\\Comparator\\ObjectComparator'], [new \DateTime, new \DateTime, 'SebastianBergmann\\Comparator\\DateTimeComparator'], [new \SplObjectStorage, new \SplObjectStorage, 'SebastianBergmann\\Comparator\\SplObjectStorageComparator'], [new \Exception, new \Exception, 'SebastianBergmann\\Comparator\\ExceptionComparator'], [new \DOMDocument, new \DOMDocument, 'SebastianBergmann\\Comparator\\DOMNodeComparator'], // mixed types [$tmpfile, [1], 'SebastianBergmann\\Comparator\\TypeComparator'], [[1], $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'], [$tmpfile, '1', 'SebastianBergmann\\Comparator\\TypeComparator'], ['1', $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'], [$tmpfile, new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'], [new \stdClass, $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'], [new \stdClass, [1], 'SebastianBergmann\\Comparator\\TypeComparator'], [[1], new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'], [new \stdClass, '1', 'SebastianBergmann\\Comparator\\TypeComparator'], ['1', new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'], [new ClassWithToString, '1', 'SebastianBergmann\\Comparator\\ScalarComparator'], ['1', new ClassWithToString, 'SebastianBergmann\\Comparator\\ScalarComparator'], [1.0, new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'], [new \stdClass, 1.0, 'SebastianBergmann\\Comparator\\TypeComparator'], [1.0, [1], 'SebastianBergmann\\Comparator\\TypeComparator'], [[1], 1.0, 'SebastianBergmann\\Comparator\\TypeComparator'], ]; } /** * @dataProvider instanceProvider * @covers ::getComparatorFor * @covers ::__construct */ public function testGetComparatorFor($a, $b, $expected) { $factory = new Factory; $actual = $factory->getComparatorFor($a, $b); $this->assertInstanceOf($expected, $actual); } /** * @covers ::register */ public function testRegister() { $comparator = new TestClassComparator; $factory = new Factory; $factory->register($comparator); $a = new TestClass; $b = new TestClass; $expected = 'SebastianBergmann\\Comparator\\TestClassComparator'; $actual = $factory->getComparatorFor($a, $b); $factory->unregister($comparator); $this->assertInstanceOf($expected, $actual); } /** * @covers ::unregister */ public function testUnregister() { $comparator = new TestClassComparator; $factory = new Factory; $factory->register($comparator); $factory->unregister($comparator); $a = new TestClass; $b = new TestClass; $expected = 'SebastianBergmann\\Comparator\\ObjectComparator'; $actual = $factory->getComparatorFor($a, $b); $this->assertInstanceOf($expected, $actual); } public function testIsSingleton() { $f = Factory::getInstance(); $this->assertSame($f, Factory::getInstance()); } } comparator-2.1.3/tests/MockObjectComparatorTest.php000066400000000000000000000135001323461510600224470ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; use stdClass; /** * @coversDefaultClass SebastianBergmann\Comparator\MockObjectComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class MockObjectComparatorTest extends TestCase { private $comparator; protected function setUp() { $this->comparator = new MockObjectComparator; $this->comparator->setFactory(new Factory); } public function acceptsSucceedsProvider() { $testmock = $this->createMock(TestClass::class); $stdmock = $this->createMock(stdClass::class); return [ [$testmock, $testmock], [$stdmock, $stdmock], [$stdmock, $testmock] ]; } public function acceptsFailsProvider() { $stdmock = $this->createMock(stdClass::class); return [ [$stdmock, null], [null, $stdmock], [null, null] ]; } public function assertEqualsSucceedsProvider() { // cyclic dependencies $book1 = $this->getMockBuilder(Book::class)->setMethods(null)->getMock(); $book1->author = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratchett'])->getMock(); $book1->author->books[] = $book1; $book2 = $this->getMockBuilder(Book::class)->setMethods(null)->getMock(); $book2->author = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratchett'])->getMock(); $book2->author->books[] = $book2; $object1 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock(); $object2 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock(); return [ [$object1, $object1], [$object1, $object2], [$book1, $book1], [$book1, $book2], [ $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([2.3])->getMock(), $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([2.5])->getMock(), 0.5 ] ]; } public function assertEqualsFailsProvider() { $typeMessage = 'is not instance of expected class'; $equalMessage = 'Failed asserting that two objects are equal.'; // cyclic dependencies $book1 = $this->getMockBuilder(Book::class)->setMethods(null)->getMock(); $book1->author = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratchett'])->getMock(); $book1->author->books[] = $book1; $book2 = $this->getMockBuilder(Book::class)->setMethods(null)->getMock(); $book1->author = $this->getMockBuilder(Author::class)->setMethods(null)->setConstructorArgs(['Terry Pratch'])->getMock(); $book2->author->books[] = $book2; $book3 = $this->getMockBuilder(Book::class)->setMethods(null)->getMock(); $book3->author = 'Terry Pratchett'; $book4 = $this->createMock(stdClass::class); $book4->author = 'Terry Pratchett'; $object1 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock(); $object2 = $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([16, 23, 42])->getMock(); return [ [ $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock(), $this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([16, 23, 42])->getMock(), $equalMessage ], [$object1, $object2, $equalMessage], [$book1, $book2, $equalMessage], [$book3, $book4, $typeMessage], [ $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([2.3])->getMock(), $this->getMockBuilder(Struct::class)->setMethods(null)->setConstructorArgs([4.2])->getMock(), $equalMessage, 0.5 ] ]; } /** * @covers ::accepts * @dataProvider acceptsSucceedsProvider */ public function testAcceptsSucceeds($expected, $actual) { $this->assertTrue( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::accepts * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual) { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0) { $exception = null; try { $this->comparator->assertEquals($expected, $actual, $delta); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0) { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage($message); $this->comparator->assertEquals($expected, $actual, $delta); } } comparator-2.1.3/tests/NumericComparatorTest.php000066400000000000000000000055301323461510600220350ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @coversDefaultClass SebastianBergmann\Comparator\NumericComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class NumericComparatorTest extends TestCase { private $comparator; protected function setUp() { $this->comparator = new NumericComparator; } public function acceptsSucceedsProvider() { return [ [5, 10], [8, '0'], ['10', 0], [0x74c3b00c, 42], [0755, 0777] ]; } public function acceptsFailsProvider() { return [ ['5', '10'], [8, 5.0], [5.0, 8], [10, null], [false, 12] ]; } public function assertEqualsSucceedsProvider() { return [ [1337, 1337], ['1337', 1337], [0x539, 1337], [02471, 1337], [1337, 1338, 1], ['1337', 1340, 5], ]; } public function assertEqualsFailsProvider() { return [ [1337, 1338], ['1338', 1337], [0x539, 1338], [1337, 1339, 1], ['1337', 1340, 2], ]; } /** * @covers ::accepts * @dataProvider acceptsSucceedsProvider */ public function testAcceptsSucceeds($expected, $actual) { $this->assertTrue( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::accepts * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual) { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0) { $exception = null; try { $this->comparator->assertEquals($expected, $actual, $delta); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual, $delta = 0.0) { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage('matches expected'); $this->comparator->assertEquals($expected, $actual, $delta); } } comparator-2.1.3/tests/ObjectComparatorTest.php000066400000000000000000000102571323461510600216430ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; use stdClass; /** * @coversDefaultClass SebastianBergmann\Comparator\ObjectComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class ObjectComparatorTest extends TestCase { private $comparator; protected function setUp() { $this->comparator = new ObjectComparator; $this->comparator->setFactory(new Factory); } public function acceptsSucceedsProvider() { return [ [new TestClass, new TestClass], [new stdClass, new stdClass], [new stdClass, new TestClass] ]; } public function acceptsFailsProvider() { return [ [new stdClass, null], [null, new stdClass], [null, null] ]; } public function assertEqualsSucceedsProvider() { // cyclic dependencies $book1 = new Book; $book1->author = new Author('Terry Pratchett'); $book1->author->books[] = $book1; $book2 = new Book; $book2->author = new Author('Terry Pratchett'); $book2->author->books[] = $book2; $object1 = new SampleClass(4, 8, 15); $object2 = new SampleClass(4, 8, 15); return [ [$object1, $object1], [$object1, $object2], [$book1, $book1], [$book1, $book2], [new Struct(2.3), new Struct(2.5), 0.5] ]; } public function assertEqualsFailsProvider() { $typeMessage = 'is not instance of expected class'; $equalMessage = 'Failed asserting that two objects are equal.'; // cyclic dependencies $book1 = new Book; $book1->author = new Author('Terry Pratchett'); $book1->author->books[] = $book1; $book2 = new Book; $book2->author = new Author('Terry Pratch'); $book2->author->books[] = $book2; $book3 = new Book; $book3->author = 'Terry Pratchett'; $book4 = new stdClass; $book4->author = 'Terry Pratchett'; $object1 = new SampleClass(4, 8, 15); $object2 = new SampleClass(16, 23, 42); return [ [new SampleClass(4, 8, 15), new SampleClass(16, 23, 42), $equalMessage], [$object1, $object2, $equalMessage], [$book1, $book2, $equalMessage], [$book3, $book4, $typeMessage], [new Struct(2.3), new Struct(4.2), $equalMessage, 0.5] ]; } /** * @covers ::accepts * @dataProvider acceptsSucceedsProvider */ public function testAcceptsSucceeds($expected, $actual) { $this->assertTrue( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::accepts * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual) { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual, $delta = 0.0) { $exception = null; try { $this->comparator->assertEquals($expected, $actual, $delta); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0) { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage($message); $this->comparator->assertEquals($expected, $actual, $delta); } } comparator-2.1.3/tests/ResourceComparatorTest.php000066400000000000000000000054331323461510600222240ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @coversDefaultClass SebastianBergmann\Comparator\ResourceComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class ResourceComparatorTest extends TestCase { private $comparator; protected function setUp() { $this->comparator = new ResourceComparator; } public function acceptsSucceedsProvider() { $tmpfile1 = \tmpfile(); $tmpfile2 = \tmpfile(); return [ [$tmpfile1, $tmpfile1], [$tmpfile2, $tmpfile2], [$tmpfile1, $tmpfile2] ]; } public function acceptsFailsProvider() { $tmpfile1 = \tmpfile(); return [ [$tmpfile1, null], [null, $tmpfile1], [null, null] ]; } public function assertEqualsSucceedsProvider() { $tmpfile1 = \tmpfile(); $tmpfile2 = \tmpfile(); return [ [$tmpfile1, $tmpfile1], [$tmpfile2, $tmpfile2] ]; } public function assertEqualsFailsProvider() { $tmpfile1 = \tmpfile(); $tmpfile2 = \tmpfile(); return [ [$tmpfile1, $tmpfile2], [$tmpfile2, $tmpfile1] ]; } /** * @covers ::accepts * @dataProvider acceptsSucceedsProvider */ public function testAcceptsSucceeds($expected, $actual) { $this->assertTrue( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::accepts * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual) { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual) { $exception = null; try { $this->comparator->assertEquals($expected, $actual); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual) { $this->expectException(ComparisonFailure::class); $this->comparator->assertEquals($expected, $actual); } } comparator-2.1.3/tests/ScalarComparatorTest.php000066400000000000000000000107461323461510600216450ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; /** * @coversDefaultClass SebastianBergmann\Comparator\ScalarComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class ScalarComparatorTest extends TestCase { private $comparator; protected function setUp() { $this->comparator = new ScalarComparator; } public function acceptsSucceedsProvider() { return [ ['string', 'string'], [new ClassWithToString, 'string'], ['string', new ClassWithToString], ['string', null], [false, 'string'], [false, true], [null, false], [null, null], ['10', 10], ['', false], ['1', true], [1, true], [0, false], [0.1, '0.1'] ]; } public function acceptsFailsProvider() { return [ [[], []], ['string', []], [new ClassWithToString, new ClassWithToString], [false, new ClassWithToString], [\tmpfile(), \tmpfile()] ]; } public function assertEqualsSucceedsProvider() { return [ ['string', 'string'], [new ClassWithToString, new ClassWithToString], ['string representation', new ClassWithToString], [new ClassWithToString, 'string representation'], ['string', 'STRING', true], ['STRING', 'string', true], ['String Representation', new ClassWithToString, true], [new ClassWithToString, 'String Representation', true], ['10', 10], ['', false], ['1', true], [1, true], [0, false], [0.1, '0.1'], [false, null], [false, false], [true, true], [null, null] ]; } public function assertEqualsFailsProvider() { $stringException = 'Failed asserting that two strings are equal.'; $otherException = 'matches expected'; return [ ['string', 'other string', $stringException], ['string', 'STRING', $stringException], ['STRING', 'string', $stringException], ['string', 'other string', $stringException], // https://github.com/sebastianbergmann/phpunit/issues/1023 ['9E6666666','9E7777777', $stringException], [new ClassWithToString, 'does not match', $otherException], ['does not match', new ClassWithToString, $otherException], [0, 'Foobar', $otherException], ['Foobar', 0, $otherException], ['10', 25, $otherException], ['1', false, $otherException], ['', true, $otherException], [false, true, $otherException], [true, false, $otherException], [null, true, $otherException], [0, true, $otherException] ]; } /** * @covers ::accepts * @dataProvider acceptsSucceedsProvider */ public function testAcceptsSucceeds($expected, $actual) { $this->assertTrue( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::accepts * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual) { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual, $ignoreCase = false) { $exception = null; try { $this->comparator->assertEquals($expected, $actual, 0.0, false, $ignoreCase); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual, $message) { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage($message); $this->comparator->assertEquals($expected, $actual); } } comparator-2.1.3/tests/SplObjectStorageComparatorTest.php000066400000000000000000000073011323461510600236430ustar00rootroot00000000000000 * * 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; /** * @coversDefaultClass SebastianBergmann\Comparator\SplObjectStorageComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class SplObjectStorageComparatorTest extends TestCase { private $comparator; protected function setUp() { $this->comparator = new SplObjectStorageComparator; } public function acceptsFailsProvider() { return [ [new SplObjectStorage, new stdClass], [new stdClass, new SplObjectStorage], [new stdClass, new stdClass] ]; } public function assertEqualsSucceedsProvider() { $object1 = new stdClass(); $object2 = new stdClass(); $storage1 = new SplObjectStorage(); $storage2 = new SplObjectStorage(); $storage3 = new SplObjectStorage(); $storage3->attach($object1); $storage3->attach($object2); $storage4 = new SplObjectStorage(); $storage4->attach($object2); $storage4->attach($object1); return [ [$storage1, $storage1], [$storage1, $storage2], [$storage3, $storage3], [$storage3, $storage4] ]; } public function assertEqualsFailsProvider() { $object1 = new stdClass; $object2 = new stdClass; $storage1 = new SplObjectStorage; $storage2 = new SplObjectStorage; $storage2->attach($object1); $storage3 = new SplObjectStorage; $storage3->attach($object2); $storage3->attach($object1); return [ [$storage1, $storage2], [$storage1, $storage3], [$storage2, $storage3], ]; } /** * @covers ::accepts */ public function testAcceptsSucceeds() { $this->assertTrue( $this->comparator->accepts( new SplObjectStorage, new SplObjectStorage ) ); } /** * @covers ::accepts * @dataProvider acceptsFailsProvider */ public function testAcceptsFails($expected, $actual) { $this->assertFalse( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual) { $exception = null; try { $this->comparator->assertEquals($expected, $actual); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual) { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage('Failed asserting that two objects are equal.'); $this->comparator->assertEquals($expected, $actual); } public function testAssertEqualsFails2() { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage('Failed asserting that two objects are equal.'); $t = new SplObjectStorage(); $t->attach(new \stdClass()); $this->comparator->assertEquals($t, new \SplObjectStorage()); } } comparator-2.1.3/tests/TypeComparatorTest.php000066400000000000000000000047301323461510600213550ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use PHPUnit\Framework\TestCase; use stdClass; /** * @coversDefaultClass SebastianBergmann\Comparator\TypeComparator * * @uses SebastianBergmann\Comparator\Comparator * @uses SebastianBergmann\Comparator\Factory * @uses SebastianBergmann\Comparator\ComparisonFailure */ class TypeComparatorTest extends TestCase { private $comparator; protected function setUp() { $this->comparator = new TypeComparator; } public function acceptsSucceedsProvider() { return [ [true, 1], [false, [1]], [null, new stdClass], [1.0, 5], ['', ''] ]; } public function assertEqualsSucceedsProvider() { return [ [true, true], [true, false], [false, false], [null, null], [new stdClass, new stdClass], [0, 0], [1.0, 2.0], ['hello', 'world'], ['', ''], [[], [1,2,3]] ]; } public function assertEqualsFailsProvider() { return [ [true, null], [null, false], [1.0, 0], [new stdClass, []], ['1', 1] ]; } /** * @covers ::accepts * @dataProvider acceptsSucceedsProvider */ public function testAcceptsSucceeds($expected, $actual) { $this->assertTrue( $this->comparator->accepts($expected, $actual) ); } /** * @covers ::assertEquals * @dataProvider assertEqualsSucceedsProvider */ public function testAssertEqualsSucceeds($expected, $actual) { $exception = null; try { $this->comparator->assertEquals($expected, $actual); } catch (ComparisonFailure $exception) { } $this->assertNull($exception, 'Unexpected ComparisonFailure'); } /** * @covers ::assertEquals * @dataProvider assertEqualsFailsProvider */ public function testAssertEqualsFails($expected, $actual) { $this->expectException(ComparisonFailure::class); $this->expectExceptionMessage('does not match expected type'); $this->comparator->assertEquals($expected, $actual); } } comparator-2.1.3/tests/_fixture/000077500000000000000000000000001323461510600166545ustar00rootroot00000000000000comparator-2.1.3/tests/_fixture/Author.php000066400000000000000000000010071323461510600206250ustar00rootroot00000000000000 * * 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-2.1.3/tests/_fixture/Book.php000066400000000000000000000006331323461510600202610ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * A book. */ class Book { // the order of properties is important for testing the cycle! public $author = null; } comparator-2.1.3/tests/_fixture/ClassWithToString.php000066400000000000000000000006141323461510600227610ustar00rootroot00000000000000 * * 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-2.1.3/tests/_fixture/SampleClass.php000066400000000000000000000007751323461510600216050ustar00rootroot00000000000000 * * 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-2.1.3/tests/_fixture/Struct.php000066400000000000000000000006401323461510600206510ustar00rootroot00000000000000 * * 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-2.1.3/tests/_fixture/TestClass.php000066400000000000000000000004571323461510600213000ustar00rootroot00000000000000 * * 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-2.1.3/tests/_fixture/TestClassComparator.php000066400000000000000000000005221323461510600233210ustar00rootroot00000000000000 * * 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 { }