pax_global_header00006660000000000000000000000064125552005340014513gustar00rootroot0000000000000052 comment=937efb279bd37a375bcadf584dec0726f84dbf22 comparator-1.2.0/000077500000000000000000000000001255520053400136625ustar00rootroot00000000000000comparator-1.2.0/.gitignore000066400000000000000000000001121255520053400156440ustar00rootroot00000000000000/build/coverage /composer.lock /composer.phar /phpunit.xml /.idea /vendor comparator-1.2.0/.travis.yml000066400000000000000000000006261255520053400157770ustar00rootroot00000000000000language: php sudo: false install: - travis_retry composer install --no-interaction --prefer-source script: ./vendor/bin/phpunit --configuration ./build/travis-ci.xml php: - 5.3.3 - 5.3 - 5.4 - 5.5 - 5.6 - hhvm notifications: email: false webhooks: urls: - https://webhooks.gitter.im/e/6668f52f3dd4e3f81960 on_success: always on_failure: always on_start: false comparator-1.2.0/LICENSE000066400000000000000000000030111255520053400146620ustar00rootroot00000000000000Comparator Copyright (c) 2002-2015, 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-1.2.0/README.md000066400000000000000000000021361255520053400151430ustar00rootroot00000000000000[![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 To add Comparator as a local, per-project dependency to your project, simply add a dependency on `sebastian/comparator` to your project's `composer.json` file. Here is a minimal example of a `composer.json` file that just defines a dependency on Comparator 1.2: ```JSON { "require": { "sebastian/comparator": "~1.2" } } ``` ## Usage ```php getComparatorFor($date1, $date2); try { $comparator->assertEquals($date1, $date2); print "Dates match"; } catch (ComparisonFailure $failure) { print "Dates don't match"; } ``` comparator-1.2.0/build.xml000066400000000000000000000017661255520053400155150ustar00rootroot00000000000000 comparator-1.2.0/build/000077500000000000000000000000001255520053400147615ustar00rootroot00000000000000comparator-1.2.0/build/travis-ci.xml000066400000000000000000000006151255520053400174060ustar00rootroot00000000000000 ../tests comparator-1.2.0/composer.json000066400000000000000000000020621255520053400164040ustar00rootroot00000000000000{ "name": "sebastian/comparator", "description": "Provides the functionality to compare PHP values for equality", "keywords": ["comparator","compare","equality"], "homepage": "http://www.github.com/sebastianbergmann/comparator", "license": "BSD-3-Clause", "authors": [ { "name": "Sebastian Bergmann", "email": "sebastian@phpunit.de" }, { "name": "Jeff Welch", "email": "whatthejeff@gmail.com" }, { "name": "Volker Dusch", "email": "github@wallbash.com" }, { "name": "Bernhard Schussek", "email": "bschussek@2bepublished.at" } ], "require": { "php": ">=5.3.3", "sebastian/diff": "~1.2", "sebastian/exporter": "~1.2" }, "require-dev": { "phpunit/phpunit": "~4.4" }, "autoload": { "classmap": [ "src/" ] }, "extra": { "branch-alias": { "dev-master": "1.2.x-dev" } } } comparator-1.2.0/phpunit.xml.dist000066400000000000000000000011531255520053400170350ustar00rootroot00000000000000 tests src comparator-1.2.0/src/000077500000000000000000000000001255520053400144515ustar00rootroot00000000000000comparator-1.2.0/src/ArrayComparator.php000066400000000000000000000107511255520053400202740ustar00rootroot00000000000000 * * 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 The first value to compare * @param mixed $actual The second value to compare * @param float $delta The allowed numerical distance between two values to * consider them equal * @param bool $canonicalize If set to TRUE, arrays are sorted before * comparison * @param bool $ignoreCase If set to TRUE, upper- and lowercasing is * ignored when comparing string values * @param array $processed * @throws ComparisonFailure Thrown when the comparison * fails. Contains information about the * specific errors that lead to the failure. */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = array()) { if ($canonicalize) { sort($expected); sort($actual); } $remaining = $actual; $expString = $actString = "Array (\n"; $equal = true; foreach ($expected as $key => $value) { unset($remaining[$key]); if (!array_key_exists($key, $actual)) { $expString .= 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); $expString .= sprintf( " %s => %s\n", $this->exporter->export($key), $this->exporter->shortenedExport($value) ); $actString .= sprintf( " %s => %s\n", $this->exporter->export($key), $this->exporter->shortenedExport($actual[$key]) ); } catch (ComparisonFailure $e) { $expString .= sprintf( " %s => %s\n", $this->exporter->export($key), $e->getExpectedAsString() ? $this->indent($e->getExpectedAsString()) : $this->exporter->shortenedExport($e->getExpected()) ); $actString .= 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) { $actString .= sprintf( " %s => %s\n", $this->exporter->export($key), $this->exporter->shortenedExport($value) ); $equal = false; } $expString .= ')'; $actString .= ')'; if (!$equal) { throw new ComparisonFailure( $expected, $actual, $expString, $actString, false, 'Failed asserting that two arrays are equal.' ); } } protected function indent($lines) { return trim(str_replace("\n", "\n ", $lines)); } } comparator-1.2.0/src/Comparator.php000066400000000000000000000041201255520053400172660ustar00rootroot00000000000000 * * 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 The first value to compare * @param mixed $actual The second value to compare * @param float $delta The allowed numerical distance between two values to * consider them equal * @param bool $canonicalize If set to TRUE, arrays are sorted before * comparison * @param bool $ignoreCase If set to TRUE, upper- and lowercasing is * ignored when comparing string values * @throws ComparisonFailure Thrown when the comparison * fails. Contains information about the * specific errors that lead to the failure. */ abstract public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false); } comparator-1.2.0/src/ComparisonFailure.php000066400000000000000000000056001255520053400206050ustar00rootroot00000000000000 * * 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; /** * 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("\n--- Expected\n+++ Actual\n"); return $differ->diff($this->expectedAsString, $this->actualAsString); } /** * @return string */ public function toString() { return $this->message . $this->getDiff(); } } comparator-1.2.0/src/DOMNodeComparator.php000066400000000000000000000066231255520053400204460ustar00rootroot00000000000000 * * 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 The first value to compare * @param mixed $actual The second value to compare * @param float $delta The allowed numerical distance between two values to * consider them equal * @param bool $canonicalize If set to TRUE, arrays are sorted before * comparison * @param bool $ignoreCase If set to TRUE, upper- and lowercasing is * ignored when comparing string values * @throws ComparisonFailure Thrown when the comparison * fails. Contains information about the * specific errors that lead to the failure. */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) { $expectedAsString = $this->nodeToText($expected, true, $ignoreCase); $actualAsString = $this->nodeToText($actual, true, $ignoreCase); if ($expectedAsString !== $actualAsString) { if ($expected instanceof DOMDocument) { $type = 'documents'; } else { $type = '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. * * @param DOMNode $node * @param bool $canonicalize * @param bool $ignoreCase * @return string */ private function nodeToText(DOMNode $node, $canonicalize, $ignoreCase) { if ($canonicalize) { $document = new DOMDocument; $document->loadXML($node->C14N()); $node = $document; } if ($node instanceof DOMDocument) { $document = $node; } else { $document = $node->ownerDocument; } $document->formatOutput = true; $document->normalizeDocument(); if ($node instanceof DOMDocument) { $text = $node->saveXML(); } else { $text = $document->saveXML($node); } if ($ignoreCase) { $text = strtolower($text); } return $text; } } comparator-1.2.0/src/DateTimeComparator.php000066400000000000000000000056231255520053400207140ustar00rootroot00000000000000 * * 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 The first value to compare * @param mixed $actual The second value to compare * @param float $delta The allowed numerical distance between two values to * consider them equal * @param bool $canonicalize If set to TRUE, arrays are sorted before * comparison * @param bool $ignoreCase If set to TRUE, upper- and lowercasing is * ignored when comparing string values * @throws ComparisonFailure Thrown when the comparison * fails. Contains information about the * specific errors that lead to the failure. */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) { $delta = new \DateInterval(sprintf('PT%sS', abs($delta))); $expectedLower = clone $expected; $expectedUpper = clone $expected; if ($actual < $expectedLower->sub($delta) || $actual > $expectedUpper->add($delta)) { throw new ComparisonFailure( $expected, $actual, $this->dateTimeToString($expected), $this->dateTimeToString($actual), false, 'Failed asserting that two DateTime objects are equal.' ); } } /** * Returns an ISO 8601 formatted string representation of a datetime or * 'Invalid DateTimeInterface object' if the provided DateTimeInterface was not properly * initialized. * * @param \DateTimeInterface $datetime * @return string */ protected function dateTimeToString($datetime) { $string = $datetime->format(\DateTime::ISO8601); return $string ? $string : 'Invalid DateTimeInterface object'; } } comparator-1.2.0/src/DoubleComparator.php000066400000000000000000000040671255520053400204330ustar00rootroot00000000000000 * * 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_double($expected) || is_double($actual)) && is_numeric($expected) && is_numeric($actual); } /** * Asserts that two values are equal. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * @param float $delta The allowed numerical distance between two values to * consider them equal * @param bool $canonicalize If set to TRUE, arrays are sorted before * comparison * @param bool $ignoreCase If set to TRUE, upper- and lowercasing is * ignored when comparing string values * @throws ComparisonFailure Thrown when the comparison * fails. Contains information about the * specific errors that lead to the failure. */ 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-1.2.0/src/ExceptionComparator.php000066400000000000000000000023271255520053400211540ustar00rootroot00000000000000 * * 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-1.2.0/src/Factory.php000066400000000000000000000055441255520053400166010ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Factory for comparators which compare values for equality. */ class Factory { /** * @var Comparator[] */ private $comparators = array(); /** * @var Factory */ private static $instance; /** * Constructs a new factory. */ public function __construct() { $this->register(new TypeComparator); $this->register(new ScalarComparator); $this->register(new NumericComparator); $this->register(new DoubleComparator); $this->register(new ArrayComparator); $this->register(new ResourceComparator); $this->register(new ObjectComparator); $this->register(new ExceptionComparator); $this->register(new SplObjectStorageComparator); $this->register(new DOMNodeComparator); $this->register(new MockObjectComparator); $this->register(new DateTimeComparator); } /** * @return Factory */ public static function getInstance() { if (self::$instance === null) { self::$instance = new self; } return self::$instance; } /** * Returns the correct comparator for comparing two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * @return Comparator */ public function getComparatorFor($expected, $actual) { foreach ($this->comparators as $comparator) { if ($comparator->accepts($expected, $actual)) { return $comparator; } } } /** * Registers a new comparator. * * This comparator will be returned by getInstance() if its accept() method * returns TRUE for the compared values. It has higher priority than the * existing comparators, meaning that its accept() method will be tested * before those of the other comparators. * * @param Comparator $comparator The registered comparator */ public function register(Comparator $comparator) { array_unshift($this->comparators, $comparator); $comparator->setFactory($this); } /** * Unregisters a comparator. * * This comparator will no longer be returned by getInstance(). * * @param Comparator $comparator The unregistered comparator */ public function unregister(Comparator $comparator) { foreach ($this->comparators as $key => $_comparator) { if ($comparator === $_comparator) { unset($this->comparators[$key]); } } } } comparator-1.2.0/src/MockObjectComparator.php000066400000000000000000000022641255520053400212360ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * Compares PHPUnit_Framework_MockObject_MockObject instances for equality. */ class MockObjectComparator extends ObjectComparator { /** * Returns whether the comparator can compare two values. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * @return bool */ public function accepts($expected, $actual) { return $expected instanceof \PHPUnit_Framework_MockObject_MockObject && $actual instanceof \PHPUnit_Framework_MockObject_MockObject; } /** * Converts an object to an array containing all of its private, protected * and public properties. * * @param object $object * @return array */ protected function toArray($object) { $array = parent::toArray($object); unset($array['__phpunit_invocationMocker']); return $array; } }comparator-1.2.0/src/NumericComparator.php000066400000000000000000000051761255520053400206250ustar00rootroot00000000000000 * * 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_double($expected) || is_double($actual)) && !(is_string($expected) && is_string($actual)); } /** * Asserts that two values are equal. * * @param mixed $expected The first value to compare * @param mixed $actual The second value to compare * @param float $delta The allowed numerical distance between two values to * consider them equal * @param bool $canonicalize If set to TRUE, arrays are sorted before * comparison * @param bool $ignoreCase If set to TRUE, upper- and lowercasing is * ignored when comparing string values * @throws ComparisonFailure Thrown when the comparison * fails. Contains information about the * specific errors that lead to the failure. */ 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-1.2.0/src/ObjectComparator.php000066400000000000000000000076411255520053400204300ustar00rootroot00000000000000 * * 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 The first value to compare * @param mixed $actual The second value to compare * @param float $delta The allowed numerical distance between two values to * consider them equal * @param bool $canonicalize If set to TRUE, arrays are sorted before * comparison * @param bool $ignoreCase If set to TRUE, upper- and lowercasing is * ignored when comparing string values * @param array $processed * @throws ComparisonFailure Thrown when the comparison * fails. Contains information about the * specific errors that lead to the failure. */ public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = array()) { 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(array($actual, $expected), $processed, true) || in_array(array($expected, $actual), $processed, true)) { return; } $processed[] = array($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-1.2.0/src/ResourceComparator.php000066400000000000000000000037611255520053400210100ustar00rootroot00000000000000 * * 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 The first value to compare * @param mixed $actual The second value to compare * @param float $delta The allowed numerical distance between two values to * consider them equal * @param bool $canonicalize If set to TRUE, arrays are sorted before * comparison * @param bool $ignoreCase If set to TRUE, upper- and lowercasing is * ignored when comparing string values * @throws ComparisonFailure Thrown when the comparison * fails. Contains information about the * specific errors that lead to the failure. */ 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-1.2.0/src/ScalarComparator.php000066400000000000000000000070761255520053400204310ustar00rootroot00000000000000 * * 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 The first value to compare * @param mixed $actual The second value to compare * @param float $delta The allowed numerical distance between two values to * consider them equal * @param bool $canonicalize If set to TRUE, arrays are sorted before * comparison * @param bool $ignoreCase If set to TRUE, upper- and lowercasing is * ignored when comparing string values * @throws ComparisonFailure Thrown when the comparison * fails. Contains information about the * specific errors that lead to the failure. */ 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-1.2.0/src/SplObjectStorageComparator.php000066400000000000000000000052351255520053400224310ustar00rootroot00000000000000 * * 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 The first value to compare * @param mixed $actual The second value to compare * @param float $delta The allowed numerical distance between two values to * consider them equal * @param bool $canonicalize If set to TRUE, arrays are sorted before * comparison * @param bool $ignoreCase If set to TRUE, upper- and lowercasing is * ignored when comparing string values * @throws ComparisonFailure Thrown when the comparison * fails. Contains information about the * specific errors that lead to the failure. */ 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-1.2.0/src/TypeComparator.php000066400000000000000000000042471255520053400201420ustar00rootroot00000000000000 * * 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 The first value to compare * @param mixed $actual The second value to compare * @param float $delta The allowed numerical distance between two values to * consider them equal * @param bool $canonicalize If set to TRUE, arrays are sorted before * comparison * @param bool $ignoreCase If set to TRUE, upper- and lowercasing is * ignored when comparing string values * @throws ComparisonFailure Thrown when the comparison * fails. Contains information about the * specific errors that lead to the failure. */ 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-1.2.0/tests/000077500000000000000000000000001255520053400150245ustar00rootroot00000000000000comparator-1.2.0/tests/ArrayComparatorTest.php000066400000000000000000000072501255520053400215070ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * @coversDefaultClass SebastianBergmann\Comparator\ArrayComparator * */ class ArrayComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new ArrayComparator; $this->comparator->setFactory(new Factory); } public function acceptsFailsProvider() { return array( array(array(), null), array(null, array()), array(null, null) ); } public function assertEqualsSucceedsProvider() { return array( array( array('a' => 1, 'b' => 2), array('b' => 2, 'a' => 1) ), array( array(1), array('1') ), array( array(3, 2, 1), array(2, 3, 1), 0, true ), array( array(2.3), array(2.5), 0.5 ), array( array(array(2.3)), array(array(2.5)), 0.5 ), array( array(new Struct(2.3)), array(new Struct(2.5)), 0.5 ), ); } public function assertEqualsFailsProvider() { return array( array( array(), array(0 => 1) ), array( array(0 => 1), array() ), array( array(0 => null), array() ), array( array(0 => 1, 1 => 2), array(0 => 1, 1 => 3) ), array( array('a', 'b' => array(1, 2)), array('a', 'b' => array(2, 1)) ), array( array(2.3), array(4.2), 0.5 ), array( array(array(2.3)), array(array(4.2)), 0.5 ), array( array(new Struct(2.3)), array(new Struct(4.2)), 0.5 ) ); } /** * @covers ::accepts */ public function testAcceptsSucceeds() { $this->assertTrue( $this->comparator->accepts(array(), array()) ); } /** * @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->setExpectedException( 'SebastianBergmann\\Comparator\\ComparisonFailure', 'Failed asserting that two arrays are equal' ); $this->comparator->assertEquals($expected, $actual, $delta, $canonicalize); } } comparator-1.2.0/tests/DOMNodeComparatorTest.php000066400000000000000000000101461255520053400216540ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use DOMNode; use DOMDocument; /** * @coversDefaultClass SebastianBergmann\Comparator\DOMNodeComparator * */ class DOMNodeComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new DOMNodeComparator; } public function acceptsSucceedsProvider() { $document = new DOMDocument; $node = new DOMNode; return array( array($document, $document), array($node, $node), array($document, $node), array($node, $document) ); } public function acceptsFailsProvider() { $document = new DOMDocument; return array( array($document, null), array(null, $document), array(null, null) ); } public function assertEqualsSucceedsProvider() { return array( array( $this->createDOMDocument(''), $this->createDOMDocument('') ), array( $this->createDOMDocument(''), $this->createDOMDocument('') ), array( $this->createDOMDocument(''), $this->createDOMDocument('') ), array( $this->createDOMDocument("\n \n"), $this->createDOMDocument('') ), ); } public function assertEqualsFailsProvider() { return array( array( $this->createDOMDocument(''), $this->createDOMDocument('') ), array( $this->createDOMDocument(''), $this->createDOMDocument('') ), array( $this->createDOMDocument(' bar '), $this->createDOMDocument('') ), array( $this->createDOMDocument(''), $this->createDOMDocument('') ), array( $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->setExpectedException( 'SebastianBergmann\\Comparator\\ComparisonFailure', 'Failed asserting that two DOM' ); $this->comparator->assertEquals($expected, $actual); } } comparator-1.2.0/tests/DateTimeComparatorTest.php000066400000000000000000000152751255520053400221330ustar00rootroot00000000000000 * * 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; /** * @coversDefaultClass SebastianBergmann\Comparator\DateTimeComparator * */ class DateTimeComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new DateTimeComparator; } public function acceptsFailsProvider() { $datetime = new DateTime; return array( array($datetime, null), array(null, $datetime), array(null, null) ); } public function assertEqualsSucceedsProvider() { return array( array( new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')), new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')) ), array( 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 ), array( 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 ), array( new DateTime('2013-03-29', new DateTimeZone('America/New_York')), new DateTime('2013-03-29', new DateTimeZone('America/New_York')) ), array( 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')) ), array( 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 ), array( new DateTime('2013-03-30', new DateTimeZone('America/New_York')), new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago')) ), array( new DateTime('2013-03-30', new DateTimeZone('America/New_York')), new DateTime('2013-03-29 23:01:30', new DateTimeZone('America/Chicago')), 100 ), array( new DateTime('@1364616000'), new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago')) ), array( new DateTime('2013-03-29T05:13:35-0500'), new DateTime('2013-03-29T04:13:35-0600') ) ); } public function assertEqualsFailsProvider() { return array( array( 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')) ), array( 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 ), array( 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 ), array( new DateTime('2013-03-29', new DateTimeZone('America/New_York')), new DateTime('2013-03-30', new DateTimeZone('America/New_York')) ), array( new DateTime('2013-03-29', new DateTimeZone('America/New_York')), new DateTime('2013-03-30', new DateTimeZone('America/New_York')), 43200 ), array( 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')), ), array( 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 ), array( new DateTime('2013-03-30', new DateTimeZone('America/New_York')), new DateTime('2013-03-30', new DateTimeZone('America/Chicago')) ), array( new DateTime('2013-03-29T05:13:35-0600'), new DateTime('2013-03-29T04:13:35-0600') ), array( 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->setExpectedException( 'SebastianBergmann\\Comparator\\ComparisonFailure', '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->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-1.2.0/tests/DoubleComparatorTest.php000066400000000000000000000062551255520053400216470ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * @coversDefaultClass SebastianBergmann\Comparator\DoubleComparator * */ class DoubleComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new DoubleComparator; } public function acceptsSucceedsProvider() { return array( array(0, 5.0), array(5.0, 0), array('5', 4.5), array(1.2e3, 7E-10), array(3, acos(8)), array(acos(8), 3), array(acos(8), acos(8)) ); } public function acceptsFailsProvider() { return array( array(5, 5), array('4.5', 5), array(0x539, 02471), array(5.0, false), array(null, 5.0) ); } public function assertEqualsSucceedsProvider() { return array( array(2.3, 2.3), array('2.3', 2.3), array(5.0, 5), array(5, 5.0), array(5.0, '5'), array(1.2e3, 1200), array(2.3, 2.5, 0.5), array(3, 3.05, 0.05), array(1.2e3, 1201, 1), array((string)(1/3), 1 - 2/3), array(1/3, (string)(1 - 2/3)) ); } public function assertEqualsFailsProvider() { return array( array(2.3, 4.2), array('2.3', 4.2), array(5.0, '4'), array(5.0, 6), array(1.2e3, 1201), array(2.3, 2.5, 0.2), array(3, 3.05, 0.04), array(3, acos(8)), array(acos(8), 3), array(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->setExpectedException( 'SebastianBergmann\\Comparator\\ComparisonFailure', 'matches expected' ); $this->comparator->assertEquals($expected, $actual, $delta); } } comparator-1.2.0/tests/ExceptionComparatorTest.php000066400000000000000000000071001255520053400223610ustar00rootroot00000000000000 * * 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; /** * @coversDefaultClass SebastianBergmann\Comparator\ExceptionComparator * */ class ExceptionComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new ExceptionComparator; $this->comparator->setFactory(new Factory); } public function acceptsSucceedsProvider() { return array( array(new Exception, new Exception), array(new RuntimeException, new RuntimeException), array(new Exception, new RuntimeException) ); } public function acceptsFailsProvider() { return array( array(new Exception, null), array(null, new Exception), array(null, null) ); } public function assertEqualsSucceedsProvider() { $exception1 = new Exception; $exception2 = new Exception; $exception3 = new RunTimeException('Error', 100); $exception4 = new RunTimeException('Error', 100); return array( array($exception1, $exception1), array($exception1, $exception2), array($exception3, $exception3), array($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 array( array($exception1, $exception2, $equalMessage), array($exception1, $exception3, $equalMessage), array($exception1, $exception4, $typeMessage), array($exception2, $exception3, $equalMessage), array($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->setExpectedException( 'SebastianBergmann\\Comparator\\ComparisonFailure', $message ); $this->comparator->assertEquals($expected, $actual); } } comparator-1.2.0/tests/FactoryTest.php000066400000000000000000000121701255520053400200050ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * @coversDefaultClass SebastianBergmann\Comparator\Factory * */ class FactoryTest extends \PHPUnit_Framework_TestCase { public function instanceProvider() { $tmpfile = tmpfile(); return array( array(NULL, NULL, 'SebastianBergmann\\Comparator\\ScalarComparator'), array(NULL, TRUE, 'SebastianBergmann\\Comparator\\ScalarComparator'), array(TRUE, NULL, 'SebastianBergmann\\Comparator\\ScalarComparator'), array(TRUE, TRUE, 'SebastianBergmann\\Comparator\\ScalarComparator'), array(FALSE, FALSE, 'SebastianBergmann\\Comparator\\ScalarComparator'), array(TRUE, FALSE, 'SebastianBergmann\\Comparator\\ScalarComparator'), array(FALSE, TRUE, 'SebastianBergmann\\Comparator\\ScalarComparator'), array('', '', 'SebastianBergmann\\Comparator\\ScalarComparator'), array('0', '0', 'SebastianBergmann\\Comparator\\ScalarComparator'), array('0', 0, 'SebastianBergmann\\Comparator\\NumericComparator'), array(0, '0', 'SebastianBergmann\\Comparator\\NumericComparator'), array(0, 0, 'SebastianBergmann\\Comparator\\NumericComparator'), array(1.0, 0, 'SebastianBergmann\\Comparator\\DoubleComparator'), array(0, 1.0, 'SebastianBergmann\\Comparator\\DoubleComparator'), array(1.0, 1.0, 'SebastianBergmann\\Comparator\\DoubleComparator'), array(array(1), array(1), 'SebastianBergmann\\Comparator\\ArrayComparator'), array($tmpfile, $tmpfile, 'SebastianBergmann\\Comparator\\ResourceComparator'), array(new \stdClass, new \stdClass, 'SebastianBergmann\\Comparator\\ObjectComparator'), array(new \DateTime, new \DateTime, 'SebastianBergmann\\Comparator\\DateTimeComparator'), array(new \SplObjectStorage, new \SplObjectStorage, 'SebastianBergmann\\Comparator\\SplObjectStorageComparator'), array(new \Exception, new \Exception, 'SebastianBergmann\\Comparator\\ExceptionComparator'), array(new \DOMDocument, new \DOMDocument, 'SebastianBergmann\\Comparator\\DOMNodeComparator'), // mixed types array($tmpfile, array(1), 'SebastianBergmann\\Comparator\\TypeComparator'), array(array(1), $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'), array($tmpfile, '1', 'SebastianBergmann\\Comparator\\TypeComparator'), array('1', $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'), array($tmpfile, new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'), array(new \stdClass, $tmpfile, 'SebastianBergmann\\Comparator\\TypeComparator'), array(new \stdClass, array(1), 'SebastianBergmann\\Comparator\\TypeComparator'), array(array(1), new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'), array(new \stdClass, '1', 'SebastianBergmann\\Comparator\\TypeComparator'), array('1', new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'), array(new ClassWithToString, '1', 'SebastianBergmann\\Comparator\\ScalarComparator'), array('1', new ClassWithToString, 'SebastianBergmann\\Comparator\\ScalarComparator'), array(1.0, new \stdClass, 'SebastianBergmann\\Comparator\\TypeComparator'), array(new \stdClass, 1.0, 'SebastianBergmann\\Comparator\\TypeComparator'), array(1.0, array(1), 'SebastianBergmann\\Comparator\\TypeComparator'), array(array(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); } } comparator-1.2.0/tests/MockObjectComparatorTest.php000066400000000000000000000125561255520053400224560ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * @coversDefaultClass SebastianBergmann\Comparator\MockObjectComparator * */ class MockObjectComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new MockObjectComparator; $this->comparator->setFactory(new Factory); } public function acceptsSucceedsProvider() { $testmock = $this->getMock('SebastianBergmann\\Comparator\\TestClass'); $stdmock = $this->getMock('stdClass'); return array( array($testmock, $testmock), array($stdmock, $stdmock), array($stdmock, $testmock) ); } public function acceptsFailsProvider() { $stdmock = $this->getMock('stdClass'); return array( array($stdmock, null), array(null, $stdmock), array(null, null) ); } public function assertEqualsSucceedsProvider() { // cyclic dependencies $book1 = $this->getMock('SebastianBergmann\\Comparator\\Book', null); $book1->author = $this->getMock('SebastianBergmann\\Comparator\\Author', null, array('Terry Pratchett')); $book1->author->books[] = $book1; $book2 = $this->getMock('SebastianBergmann\\Comparator\\Book', null); $book2->author = $this->getMock('SebastianBergmann\\Comparator\\Author', null, array('Terry Pratchett')); $book2->author->books[] = $book2; $object1 = $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(4, 8, 15)); $object2 = $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(4, 8, 15)); return array( array($object1, $object1), array($object1, $object2), array($book1, $book1), array($book1, $book2), array( $this->getMock('SebastianBergmann\\Comparator\\Struct', null, array(2.3)), $this->getMock('SebastianBergmann\\Comparator\\Struct', null, array(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 = $this->getMock('SebastianBergmann\\Comparator\\Book', null); $book1->author = $this->getMock('SebastianBergmann\\Comparator\\Author', null, array('Terry Pratchett')); $book1->author->books[] = $book1; $book2 = $this->getMock('SebastianBergmann\\Comparator\\Book', null); $book2->author = $this->getMock('SebastianBergmann\\Comparator\\Author', null, array('Terry Pratch')); $book2->author->books[] = $book2; $book3 = $this->getMock('SebastianBergmann\\Comparator\\Book', null); $book3->author = 'Terry Pratchett'; $book4 = $this->getMock('stdClass'); $book4->author = 'Terry Pratchett'; $object1 = $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(4, 8, 15)); $object2 = $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(16, 23, 42)); return array( array( $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(4, 8, 15)), $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(16, 23, 42)), $equalMessage ), array($object1, $object2, $equalMessage), array($book1, $book2, $equalMessage), array($book3, $book4, $typeMessage), array( $this->getMock('SebastianBergmann\\Comparator\\Struct', null, array(2.3)), $this->getMock('SebastianBergmann\\Comparator\\Struct', null, array(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->setExpectedException( 'SebastianBergmann\\Comparator\\ComparisonFailure', $message ); $this->comparator->assertEquals($expected, $actual, $delta); } } comparator-1.2.0/tests/NumericComparatorTest.php000066400000000000000000000055061255520053400220350ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * @coversDefaultClass SebastianBergmann\Comparator\NumericComparator * */ class NumericComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new NumericComparator; } public function acceptsSucceedsProvider() { return array( array(5, 10), array(8, '0'), array('10', 0), array(0x74c3b00c, 42), array(0755, 0777) ); } public function acceptsFailsProvider() { return array( array('5', '10'), array(8, 5.0), array(5.0, 8), array(10, null), array(false, 12) ); } public function assertEqualsSucceedsProvider() { return array( array(1337, 1337), array('1337', 1337), array(0x539, 1337), array(02471, 1337), array(1337, 1338, 1), array('1337', 1340, 5), ); } public function assertEqualsFailsProvider() { return array( array(1337, 1338), array('1338', 1337), array(0x539, 1338), array(1337, 1339, 1), array('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->setExpectedException( 'SebastianBergmann\\Comparator\\ComparisonFailure', 'matches expected' ); $this->comparator->assertEquals($expected, $actual, $delta); } } comparator-1.2.0/tests/ObjectComparatorTest.php000066400000000000000000000100161255520053400216310ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use stdClass; /** * @coversDefaultClass SebastianBergmann\Comparator\ObjectComparator * */ class ObjectComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new ObjectComparator; $this->comparator->setFactory(new Factory); } public function acceptsSucceedsProvider() { return array( array(new TestClass, new TestClass), array(new stdClass, new stdClass), array(new stdClass, new TestClass) ); } public function acceptsFailsProvider() { return array( array(new stdClass, null), array(null, new stdClass), array(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 array( array($object1, $object1), array($object1, $object2), array($book1, $book1), array($book1, $book2), array(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 array( array(new SampleClass(4, 8, 15), new SampleClass(16, 23, 42), $equalMessage), array($object1, $object2, $equalMessage), array($book1, $book2, $equalMessage), array($book3, $book4, $typeMessage), array(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->setExpectedException( 'SebastianBergmann\\Comparator\\ComparisonFailure', $message ); $this->comparator->assertEquals($expected, $actual, $delta); } } comparator-1.2.0/tests/ResourceComparatorTest.php000066400000000000000000000053361255520053400222230ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * @coversDefaultClass SebastianBergmann\Comparator\ResourceComparator * */ class ResourceComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new ResourceComparator; } public function acceptsSucceedsProvider() { $tmpfile1 = tmpfile(); $tmpfile2 = tmpfile(); return array( array($tmpfile1, $tmpfile1), array($tmpfile2, $tmpfile2), array($tmpfile1, $tmpfile2) ); } public function acceptsFailsProvider() { $tmpfile1 = tmpfile(); return array( array($tmpfile1, null), array(null, $tmpfile1), array(null, null) ); } public function assertEqualsSucceedsProvider() { $tmpfile1 = tmpfile(); $tmpfile2 = tmpfile(); return array( array($tmpfile1, $tmpfile1), array($tmpfile2, $tmpfile2) ); } public function assertEqualsFailsProvider() { $tmpfile1 = tmpfile(); $tmpfile2 = tmpfile(); return array( array($tmpfile1, $tmpfile2), array($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->setExpectedException('SebastianBergmann\\Comparator\\ComparisonFailure'); $this->comparator->assertEquals($expected, $actual); } } comparator-1.2.0/tests/ScalarComparatorTest.php000066400000000000000000000112001255520053400216240ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; /** * @coversDefaultClass SebastianBergmann\Comparator\ScalarComparator * */ class ScalarComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new ScalarComparator; } public function acceptsSucceedsProvider() { return array( array("string", "string"), array(new ClassWithToString, "string"), array("string", new ClassWithToString), array("string", null), array(false, "string"), array(false, true), array(null, false), array(null, null), array("10", 10), array("", false), array("1", true), array(1, true), array(0, false), array(0.1, "0.1") ); } public function acceptsFailsProvider() { return array( array(array(), array()), array("string", array()), array(new ClassWithToString, new ClassWithToString), array(false, new ClassWithToString), array(tmpfile(), tmpfile()) ); } public function assertEqualsSucceedsProvider() { return array( array("string", "string"), array(new ClassWithToString, new ClassWithToString), array("string representation", new ClassWithToString), array(new ClassWithToString, "string representation"), array("string", "STRING", true), array("STRING", "string", true), array("String Representation", new ClassWithToString, true), array(new ClassWithToString, "String Representation", true), array("10", 10), array("", false), array("1", true), array(1, true), array(0, false), array(0.1, "0.1"), array(false, null), array(false, false), array(true, true), array(null, null) ); } public function assertEqualsFailsProvider() { $stringException = 'Failed asserting that two strings are equal.'; $otherException = 'matches expected'; return array( array("string", "other string", $stringException), array("string", "STRING", $stringException), array("STRING", "string", $stringException), array("string", "other string", $stringException), // https://github.com/sebastianbergmann/phpunit/issues/1023 array('9E6666666','9E7777777', $stringException), array(new ClassWithToString, "does not match", $otherException), array("does not match", new ClassWithToString, $otherException), array(0, 'Foobar', $otherException), array('Foobar', 0, $otherException), array("10", 25, $otherException), array("1", false, $otherException), array("", true, $otherException), array(false, true, $otherException), array(true, false, $otherException), array(null, true, $otherException), array(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->setExpectedException( 'SebastianBergmann\\Comparator\\ComparisonFailure', $message ); $this->comparator->assertEquals($expected, $actual); } } comparator-1.2.0/tests/SplObjectStorageComparatorTest.php000066400000000000000000000064411255520053400236440ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use SplObjectStorage; use stdClass; /** * @coversDefaultClass SebastianBergmann\Comparator\SplObjectStorageComparator * */ class SplObjectStorageComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new SplObjectStorageComparator; } public function acceptsFailsProvider() { return array( array(new SplObjectStorage, new stdClass), array(new stdClass, new SplObjectStorage), array(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 array( array($storage1, $storage1), array($storage1, $storage2), array($storage3, $storage3), array($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 array( array($storage1, $storage2), array($storage1, $storage3), array($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->setExpectedException( 'SebastianBergmann\\Comparator\\ComparisonFailure', 'Failed asserting that two objects are equal.' ); $this->comparator->assertEquals($expected, $actual); } } comparator-1.2.0/tests/TypeComparatorTest.php000066400000000000000000000046751255520053400213620ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\Comparator; use stdClass; /** * @coversDefaultClass SebastianBergmann\Comparator\TypeComparator * */ class TypeComparatorTest extends \PHPUnit_Framework_TestCase { private $comparator; protected function setUp() { $this->comparator = new TypeComparator; } public function acceptsSucceedsProvider() { return array( array(true, 1), array(false, array(1)), array(null, new stdClass), array(1.0, 5), array("", "") ); } public function assertEqualsSucceedsProvider() { return array( array(true, true), array(true, false), array(false, false), array(null, null), array(new stdClass, new stdClass), array(0, 0), array(1.0, 2.0), array("hello", "world"), array("", ""), array(array(), array(1,2,3)) ); } public function assertEqualsFailsProvider() { return array( array(true, null), array(null, false), array(1.0, 0), array(new stdClass, array()), array("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->setExpectedException('SebastianBergmann\\Comparator\\ComparisonFailure', 'does not match expected type'); $this->comparator->assertEquals($expected, $actual); } } comparator-1.2.0/tests/_files/000077500000000000000000000000001255520053400162655ustar00rootroot00000000000000comparator-1.2.0/tests/_files/Author.php000066400000000000000000000010211255520053400202320ustar00rootroot00000000000000 * * 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 = array(); private $name = ''; public function __construct($name) { $this->name = $name; } } comparator-1.2.0/tests/_files/Book.php000066400000000000000000000006401255520053400176700ustar00rootroot00000000000000 * * 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-1.2.0/tests/_files/ClassWithToString.php000066400000000000000000000006161255520053400223740ustar00rootroot00000000000000 * * 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-1.2.0/tests/_files/SampleClass.php000066400000000000000000000010021255520053400211760ustar00rootroot00000000000000 * * 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-1.2.0/tests/_files/Struct.php000066400000000000000000000006451255520053400202670ustar00rootroot00000000000000 * * 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-1.2.0/tests/_files/TestClass.php000066400000000000000000000004611255520053400207040ustar00rootroot00000000000000 * * 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-1.2.0/tests/_files/TestClassComparator.php000066400000000000000000000005241255520053400227340ustar00rootroot00000000000000 * * 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 { } comparator-1.2.0/tests/autoload.php000066400000000000000000000045531255520053400173540ustar00rootroot00000000000000 '/ArrayComparatorTest.php', 'sebastianbergmann\\comparator\\author' => '/_files/Author.php', 'sebastianbergmann\\comparator\\book' => '/_files/Book.php', 'sebastianbergmann\\comparator\\classwithtostring' => '/_files/ClassWithToString.php', 'sebastianbergmann\\comparator\\datetimecomparatortest' => '/DateTimeComparatorTest.php', 'sebastianbergmann\\comparator\\domnodecomparatortest' => '/DOMNodeComparatorTest.php', 'sebastianbergmann\\comparator\\doublecomparatortest' => '/DoubleComparatorTest.php', 'sebastianbergmann\\comparator\\exceptioncomparatortest' => '/ExceptionComparatorTest.php', 'sebastianbergmann\\comparator\\factorytest' => '/FactoryTest.php', 'sebastianbergmann\\comparator\\mockobjectcomparatortest' => '/MockObjectComparatorTest.php', 'sebastianbergmann\\comparator\\numericcomparatortest' => '/NumericComparatorTest.php', 'sebastianbergmann\\comparator\\objectcomparatortest' => '/ObjectComparatorTest.php', 'sebastianbergmann\\comparator\\resourcecomparatortest' => '/ResourceComparatorTest.php', 'sebastianbergmann\\comparator\\sampleclass' => '/_files/SampleClass.php', 'sebastianbergmann\\comparator\\scalarcomparatortest' => '/ScalarComparatorTest.php', 'sebastianbergmann\\comparator\\splobjectstoragecomparatortest' => '/SplObjectStorageComparatorTest.php', 'sebastianbergmann\\comparator\\struct' => '/_files/Struct.php', 'sebastianbergmann\\comparator\\testclass' => '/_files/TestClass.php', 'sebastianbergmann\\comparator\\testclasscomparator' => '/_files/TestClassComparator.php', 'sebastianbergmann\\comparator\\typecomparatortest' => '/TypeComparatorTest.php' ); } $cn = strtolower($class); if (isset($classes[$cn])) { require __DIR__ . $classes[$cn]; } } ); // @codeCoverageIgnoreEnd comparator-1.2.0/tests/bootstrap.php000066400000000000000000000002261255520053400175520ustar00rootroot00000000000000