Add pear modules, mail and net_smtp via composer (#93)
Add pear modules, mail and net_smtp via composer, remove php 5.6 build due to phpunit 6
This commit is contained in:
Thilina Hasantha
GitHub
@@ -1,6 +1,4 @@
|
||||
/build/coverage
|
||||
/composer.lock
|
||||
/composer.phar
|
||||
/phpunit.xml
|
||||
/.idea
|
||||
/.php_cs.cache
|
||||
/composer.lock
|
||||
/vendor
|
||||
|
||||
81
lib/composer/vendor/sebastian/comparator/.php_cs
vendored
Normal file
81
lib/composer/vendor/sebastian/comparator/.php_cs
vendored
Normal file
@@ -0,0 +1,81 @@
|
||||
<?php
|
||||
$header = <<<'EOF'
|
||||
This file is part of the Comparator package.
|
||||
|
||||
(c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
|
||||
For the full copyright and license information, please view the LICENSE
|
||||
file that was distributed with this source code.
|
||||
EOF;
|
||||
|
||||
return PhpCsFixer\Config::create()
|
||||
->setRiskyAllowed(true)
|
||||
->setRules(
|
||||
[
|
||||
'array_syntax' => ['syntax' => 'short'],
|
||||
'binary_operator_spaces' => [
|
||||
'align_double_arrow' => true,
|
||||
'align_equals' => true
|
||||
],
|
||||
'blank_line_after_namespace' => true,
|
||||
'blank_line_before_return' => true,
|
||||
'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,
|
||||
'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,
|
||||
'strict_param' => true,
|
||||
'ternary_operator_spaces' => true,
|
||||
'trim_array_spaces' => true,
|
||||
'visibility_required' => true,
|
||||
]
|
||||
)
|
||||
->setFinder(
|
||||
PhpCsFixer\Finder::create()
|
||||
->files()
|
||||
->in(__DIR__ . '/src')
|
||||
->in(__DIR__ . '/tests')
|
||||
->exclude(__DIR__.'/tests/_fixture')
|
||||
->name('*.php')
|
||||
);
|
||||
@@ -2,24 +2,33 @@ language: 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
|
||||
- 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
|
||||
webhooks:
|
||||
urls:
|
||||
- https://webhooks.gitter.im/e/6668f52f3dd4e3f81960
|
||||
on_success: always
|
||||
on_failure: always
|
||||
on_start: false
|
||||
|
||||
|
||||
19
lib/composer/vendor/sebastian/comparator/ChangeLog.md
vendored
Normal file
19
lib/composer/vendor/sebastian/comparator/ChangeLog.md
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
# ChangeLog
|
||||
|
||||
All notable changes are documented in this file using the [Keep a CHANGELOG](http://keepachangelog.com/) principles.
|
||||
|
||||
## [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.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
|
||||
@@ -1,6 +1,6 @@
|
||||
Comparator
|
||||
|
||||
Copyright (c) 2002-2015, Sebastian Bergmann <sebastian@phpunit.de>.
|
||||
Copyright (c) 2002-2017, Sebastian Bergmann <sebastian@phpunit.de>.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
|
||||
@@ -30,9 +30,7 @@ $comparator = $factory->getComparatorFor($date1, $date2);
|
||||
try {
|
||||
$comparator->assertEquals($date1, $date2);
|
||||
print "Dates match";
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $failure) {
|
||||
} catch (ComparisonFailure $failure) {
|
||||
print "Dates don't match";
|
||||
}
|
||||
```
|
||||
|
||||
@@ -1,34 +1,21 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project name="comparator">
|
||||
<target name="clean" description="Cleanup build artifacts">
|
||||
<delete dir="${basedir}/vendor"/>
|
||||
<delete file="${basedir}/composer.lock"/>
|
||||
</target>
|
||||
<project name="comparator" default="setup">
|
||||
<target name="setup" depends="clean,composer"/>
|
||||
|
||||
<target name="composer" depends="clean" description="Install dependencies with Composer">
|
||||
<tstamp>
|
||||
<format property="thirty.days.ago" pattern="MM/dd/yyyy hh:mm aa" offset="-30" unit="day"/>
|
||||
</tstamp>
|
||||
<delete>
|
||||
<fileset dir="${basedir}">
|
||||
<include name="composer.phar" />
|
||||
<date datetime="${thirty.days.ago}" when="before"/>
|
||||
</fileset>
|
||||
</delete>
|
||||
<target name="clean" description="Cleanup build artifacts">
|
||||
<delete dir="${basedir}/vendor"/>
|
||||
<delete file="${basedir}/composer.lock"/>
|
||||
</target>
|
||||
|
||||
<get src="https://getcomposer.org/composer.phar" dest="${basedir}/composer.phar" skipexisting="true"/>
|
||||
|
||||
<exec executable="php">
|
||||
<arg value="composer.phar"/>
|
||||
<arg value="install"/>
|
||||
</exec>
|
||||
</target>
|
||||
|
||||
<target name="phpab" description="Generate autoloader script">
|
||||
<exec executable="phpab">
|
||||
<arg value="--output" />
|
||||
<arg path="tests/autoload.php" />
|
||||
<arg path="tests" />
|
||||
</exec>
|
||||
</target>
|
||||
<target name="composer" depends="clean" description="Install dependencies with Composer">
|
||||
<exec executable="composer" taskname="composer">
|
||||
<env key="COMPOSER_DISABLE_XDEBUG_WARN" value="1"/>
|
||||
<arg value="update"/>
|
||||
<arg value="--no-interaction"/>
|
||||
<arg value="--no-progress"/>
|
||||
<arg value="--no-ansi"/>
|
||||
<arg value="--no-suggest"/>
|
||||
</exec>
|
||||
</target>
|
||||
</project>
|
||||
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.2/phpunit.xsd"
|
||||
bootstrap="../tests/bootstrap.php"
|
||||
backupGlobals="false"
|
||||
verbose="true">
|
||||
<testsuite name="Comparator">
|
||||
<directory suffix="Test.php">../tests</directory>
|
||||
</testsuite>
|
||||
</phpunit>
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
"name": "sebastian/comparator",
|
||||
"description": "Provides the functionality to compare PHP values for equality",
|
||||
"keywords": ["comparator","compare","equality"],
|
||||
"homepage": "http://www.github.com/sebastianbergmann/comparator",
|
||||
"homepage": "https://github.com/sebastianbergmann/comparator",
|
||||
"license": "BSD-3-Clause",
|
||||
"authors": [
|
||||
{
|
||||
@@ -22,22 +22,32 @@
|
||||
"email": "bschussek@2bepublished.at"
|
||||
}
|
||||
],
|
||||
"prefer-stable": true,
|
||||
"require": {
|
||||
"php": ">=5.3.3",
|
||||
"sebastian/diff": "~1.2",
|
||||
"sebastian/exporter": "~1.2 || ~2.0"
|
||||
"php": "^7.0",
|
||||
"sebastian/diff": "^2.0",
|
||||
"sebastian/exporter": "^3.1"
|
||||
},
|
||||
"require-dev": {
|
||||
"phpunit/phpunit": "~4.4"
|
||||
"phpunit/phpunit": "^6.4"
|
||||
},
|
||||
"config": {
|
||||
"optimize-autoloader": true,
|
||||
"sort-packages": true
|
||||
},
|
||||
"autoload": {
|
||||
"classmap": [
|
||||
"src/"
|
||||
]
|
||||
},
|
||||
"autoload-dev": {
|
||||
"classmap": [
|
||||
"tests/_fixture"
|
||||
]
|
||||
},
|
||||
"extra": {
|
||||
"branch-alias": {
|
||||
"dev-master": "1.2.x-dev"
|
||||
"dev-master": "2.1.x-dev"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
18
lib/composer/vendor/sebastian/comparator/phpunit.xml
vendored
Normal file
18
lib/composer/vendor/sebastian/comparator/phpunit.xml
vendored
Normal file
@@ -0,0 +1,18 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/6.0/phpunit.xsd"
|
||||
bootstrap="vendor/autoload.php"
|
||||
beStrictAboutCoversAnnotation="true"
|
||||
beStrictAboutOutputDuringTests="true"
|
||||
beStrictAboutTodoAnnotatedTests="true"
|
||||
verbose="true">
|
||||
<testsuite>
|
||||
<directory suffix="Test.php">tests</directory>
|
||||
</testsuite>
|
||||
|
||||
<filter>
|
||||
<whitelist processUncoveredFilesFromWhitelist="true">
|
||||
<directory suffix=".php">src</directory>
|
||||
</whitelist>
|
||||
</filter>
|
||||
</phpunit>
|
||||
@@ -1,21 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.1/phpunit.xsd"
|
||||
bootstrap="tests/bootstrap.php"
|
||||
backupGlobals="false"
|
||||
verbose="true">
|
||||
<testsuite name="Comparator">
|
||||
<directory suffix="Test.php">tests</directory>
|
||||
</testsuite>
|
||||
|
||||
<logging>
|
||||
<log type="coverage-html" target="build/coverage"/>
|
||||
</logging>
|
||||
|
||||
<filter>
|
||||
<whitelist processUncoveredFilesFromWhitelist="true">
|
||||
<directory suffix=".php">src</directory>
|
||||
</whitelist>
|
||||
</filter>
|
||||
</phpunit>
|
||||
|
||||
@@ -18,8 +18,9 @@ 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
|
||||
* @param mixed $expected The first value to compare
|
||||
* @param mixed $actual The second value to compare
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function accepts($expected, $actual)
|
||||
@@ -30,35 +31,32 @@ class ArrayComparator extends Comparator
|
||||
/**
|
||||
* 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.
|
||||
* @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 = array())
|
||||
public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])
|
||||
{
|
||||
if ($canonicalize) {
|
||||
sort($expected);
|
||||
sort($actual);
|
||||
}
|
||||
|
||||
$remaining = $actual;
|
||||
$expString = $actString = "Array (\n";
|
||||
$equal = true;
|
||||
$remaining = $actual;
|
||||
$actualAsString = "Array (\n";
|
||||
$expectedAsString = "Array (\n";
|
||||
$equal = true;
|
||||
|
||||
foreach ($expected as $key => $value) {
|
||||
unset($remaining[$key]);
|
||||
|
||||
if (!array_key_exists($key, $actual)) {
|
||||
$expString .= sprintf(
|
||||
$expectedAsString .= sprintf(
|
||||
" %s => %s\n",
|
||||
$this->exporter->export($key),
|
||||
$this->exporter->shortenedExport($value)
|
||||
@@ -73,31 +71,28 @@ class ArrayComparator extends Comparator
|
||||
$comparator = $this->factory->getComparatorFor($value, $actual[$key]);
|
||||
$comparator->assertEquals($value, $actual[$key], $delta, $canonicalize, $ignoreCase, $processed);
|
||||
|
||||
$expString .= sprintf(
|
||||
$expectedAsString .= sprintf(
|
||||
" %s => %s\n",
|
||||
$this->exporter->export($key),
|
||||
$this->exporter->shortenedExport($value)
|
||||
);
|
||||
$actString .= sprintf(
|
||||
|
||||
$actualAsString .= sprintf(
|
||||
" %s => %s\n",
|
||||
$this->exporter->export($key),
|
||||
$this->exporter->shortenedExport($actual[$key])
|
||||
);
|
||||
} catch (ComparisonFailure $e) {
|
||||
$expString .= sprintf(
|
||||
$expectedAsString .= sprintf(
|
||||
" %s => %s\n",
|
||||
$this->exporter->export($key),
|
||||
$e->getExpectedAsString()
|
||||
? $this->indent($e->getExpectedAsString())
|
||||
: $this->exporter->shortenedExport($e->getExpected())
|
||||
$e->getExpectedAsString() ? $this->indent($e->getExpectedAsString()) : $this->exporter->shortenedExport($e->getExpected())
|
||||
);
|
||||
|
||||
$actString .= sprintf(
|
||||
$actualAsString .= sprintf(
|
||||
" %s => %s\n",
|
||||
$this->exporter->export($key),
|
||||
$e->getActualAsString()
|
||||
? $this->indent($e->getActualAsString())
|
||||
: $this->exporter->shortenedExport($e->getActual())
|
||||
$e->getActualAsString() ? $this->indent($e->getActualAsString()) : $this->exporter->shortenedExport($e->getActual())
|
||||
);
|
||||
|
||||
$equal = false;
|
||||
@@ -105,7 +100,7 @@ class ArrayComparator extends Comparator
|
||||
}
|
||||
|
||||
foreach ($remaining as $key => $value) {
|
||||
$actString .= sprintf(
|
||||
$actualAsString .= sprintf(
|
||||
" %s => %s\n",
|
||||
$this->exporter->export($key),
|
||||
$this->exporter->shortenedExport($value)
|
||||
@@ -114,15 +109,15 @@ class ArrayComparator extends Comparator
|
||||
$equal = false;
|
||||
}
|
||||
|
||||
$expString .= ')';
|
||||
$actString .= ')';
|
||||
$expectedAsString .= ')';
|
||||
$actualAsString .= ')';
|
||||
|
||||
if (!$equal) {
|
||||
throw new ComparisonFailure(
|
||||
$expected,
|
||||
$actual,
|
||||
$expString,
|
||||
$actString,
|
||||
$expectedAsString,
|
||||
$actualAsString,
|
||||
false,
|
||||
'Failed asserting that two arrays are equal.'
|
||||
);
|
||||
|
||||
@@ -43,8 +43,9 @@ abstract class 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
|
||||
* @param mixed $expected The first value to compare
|
||||
* @param mixed $actual The second value to compare
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
abstract public function accepts($expected, $actual);
|
||||
@@ -52,17 +53,13 @@ abstract class Comparator
|
||||
/**
|
||||
* 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.
|
||||
* @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);
|
||||
}
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
namespace SebastianBergmann\Comparator;
|
||||
|
||||
use SebastianBergmann\Diff\Differ;
|
||||
use SebastianBergmann\Diff\Output\UnifiedDiffOutputBuilder;
|
||||
|
||||
/**
|
||||
* Thrown when an assertion for string equality failed.
|
||||
@@ -19,24 +20,28 @@ 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;
|
||||
@@ -49,6 +54,7 @@ class ComparisonFailure extends \RuntimeException
|
||||
/**
|
||||
* Optional message which is placed in front of the first line
|
||||
* returned by toString().
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $message;
|
||||
@@ -114,7 +120,7 @@ class ComparisonFailure extends \RuntimeException
|
||||
return '';
|
||||
}
|
||||
|
||||
$differ = new Differ("\n--- Expected\n+++ Actual\n");
|
||||
$differ = new Differ(new UnifiedDiffOutputBuilder("\n--- Expected\n+++ Actual\n"));
|
||||
|
||||
return $differ->diff($this->expectedAsString, $this->actualAsString);
|
||||
}
|
||||
|
||||
@@ -21,8 +21,9 @@ 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
|
||||
* @param mixed $expected The first value to compare
|
||||
* @param mixed $actual The second value to compare
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function accepts($expected, $actual)
|
||||
@@ -33,29 +34,22 @@ class DOMNodeComparator extends ObjectComparator
|
||||
/**
|
||||
* 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.
|
||||
* @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)
|
||||
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) {
|
||||
if ($expected instanceof DOMDocument) {
|
||||
$type = 'documents';
|
||||
} else {
|
||||
$type = 'nodes';
|
||||
}
|
||||
$type = $expected instanceof DOMDocument ? 'documents' : 'nodes';
|
||||
|
||||
throw new ComparisonFailure(
|
||||
$expected,
|
||||
@@ -71,40 +65,23 @@ class DOMNodeComparator extends ObjectComparator
|
||||
/**
|
||||
* 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)
|
||||
private function nodeToText(DOMNode $node, bool $canonicalize, bool $ignoreCase): string
|
||||
{
|
||||
if ($canonicalize) {
|
||||
$document = new DOMDocument;
|
||||
$document->loadXML($node->C14N());
|
||||
@$document->loadXML($node->C14N());
|
||||
|
||||
$node = $document;
|
||||
}
|
||||
|
||||
if ($node instanceof DOMDocument) {
|
||||
$document = $node;
|
||||
} else {
|
||||
$document = $node->ownerDocument;
|
||||
}
|
||||
$document = $node instanceof DOMDocument ? $node : $node->ownerDocument;
|
||||
|
||||
$document->formatOutput = true;
|
||||
$document->normalizeDocument();
|
||||
|
||||
if ($node instanceof DOMDocument) {
|
||||
$text = $node->saveXML();
|
||||
} else {
|
||||
$text = $document->saveXML($node);
|
||||
}
|
||||
$text = $node instanceof DOMDocument ? $node->saveXML() : $document->saveXML($node);
|
||||
|
||||
if ($ignoreCase) {
|
||||
$text = strtolower($text);
|
||||
}
|
||||
|
||||
return $text;
|
||||
return $ignoreCase ? $text : strtolower($text);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -18,8 +18,9 @@ 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
|
||||
* @param mixed $expected The first value to compare
|
||||
* @param mixed $actual The second value to compare
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function accepts($expected, $actual)
|
||||
@@ -31,27 +32,34 @@ class DateTimeComparator extends ObjectComparator
|
||||
/**
|
||||
* 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.
|
||||
* @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)
|
||||
public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])
|
||||
{
|
||||
$delta = new \DateInterval(sprintf('PT%sS', abs($delta)));
|
||||
/** @var \DateTimeInterface $expected */
|
||||
/** @var \DateTimeInterface $actual */
|
||||
|
||||
$delta = new \DateInterval(sprintf('PT%dS', abs($delta)));
|
||||
|
||||
$actualClone = clone $actual;
|
||||
$actualClone->setTimezone(new \DateTimeZone('UTC'));
|
||||
|
||||
$expectedLower = clone $expected;
|
||||
$expectedUpper = clone $expected;
|
||||
$expectedLower->setTimezone(new \DateTimeZone('UTC'));
|
||||
$expectedLower->sub($delta);
|
||||
|
||||
if ($actual < $expectedLower->sub($delta) ||
|
||||
$actual > $expectedUpper->add($delta)) {
|
||||
$expectedUpper = clone $expected;
|
||||
$expectedUpper->setTimezone(new \DateTimeZone('UTC'));
|
||||
$expectedUpper->add($delta);
|
||||
|
||||
if ($actual < $expectedLower || $actual > $expectedUpper) {
|
||||
throw new ComparisonFailure(
|
||||
$expected,
|
||||
$actual,
|
||||
@@ -67,14 +75,11 @@ class DateTimeComparator extends ObjectComparator
|
||||
* 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
|
||||
*/
|
||||
private function dateTimeToString($datetime)
|
||||
private function dateTimeToString(\DateTimeInterface $datetime): string
|
||||
{
|
||||
$string = $datetime->format('Y-m-d\TH:i:s.uO');
|
||||
|
||||
return $string ? $string : 'Invalid DateTimeInterface object';
|
||||
return $string ?: 'Invalid DateTimeInterface object';
|
||||
}
|
||||
}
|
||||
|
||||
@@ -25,29 +25,26 @@ class DoubleComparator extends NumericComparator
|
||||
/**
|
||||
* Returns whether the comparator can compare two values.
|
||||
*
|
||||
* @param mixed $expected The first value to compare
|
||||
* @param mixed $actual The second value to compare
|
||||
* @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);
|
||||
return (is_float($expected) || is_float($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.
|
||||
* @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)
|
||||
{
|
||||
|
||||
@@ -18,8 +18,9 @@ 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
|
||||
* @param mixed $expected The first value to compare
|
||||
* @param mixed $actual The second value to compare
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function accepts($expected, $actual)
|
||||
@@ -31,7 +32,8 @@ class ExceptionComparator extends ObjectComparator
|
||||
* Converts an object to an array containing all of its private, protected
|
||||
* and public properties.
|
||||
*
|
||||
* @param object $object
|
||||
* @param object $object
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
protected function toArray($object)
|
||||
|
||||
@@ -18,32 +18,18 @@ class Factory
|
||||
/**
|
||||
* @var Comparator[]
|
||||
*/
|
||||
private $comparators = array();
|
||||
private $customComparators = [];
|
||||
|
||||
/**
|
||||
* @var Comparator[]
|
||||
*/
|
||||
private $defaultComparators = [];
|
||||
|
||||
/**
|
||||
* @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
|
||||
*/
|
||||
@@ -56,16 +42,31 @@ class Factory
|
||||
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
|
||||
* @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) {
|
||||
foreach ($this->customComparators as $comparator) {
|
||||
if ($comparator->accepts($expected, $actual)) {
|
||||
return $comparator;
|
||||
}
|
||||
}
|
||||
|
||||
foreach ($this->defaultComparators as $comparator) {
|
||||
if ($comparator->accepts($expected, $actual)) {
|
||||
return $comparator;
|
||||
}
|
||||
@@ -75,16 +76,16 @@ class Factory
|
||||
/**
|
||||
* Registers a new comparator.
|
||||
*
|
||||
* This comparator will be returned by getInstance() if its accept() method
|
||||
* 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 tested
|
||||
* existing comparators, meaning that its accept() method will be invoked
|
||||
* before those of the other comparators.
|
||||
*
|
||||
* @param Comparator $comparator The registered comparator
|
||||
* @param Comparator $comparator The comparator to be registered
|
||||
*/
|
||||
public function register(Comparator $comparator)
|
||||
{
|
||||
array_unshift($this->comparators, $comparator);
|
||||
array_unshift($this->customComparators, $comparator);
|
||||
|
||||
$comparator->setFactory($this);
|
||||
}
|
||||
@@ -92,16 +93,47 @@ class Factory
|
||||
/**
|
||||
* Unregisters a comparator.
|
||||
*
|
||||
* This comparator will no longer be returned by getInstance().
|
||||
* This comparator will no longer be considered by getComparatorFor().
|
||||
*
|
||||
* @param Comparator $comparator The unregistered comparator
|
||||
* @param Comparator $comparator The comparator to be unregistered
|
||||
*/
|
||||
public function unregister(Comparator $comparator)
|
||||
{
|
||||
foreach ($this->comparators as $key => $_comparator) {
|
||||
foreach ($this->customComparators as $key => $_comparator) {
|
||||
if ($comparator === $_comparator) {
|
||||
unset($this->comparators[$key]);
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -18,20 +18,23 @@ 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
|
||||
* @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;
|
||||
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
|
||||
* @param object $object
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
protected function toArray($object)
|
||||
@@ -42,4 +45,4 @@ class MockObjectComparator extends ObjectComparator
|
||||
|
||||
return $array;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -18,8 +18,9 @@ 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
|
||||
* @param mixed $expected The first value to compare
|
||||
* @param mixed $actual The second value to compare
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function accepts($expected, $actual)
|
||||
@@ -27,24 +28,20 @@ class NumericComparator extends ScalarComparator
|
||||
// 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_float($expected) || is_float($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.
|
||||
* @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)
|
||||
{
|
||||
|
||||
@@ -18,8 +18,9 @@ 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
|
||||
* @param mixed $expected The first value to compare
|
||||
* @param mixed $actual The second value to compare
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function accepts($expected, $actual)
|
||||
@@ -30,20 +31,16 @@ class ObjectComparator extends ArrayComparator
|
||||
/**
|
||||
* 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.
|
||||
* @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 = array())
|
||||
public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])
|
||||
{
|
||||
if (get_class($actual) !== get_class($expected)) {
|
||||
throw new ComparisonFailure(
|
||||
@@ -61,12 +58,12 @@ class ObjectComparator extends ArrayComparator
|
||||
}
|
||||
|
||||
// don't compare twice to allow for cyclic dependencies
|
||||
if (in_array(array($actual, $expected), $processed, true) ||
|
||||
in_array(array($expected, $actual), $processed, true)) {
|
||||
if (in_array([$actual, $expected], $processed, true) ||
|
||||
in_array([$expected, $actual], $processed, true)) {
|
||||
return;
|
||||
}
|
||||
|
||||
$processed[] = array($actual, $expected);
|
||||
$processed[] = [$actual, $expected];
|
||||
|
||||
// don't compare objects if they are identical
|
||||
// this helps to avoid the error "maximum function nesting level reached"
|
||||
@@ -99,7 +96,8 @@ class ObjectComparator extends ArrayComparator
|
||||
* Converts an object to an array containing all of its private, protected
|
||||
* and public properties.
|
||||
*
|
||||
* @param object $object
|
||||
* @param object $object
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
protected function toArray($object)
|
||||
|
||||
@@ -18,8 +18,9 @@ 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
|
||||
* @param mixed $expected The first value to compare
|
||||
* @param mixed $actual The second value to compare
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function accepts($expected, $actual)
|
||||
@@ -30,17 +31,13 @@ class ResourceComparator extends Comparator
|
||||
/**
|
||||
* 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.
|
||||
* @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)
|
||||
{
|
||||
|
||||
@@ -18,9 +18,11 @@ 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
|
||||
* @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)
|
||||
@@ -35,17 +37,13 @@ class ScalarComparator extends Comparator
|
||||
/**
|
||||
* 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.
|
||||
* @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)
|
||||
{
|
||||
|
||||
@@ -18,8 +18,9 @@ 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
|
||||
* @param mixed $expected The first value to compare
|
||||
* @param mixed $actual The second value to compare
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function accepts($expected, $actual)
|
||||
@@ -30,17 +31,13 @@ class SplObjectStorageComparator extends Comparator
|
||||
/**
|
||||
* 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.
|
||||
* @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)
|
||||
{
|
||||
|
||||
@@ -18,8 +18,9 @@ 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
|
||||
* @param mixed $expected The first value to compare
|
||||
* @param mixed $actual The second value to compare
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function accepts($expected, $actual)
|
||||
@@ -30,17 +31,13 @@ class TypeComparator extends Comparator
|
||||
/**
|
||||
* 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.
|
||||
* @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)
|
||||
{
|
||||
|
||||
@@ -10,12 +10,19 @@
|
||||
|
||||
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 \PHPUnit_Framework_TestCase
|
||||
class ArrayComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var ArrayComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp()
|
||||
@@ -26,87 +33,87 @@ class ArrayComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
public function acceptsFailsProvider()
|
||||
{
|
||||
return array(
|
||||
array(array(), null),
|
||||
array(null, array()),
|
||||
array(null, null)
|
||||
);
|
||||
return [
|
||||
[[], null],
|
||||
[null, []],
|
||||
[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),
|
||||
return [
|
||||
[
|
||||
['a' => 1, 'b' => 2],
|
||||
['b' => 2, 'a' => 1]
|
||||
],
|
||||
[
|
||||
[1],
|
||||
['1']
|
||||
],
|
||||
[
|
||||
[3, 2, 1],
|
||||
[2, 3, 1],
|
||||
0,
|
||||
true
|
||||
),
|
||||
array(
|
||||
array(2.3),
|
||||
array(2.5),
|
||||
],
|
||||
[
|
||||
[2.3],
|
||||
[2.5],
|
||||
0.5
|
||||
),
|
||||
array(
|
||||
array(array(2.3)),
|
||||
array(array(2.5)),
|
||||
],
|
||||
[
|
||||
[[2.3]],
|
||||
[[2.5]],
|
||||
0.5
|
||||
),
|
||||
array(
|
||||
array(new Struct(2.3)),
|
||||
array(new Struct(2.5)),
|
||||
],
|
||||
[
|
||||
[new Struct(2.3)],
|
||||
[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),
|
||||
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
|
||||
),
|
||||
array(
|
||||
array(array(2.3)),
|
||||
array(array(4.2)),
|
||||
],
|
||||
[
|
||||
[[2.3]],
|
||||
[[4.2]],
|
||||
0.5
|
||||
),
|
||||
array(
|
||||
array(new Struct(2.3)),
|
||||
array(new Struct(4.2)),
|
||||
],
|
||||
[
|
||||
[new Struct(2.3)],
|
||||
[new Struct(4.2)],
|
||||
0.5
|
||||
)
|
||||
);
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -115,7 +122,7 @@ class ArrayComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
public function testAcceptsSucceeds()
|
||||
{
|
||||
$this->assertTrue(
|
||||
$this->comparator->accepts(array(), array())
|
||||
$this->comparator->accepts([], [])
|
||||
);
|
||||
}
|
||||
|
||||
@@ -140,9 +147,7 @@ class ArrayComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta, $canonicalize);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -152,12 +157,11 @@ class ArrayComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
* @covers ::assertEquals
|
||||
* @dataProvider assertEqualsFailsProvider
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual,$delta = 0.0, $canonicalize = false)
|
||||
public function testAssertEqualsFails($expected, $actual, $delta = 0.0, $canonicalize = false)
|
||||
{
|
||||
$this->setExpectedException(
|
||||
'SebastianBergmann\\Comparator\\ComparisonFailure',
|
||||
'Failed asserting that two arrays are equal'
|
||||
);
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('Failed asserting that two arrays are equal');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta, $canonicalize);
|
||||
}
|
||||
}
|
||||
|
||||
58
lib/composer/vendor/sebastian/comparator/tests/ComparisonFailureTest.php
vendored
Normal file
58
lib/composer/vendor/sebastian/comparator/tests/ComparisonFailureTest.php
vendored
Normal file
@@ -0,0 +1,58 @@
|
||||
<?php
|
||||
/*
|
||||
* This file is part of the Comparator package.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Comparator;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* @covers SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
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());
|
||||
}
|
||||
}
|
||||
@@ -12,12 +12,15 @@ namespace SebastianBergmann\Comparator;
|
||||
|
||||
use DOMNode;
|
||||
use DOMDocument;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass SebastianBergmann\Comparator\DOMNodeComparator
|
||||
*
|
||||
* @uses SebastianBergmann\Comparator\Comparator
|
||||
* @uses SebastianBergmann\Comparator\Factory
|
||||
* @uses SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
class DOMNodeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
class DOMNodeComparatorTest extends TestCase
|
||||
{
|
||||
private $comparator;
|
||||
|
||||
@@ -29,78 +32,78 @@ class DOMNodeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
public function acceptsSucceedsProvider()
|
||||
{
|
||||
$document = new DOMDocument;
|
||||
$node = new DOMNode;
|
||||
$node = new DOMNode;
|
||||
|
||||
return array(
|
||||
array($document, $document),
|
||||
array($node, $node),
|
||||
array($document, $node),
|
||||
array($node, $document)
|
||||
);
|
||||
return [
|
||||
[$document, $document],
|
||||
[$node, $node],
|
||||
[$document, $node],
|
||||
[$node, $document]
|
||||
];
|
||||
}
|
||||
|
||||
public function acceptsFailsProvider()
|
||||
{
|
||||
$document = new DOMDocument;
|
||||
|
||||
return array(
|
||||
array($document, null),
|
||||
array(null, $document),
|
||||
array(null, null)
|
||||
);
|
||||
return [
|
||||
[$document, null],
|
||||
[null, $document],
|
||||
[null, null]
|
||||
];
|
||||
}
|
||||
|
||||
public function assertEqualsSucceedsProvider()
|
||||
{
|
||||
return array(
|
||||
array(
|
||||
return [
|
||||
[
|
||||
$this->createDOMDocument('<root></root>'),
|
||||
$this->createDOMDocument('<root/>')
|
||||
),
|
||||
array(
|
||||
],
|
||||
[
|
||||
$this->createDOMDocument('<root attr="bar"></root>'),
|
||||
$this->createDOMDocument('<root attr="bar"/>')
|
||||
),
|
||||
array(
|
||||
],
|
||||
[
|
||||
$this->createDOMDocument('<root><foo attr="bar"></foo></root>'),
|
||||
$this->createDOMDocument('<root><foo attr="bar"/></root>')
|
||||
),
|
||||
array(
|
||||
],
|
||||
[
|
||||
$this->createDOMDocument("<root>\n <child/>\n</root>"),
|
||||
$this->createDOMDocument('<root><child/></root>')
|
||||
),
|
||||
);
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
public function assertEqualsFailsProvider()
|
||||
{
|
||||
return array(
|
||||
array(
|
||||
return [
|
||||
[
|
||||
$this->createDOMDocument('<root></root>'),
|
||||
$this->createDOMDocument('<bar/>')
|
||||
),
|
||||
array(
|
||||
],
|
||||
[
|
||||
$this->createDOMDocument('<foo attr1="bar"/>'),
|
||||
$this->createDOMDocument('<foo attr1="foobar"/>')
|
||||
),
|
||||
array(
|
||||
],
|
||||
[
|
||||
$this->createDOMDocument('<foo> bar </foo>'),
|
||||
$this->createDOMDocument('<foo />')
|
||||
),
|
||||
array(
|
||||
],
|
||||
[
|
||||
$this->createDOMDocument('<foo xmlns="urn:myns:bar"/>'),
|
||||
$this->createDOMDocument('<foo xmlns="urn:notmyns:bar"/>')
|
||||
),
|
||||
array(
|
||||
],
|
||||
[
|
||||
$this->createDOMDocument('<foo> bar </foo>'),
|
||||
$this->createDOMDocument('<foo> bir </foo>')
|
||||
)
|
||||
);
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
private function createDOMDocument($content)
|
||||
{
|
||||
$document = new DOMDocument;
|
||||
$document = new DOMDocument;
|
||||
$document->preserveWhiteSpace = false;
|
||||
$document->loadXML($content);
|
||||
|
||||
@@ -139,9 +142,7 @@ class DOMNodeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -153,10 +154,9 @@ class DOMNodeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual)
|
||||
{
|
||||
$this->setExpectedException(
|
||||
'SebastianBergmann\\Comparator\\ComparisonFailure',
|
||||
'Failed asserting that two DOM'
|
||||
);
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('Failed asserting that two DOM');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -13,13 +13,19 @@ 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 \PHPUnit_Framework_TestCase
|
||||
class DateTimeComparatorTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @var DateTimeComparator
|
||||
*/
|
||||
private $comparator;
|
||||
|
||||
protected function setUp()
|
||||
@@ -31,111 +37,111 @@ class DateTimeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
$datetime = new DateTime;
|
||||
|
||||
return array(
|
||||
array($datetime, null),
|
||||
array(null, $datetime),
|
||||
array(null, null)
|
||||
);
|
||||
return [
|
||||
[$datetime, null],
|
||||
[null, $datetime],
|
||||
[null, null]
|
||||
];
|
||||
}
|
||||
|
||||
public function assertEqualsSucceedsProvider()
|
||||
{
|
||||
return array(
|
||||
array(
|
||||
return [
|
||||
[
|
||||
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(
|
||||
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'))
|
||||
),
|
||||
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')
|
||||
),
|
||||
);
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -172,9 +178,7 @@ class DateTimeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -186,10 +190,9 @@ class DateTimeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $delta = 0.0)
|
||||
{
|
||||
$this->setExpectedException(
|
||||
'SebastianBergmann\\Comparator\\ComparisonFailure',
|
||||
'Failed asserting that two DateTime objects are equal.'
|
||||
);
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('Failed asserting that two DateTime objects are equal.');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
|
||||
@@ -208,9 +211,11 @@ class DateTimeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
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'))
|
||||
$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'))
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,11 +10,15 @@
|
||||
|
||||
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 \PHPUnit_Framework_TestCase
|
||||
class DoubleComparatorTest extends TestCase
|
||||
{
|
||||
private $comparator;
|
||||
|
||||
@@ -25,59 +29,59 @@ class DoubleComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
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))
|
||||
);
|
||||
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 array(
|
||||
array(5, 5),
|
||||
array('4.5', 5),
|
||||
array(0x539, 02471),
|
||||
array(5.0, false),
|
||||
array(null, 5.0)
|
||||
);
|
||||
return [
|
||||
[5, 5],
|
||||
['4.5', 5],
|
||||
[0x539, 02471],
|
||||
[5.0, false],
|
||||
[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))
|
||||
);
|
||||
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 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))
|
||||
);
|
||||
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)]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -112,9 +116,7 @@ class DoubleComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -126,9 +128,9 @@ class DoubleComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $delta = 0.0)
|
||||
{
|
||||
$this->setExpectedException(
|
||||
'SebastianBergmann\\Comparator\\ComparisonFailure', 'matches expected'
|
||||
);
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('matches expected');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,12 +12,15 @@ 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 \PHPUnit_Framework_TestCase
|
||||
class ExceptionComparatorTest extends TestCase
|
||||
{
|
||||
private $comparator;
|
||||
|
||||
@@ -29,20 +32,20 @@ class ExceptionComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
public function acceptsSucceedsProvider()
|
||||
{
|
||||
return array(
|
||||
array(new Exception, new Exception),
|
||||
array(new RuntimeException, new RuntimeException),
|
||||
array(new Exception, new RuntimeException)
|
||||
);
|
||||
return [
|
||||
[new Exception, new Exception],
|
||||
[new RuntimeException, new RuntimeException],
|
||||
[new Exception, new RuntimeException]
|
||||
];
|
||||
}
|
||||
|
||||
public function acceptsFailsProvider()
|
||||
{
|
||||
return array(
|
||||
array(new Exception, null),
|
||||
array(null, new Exception),
|
||||
array(null, null)
|
||||
);
|
||||
return [
|
||||
[new Exception, null],
|
||||
[null, new Exception],
|
||||
[null, null]
|
||||
];
|
||||
}
|
||||
|
||||
public function assertEqualsSucceedsProvider()
|
||||
@@ -50,36 +53,36 @@ class ExceptionComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
$exception1 = new Exception;
|
||||
$exception2 = new Exception;
|
||||
|
||||
$exception3 = new RunTimeException('Error', 100);
|
||||
$exception4 = new RunTimeException('Error', 100);
|
||||
$exception3 = new RuntimeException('Error', 100);
|
||||
$exception4 = new RuntimeException('Error', 100);
|
||||
|
||||
return array(
|
||||
array($exception1, $exception1),
|
||||
array($exception1, $exception2),
|
||||
array($exception3, $exception3),
|
||||
array($exception3, $exception4)
|
||||
);
|
||||
return [
|
||||
[$exception1, $exception1],
|
||||
[$exception1, $exception2],
|
||||
[$exception3, $exception3],
|
||||
[$exception3, $exception4]
|
||||
];
|
||||
}
|
||||
|
||||
public function assertEqualsFailsProvider()
|
||||
{
|
||||
$typeMessage = 'not instance of expected class';
|
||||
$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);
|
||||
$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)
|
||||
);
|
||||
return [
|
||||
[$exception1, $exception2, $equalMessage],
|
||||
[$exception1, $exception3, $equalMessage],
|
||||
[$exception1, $exception4, $typeMessage],
|
||||
[$exception2, $exception3, $equalMessage],
|
||||
[$exception4, $exception5, $equalMessage]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -114,9 +117,7 @@ class ExceptionComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -128,9 +129,9 @@ class ExceptionComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $message)
|
||||
{
|
||||
$this->setExpectedException(
|
||||
'SebastianBergmann\\Comparator\\ComparisonFailure', $message
|
||||
);
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage($message);
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,57 +10,61 @@
|
||||
|
||||
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 \PHPUnit_Framework_TestCase
|
||||
class FactoryTest extends 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'),
|
||||
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
|
||||
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'),
|
||||
);
|
||||
[$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'],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -71,7 +75,7 @@ class FactoryTest extends \PHPUnit_Framework_TestCase
|
||||
public function testGetComparatorFor($a, $b, $expected)
|
||||
{
|
||||
$factory = new Factory;
|
||||
$actual = $factory->getComparatorFor($a, $b);
|
||||
$actual = $factory->getComparatorFor($a, $b);
|
||||
$this->assertInstanceOf($expected, $actual);
|
||||
}
|
||||
|
||||
@@ -85,10 +89,10 @@ class FactoryTest extends \PHPUnit_Framework_TestCase
|
||||
$factory = new Factory;
|
||||
$factory->register($comparator);
|
||||
|
||||
$a = new TestClass;
|
||||
$b = new TestClass;
|
||||
$a = new TestClass;
|
||||
$b = new TestClass;
|
||||
$expected = 'SebastianBergmann\\Comparator\\TestClassComparator';
|
||||
$actual = $factory->getComparatorFor($a, $b);
|
||||
$actual = $factory->getComparatorFor($a, $b);
|
||||
|
||||
$factory->unregister($comparator);
|
||||
$this->assertInstanceOf($expected, $actual);
|
||||
@@ -105,11 +109,17 @@ class FactoryTest extends \PHPUnit_Framework_TestCase
|
||||
$factory->register($comparator);
|
||||
$factory->unregister($comparator);
|
||||
|
||||
$a = new TestClass;
|
||||
$b = new TestClass;
|
||||
$a = new TestClass;
|
||||
$b = new TestClass;
|
||||
$expected = 'SebastianBergmann\\Comparator\\ObjectComparator';
|
||||
$actual = $factory->getComparatorFor($a, $b);
|
||||
$actual = $factory->getComparatorFor($a, $b);
|
||||
|
||||
$this->assertInstanceOf($expected, $actual);
|
||||
}
|
||||
|
||||
public function testIsSingleton()
|
||||
{
|
||||
$f = Factory::getInstance();
|
||||
$this->assertSame($f, Factory::getInstance());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,11 +10,16 @@
|
||||
|
||||
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 \PHPUnit_Framework_TestCase
|
||||
class MockObjectComparatorTest extends TestCase
|
||||
{
|
||||
private $comparator;
|
||||
|
||||
@@ -26,90 +31,90 @@ class MockObjectComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
public function acceptsSucceedsProvider()
|
||||
{
|
||||
$testmock = $this->getMock('SebastianBergmann\\Comparator\\TestClass');
|
||||
$stdmock = $this->getMock('stdClass');
|
||||
$testmock = $this->createMock(TestClass::class);
|
||||
$stdmock = $this->createMock(stdClass::class);
|
||||
|
||||
return array(
|
||||
array($testmock, $testmock),
|
||||
array($stdmock, $stdmock),
|
||||
array($stdmock, $testmock)
|
||||
);
|
||||
return [
|
||||
[$testmock, $testmock],
|
||||
[$stdmock, $stdmock],
|
||||
[$stdmock, $testmock]
|
||||
];
|
||||
}
|
||||
|
||||
public function acceptsFailsProvider()
|
||||
{
|
||||
$stdmock = $this->getMock('stdClass');
|
||||
$stdmock = $this->createMock(stdClass::class);
|
||||
|
||||
return array(
|
||||
array($stdmock, null),
|
||||
array(null, $stdmock),
|
||||
array(null, null)
|
||||
);
|
||||
return [
|
||||
[$stdmock, null],
|
||||
[null, $stdmock],
|
||||
[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 = $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->getMock('SebastianBergmann\\Comparator\\Book', null);
|
||||
$book2->author = $this->getMock('SebastianBergmann\\Comparator\\Author', null, array('Terry Pratchett'));
|
||||
$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->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(4, 8, 15));
|
||||
$object2 = $this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(4, 8, 15));
|
||||
$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 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)),
|
||||
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';
|
||||
$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 = $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->getMock('SebastianBergmann\\Comparator\\Book', null);
|
||||
$book2->author = $this->getMock('SebastianBergmann\\Comparator\\Author', null, array('Terry Pratch'));
|
||||
$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->getMock('SebastianBergmann\\Comparator\\Book', null);
|
||||
$book3 = $this->getMockBuilder(Book::class)->setMethods(null)->getMock();
|
||||
$book3->author = 'Terry Pratchett';
|
||||
$book4 = $this->getMock('stdClass');
|
||||
$book4 = $this->createMock(stdClass::class);
|
||||
$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));
|
||||
$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 array(
|
||||
array(
|
||||
$this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(4, 8, 15)),
|
||||
$this->getMock('SebastianBergmann\\Comparator\\SampleClass', null, array(16, 23, 42)),
|
||||
return [
|
||||
[
|
||||
$this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([4, 8, 15])->getMock(),
|
||||
$this->getMockBuilder(SampleClass::class)->setMethods(null)->setConstructorArgs([16, 23, 42])->getMock(),
|
||||
$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)),
|
||||
],
|
||||
[$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
|
||||
)
|
||||
);
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -144,9 +149,7 @@ class MockObjectComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -158,9 +161,9 @@ class MockObjectComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0)
|
||||
{
|
||||
$this->setExpectedException(
|
||||
'SebastianBergmann\\Comparator\\ComparisonFailure', $message
|
||||
);
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage($message);
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,11 +10,15 @@
|
||||
|
||||
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 \PHPUnit_Framework_TestCase
|
||||
class NumericComparatorTest extends TestCase
|
||||
{
|
||||
private $comparator;
|
||||
|
||||
@@ -25,47 +29,47 @@ class NumericComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
public function acceptsSucceedsProvider()
|
||||
{
|
||||
return array(
|
||||
array(5, 10),
|
||||
array(8, '0'),
|
||||
array('10', 0),
|
||||
array(0x74c3b00c, 42),
|
||||
array(0755, 0777)
|
||||
);
|
||||
return [
|
||||
[5, 10],
|
||||
[8, '0'],
|
||||
['10', 0],
|
||||
[0x74c3b00c, 42],
|
||||
[0755, 0777]
|
||||
];
|
||||
}
|
||||
|
||||
public function acceptsFailsProvider()
|
||||
{
|
||||
return array(
|
||||
array('5', '10'),
|
||||
array(8, 5.0),
|
||||
array(5.0, 8),
|
||||
array(10, null),
|
||||
array(false, 12)
|
||||
);
|
||||
return [
|
||||
['5', '10'],
|
||||
[8, 5.0],
|
||||
[5.0, 8],
|
||||
[10, null],
|
||||
[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),
|
||||
);
|
||||
return [
|
||||
[1337, 1337],
|
||||
['1337', 1337],
|
||||
[0x539, 1337],
|
||||
[02471, 1337],
|
||||
[1337, 1338, 1],
|
||||
['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),
|
||||
);
|
||||
return [
|
||||
[1337, 1338],
|
||||
['1338', 1337],
|
||||
[0x539, 1338],
|
||||
[1337, 1339, 1],
|
||||
['1337', 1340, 2],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -100,9 +104,7 @@ class NumericComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -114,9 +116,9 @@ class NumericComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $delta = 0.0)
|
||||
{
|
||||
$this->setExpectedException(
|
||||
'SebastianBergmann\\Comparator\\ComparisonFailure', 'matches expected'
|
||||
);
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('matches expected');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,12 +11,15 @@
|
||||
namespace SebastianBergmann\Comparator;
|
||||
|
||||
use stdClass;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass SebastianBergmann\Comparator\ObjectComparator
|
||||
*
|
||||
* @uses SebastianBergmann\Comparator\Comparator
|
||||
* @uses SebastianBergmann\Comparator\Factory
|
||||
* @uses SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
class ObjectComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
class ObjectComparatorTest extends TestCase
|
||||
{
|
||||
private $comparator;
|
||||
|
||||
@@ -28,72 +31,72 @@ class ObjectComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
public function acceptsSucceedsProvider()
|
||||
{
|
||||
return array(
|
||||
array(new TestClass, new TestClass),
|
||||
array(new stdClass, new stdClass),
|
||||
array(new stdClass, new TestClass)
|
||||
);
|
||||
return [
|
||||
[new TestClass, new TestClass],
|
||||
[new stdClass, new stdClass],
|
||||
[new stdClass, new TestClass]
|
||||
];
|
||||
}
|
||||
|
||||
public function acceptsFailsProvider()
|
||||
{
|
||||
return array(
|
||||
array(new stdClass, null),
|
||||
array(null, new stdClass),
|
||||
array(null, null)
|
||||
);
|
||||
return [
|
||||
[new stdClass, null],
|
||||
[null, new stdClass],
|
||||
[null, null]
|
||||
];
|
||||
}
|
||||
|
||||
public function assertEqualsSucceedsProvider()
|
||||
{
|
||||
// cyclic dependencies
|
||||
$book1 = new Book;
|
||||
$book1->author = new Author('Terry Pratchett');
|
||||
$book1 = new Book;
|
||||
$book1->author = new Author('Terry Pratchett');
|
||||
$book1->author->books[] = $book1;
|
||||
$book2 = new Book;
|
||||
$book2->author = new Author('Terry Pratchett');
|
||||
$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)
|
||||
);
|
||||
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';
|
||||
$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 = new Book;
|
||||
$book1->author = new Author('Terry Pratchett');
|
||||
$book1->author->books[] = $book1;
|
||||
$book2 = new Book;
|
||||
$book2->author = new Author('Terry Pratch');
|
||||
$book2 = new Book;
|
||||
$book2->author = new Author('Terry Pratch');
|
||||
$book2->author->books[] = $book2;
|
||||
|
||||
$book3 = new Book;
|
||||
$book3 = new Book;
|
||||
$book3->author = 'Terry Pratchett';
|
||||
$book4 = new stdClass;
|
||||
$book4 = new stdClass;
|
||||
$book4->author = 'Terry Pratchett';
|
||||
|
||||
$object1 = new SampleClass( 4, 8, 15);
|
||||
$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)
|
||||
);
|
||||
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]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -128,9 +131,7 @@ class ObjectComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -142,9 +143,9 @@ class ObjectComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $message, $delta = 0.0)
|
||||
{
|
||||
$this->setExpectedException(
|
||||
'SebastianBergmann\\Comparator\\ComparisonFailure', $message
|
||||
);
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage($message);
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual, $delta);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,11 +10,15 @@
|
||||
|
||||
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 \PHPUnit_Framework_TestCase
|
||||
class ResourceComparatorTest extends TestCase
|
||||
{
|
||||
private $comparator;
|
||||
|
||||
@@ -28,22 +32,22 @@ class ResourceComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
$tmpfile1 = tmpfile();
|
||||
$tmpfile2 = tmpfile();
|
||||
|
||||
return array(
|
||||
array($tmpfile1, $tmpfile1),
|
||||
array($tmpfile2, $tmpfile2),
|
||||
array($tmpfile1, $tmpfile2)
|
||||
);
|
||||
return [
|
||||
[$tmpfile1, $tmpfile1],
|
||||
[$tmpfile2, $tmpfile2],
|
||||
[$tmpfile1, $tmpfile2]
|
||||
];
|
||||
}
|
||||
|
||||
public function acceptsFailsProvider()
|
||||
{
|
||||
$tmpfile1 = tmpfile();
|
||||
|
||||
return array(
|
||||
array($tmpfile1, null),
|
||||
array(null, $tmpfile1),
|
||||
array(null, null)
|
||||
);
|
||||
return [
|
||||
[$tmpfile1, null],
|
||||
[null, $tmpfile1],
|
||||
[null, null]
|
||||
];
|
||||
}
|
||||
|
||||
public function assertEqualsSucceedsProvider()
|
||||
@@ -51,10 +55,10 @@ class ResourceComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
$tmpfile1 = tmpfile();
|
||||
$tmpfile2 = tmpfile();
|
||||
|
||||
return array(
|
||||
array($tmpfile1, $tmpfile1),
|
||||
array($tmpfile2, $tmpfile2)
|
||||
);
|
||||
return [
|
||||
[$tmpfile1, $tmpfile1],
|
||||
[$tmpfile2, $tmpfile2]
|
||||
];
|
||||
}
|
||||
|
||||
public function assertEqualsFailsProvider()
|
||||
@@ -62,10 +66,10 @@ class ResourceComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
$tmpfile1 = tmpfile();
|
||||
$tmpfile2 = tmpfile();
|
||||
|
||||
return array(
|
||||
array($tmpfile1, $tmpfile2),
|
||||
array($tmpfile2, $tmpfile1)
|
||||
);
|
||||
return [
|
||||
[$tmpfile1, $tmpfile2],
|
||||
[$tmpfile2, $tmpfile1]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -100,9 +104,7 @@ class ResourceComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -114,7 +116,8 @@ class ResourceComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual)
|
||||
{
|
||||
$this->setExpectedException('SebastianBergmann\\Comparator\\ComparisonFailure');
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,11 +10,15 @@
|
||||
|
||||
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 \PHPUnit_Framework_TestCase
|
||||
class ScalarComparatorTest extends TestCase
|
||||
{
|
||||
private $comparator;
|
||||
|
||||
@@ -25,83 +29,83 @@ class ScalarComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
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")
|
||||
);
|
||||
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 array(
|
||||
array(array(), array()),
|
||||
array("string", array()),
|
||||
array(new ClassWithToString, new ClassWithToString),
|
||||
array(false, new ClassWithToString),
|
||||
array(tmpfile(), tmpfile())
|
||||
);
|
||||
return [
|
||||
[[], []],
|
||||
['string', []],
|
||||
[new ClassWithToString, new ClassWithToString],
|
||||
[false, new ClassWithToString],
|
||||
[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)
|
||||
);
|
||||
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';
|
||||
$otherException = 'matches expected';
|
||||
|
||||
return array(
|
||||
array("string", "other string", $stringException),
|
||||
array("string", "STRING", $stringException),
|
||||
array("STRING", "string", $stringException),
|
||||
array("string", "other string", $stringException),
|
||||
return [
|
||||
['string', 'other string', $stringException],
|
||||
['string', 'STRING', $stringException],
|
||||
['STRING', 'string', $stringException],
|
||||
['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)
|
||||
);
|
||||
['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]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -136,9 +140,7 @@ class ScalarComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual, 0.0, false, $ignoreCase);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -150,9 +152,9 @@ class ScalarComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual, $message)
|
||||
{
|
||||
$this->setExpectedException(
|
||||
'SebastianBergmann\\Comparator\\ComparisonFailure', $message
|
||||
);
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage($message);
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,12 +12,15 @@ namespace SebastianBergmann\Comparator;
|
||||
|
||||
use SplObjectStorage;
|
||||
use stdClass;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass SebastianBergmann\Comparator\SplObjectStorageComparator
|
||||
*
|
||||
* @uses SebastianBergmann\Comparator\Comparator
|
||||
* @uses SebastianBergmann\Comparator\Factory
|
||||
* @uses SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
class SplObjectStorageComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
class SplObjectStorageComparatorTest extends TestCase
|
||||
{
|
||||
private $comparator;
|
||||
|
||||
@@ -28,11 +31,11 @@ class SplObjectStorageComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
public function acceptsFailsProvider()
|
||||
{
|
||||
return array(
|
||||
array(new SplObjectStorage, new stdClass),
|
||||
array(new stdClass, new SplObjectStorage),
|
||||
array(new stdClass, new stdClass)
|
||||
);
|
||||
return [
|
||||
[new SplObjectStorage, new stdClass],
|
||||
[new stdClass, new SplObjectStorage],
|
||||
[new stdClass, new stdClass]
|
||||
];
|
||||
}
|
||||
|
||||
public function assertEqualsSucceedsProvider()
|
||||
@@ -51,12 +54,12 @@ class SplObjectStorageComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
$storage4->attach($object2);
|
||||
$storage4->attach($object1);
|
||||
|
||||
return array(
|
||||
array($storage1, $storage1),
|
||||
array($storage1, $storage2),
|
||||
array($storage3, $storage3),
|
||||
array($storage3, $storage4)
|
||||
);
|
||||
return [
|
||||
[$storage1, $storage1],
|
||||
[$storage1, $storage2],
|
||||
[$storage3, $storage3],
|
||||
[$storage3, $storage4]
|
||||
];
|
||||
}
|
||||
|
||||
public function assertEqualsFailsProvider()
|
||||
@@ -73,11 +76,11 @@ class SplObjectStorageComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
$storage3->attach($object2);
|
||||
$storage3->attach($object1);
|
||||
|
||||
return array(
|
||||
array($storage1, $storage2),
|
||||
array($storage1, $storage3),
|
||||
array($storage2, $storage3),
|
||||
);
|
||||
return [
|
||||
[$storage1, $storage2],
|
||||
[$storage1, $storage3],
|
||||
[$storage2, $storage3],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -114,9 +117,7 @@ class SplObjectStorageComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -128,10 +129,20 @@ class SplObjectStorageComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual)
|
||||
{
|
||||
$this->setExpectedException(
|
||||
'SebastianBergmann\\Comparator\\ComparisonFailure',
|
||||
'Failed asserting that two objects are equal.'
|
||||
);
|
||||
$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());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,12 +11,15 @@
|
||||
namespace SebastianBergmann\Comparator;
|
||||
|
||||
use stdClass;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass SebastianBergmann\Comparator\TypeComparator
|
||||
*
|
||||
* @uses SebastianBergmann\Comparator\Comparator
|
||||
* @uses SebastianBergmann\Comparator\Factory
|
||||
* @uses SebastianBergmann\Comparator\ComparisonFailure
|
||||
*/
|
||||
class TypeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
class TypeComparatorTest extends TestCase
|
||||
{
|
||||
private $comparator;
|
||||
|
||||
@@ -27,40 +30,40 @@ class TypeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
public function acceptsSucceedsProvider()
|
||||
{
|
||||
return array(
|
||||
array(true, 1),
|
||||
array(false, array(1)),
|
||||
array(null, new stdClass),
|
||||
array(1.0, 5),
|
||||
array("", "")
|
||||
);
|
||||
return [
|
||||
[true, 1],
|
||||
[false, [1]],
|
||||
[null, new stdClass],
|
||||
[1.0, 5],
|
||||
['', '']
|
||||
];
|
||||
}
|
||||
|
||||
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))
|
||||
);
|
||||
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 array(
|
||||
array(true, null),
|
||||
array(null, false),
|
||||
array(1.0, 0),
|
||||
array(new stdClass, array()),
|
||||
array("1", 1)
|
||||
);
|
||||
return [
|
||||
[true, null],
|
||||
[null, false],
|
||||
[1.0, 0],
|
||||
[new stdClass, []],
|
||||
['1', 1]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -84,9 +87,7 @@ class TypeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
|
||||
try {
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
|
||||
catch (ComparisonFailure $exception) {
|
||||
} catch (ComparisonFailure $exception) {
|
||||
}
|
||||
|
||||
$this->assertNull($exception, 'Unexpected ComparisonFailure');
|
||||
@@ -98,7 +99,9 @@ class TypeComparatorTest extends \PHPUnit_Framework_TestCase
|
||||
*/
|
||||
public function testAssertEqualsFails($expected, $actual)
|
||||
{
|
||||
$this->setExpectedException('SebastianBergmann\\Comparator\\ComparisonFailure', 'does not match expected type');
|
||||
$this->expectException(ComparisonFailure::class);
|
||||
$this->expectExceptionMessage('does not match expected type');
|
||||
|
||||
$this->comparator->assertEquals($expected, $actual);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,12 +12,11 @@ namespace SebastianBergmann\Comparator;
|
||||
|
||||
/**
|
||||
* An author.
|
||||
*
|
||||
*/
|
||||
class Author
|
||||
{
|
||||
// the order of properties is important for testing the cycle!
|
||||
public $books = array();
|
||||
public $books = [];
|
||||
|
||||
private $name = '';
|
||||
|
||||
@@ -12,7 +12,6 @@ namespace SebastianBergmann\Comparator;
|
||||
|
||||
/**
|
||||
* A book.
|
||||
*
|
||||
*/
|
||||
class Book
|
||||
{
|
||||
@@ -12,7 +12,6 @@ namespace SebastianBergmann\Comparator;
|
||||
|
||||
/**
|
||||
* A sample class.
|
||||
*
|
||||
*/
|
||||
class SampleClass
|
||||
{
|
||||
@@ -12,7 +12,6 @@ namespace SebastianBergmann\Comparator;
|
||||
|
||||
/**
|
||||
* A struct.
|
||||
*
|
||||
*/
|
||||
class Struct
|
||||
{
|
||||
@@ -10,5 +10,6 @@
|
||||
|
||||
namespace SebastianBergmann\Comparator;
|
||||
|
||||
class TestClass {
|
||||
class TestClass
|
||||
{
|
||||
}
|
||||
@@ -10,5 +10,6 @@
|
||||
|
||||
namespace SebastianBergmann\Comparator;
|
||||
|
||||
class TestClassComparator extends ObjectComparator {
|
||||
class TestClassComparator extends ObjectComparator
|
||||
{
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
<?php
|
||||
// @codingStandardsIgnoreFile
|
||||
// @codeCoverageIgnoreStart
|
||||
// this is an autogenerated file - do not edit
|
||||
spl_autoload_register(
|
||||
function($class) {
|
||||
static $classes = null;
|
||||
if ($classes === null) {
|
||||
$classes = array(
|
||||
'sebastianbergmann\\comparator\\arraycomparatortest' => '/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
|
||||
@@ -1,7 +0,0 @@
|
||||
<?php
|
||||
require __DIR__ . '/../vendor/autoload.php';
|
||||
require __DIR__ . '/autoload.php';
|
||||
|
||||
ini_set('precision', 14);
|
||||
ini_set('serialize_precision', 14);
|
||||
|
||||
Reference in New Issue
Block a user