tests/PHPUnit/Framework/Constraint/IsEqual.php

   1 <?php
   2 /**
   3  * PHPUnit
   4  *
   5  * Copyright (c) 2002-2009, Sebastian Bergmann <sb@sebastian-bergmann.de>.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  *   * Redistributions of source code must retain the above copyright
  13  *     notice, this list of conditions and the following disclaimer.
  14  *
  15  *   * Redistributions in binary form must reproduce the above copyright
  16  *     notice, this list of conditions and the following disclaimer in
  17  *     the documentation and/or other materials provided with the
  18  *     distribution.
  19  *
  20  *   * Neither the name of Sebastian Bergmann nor the names of his
  21  *     contributors may be used to endorse or promote products derived
  22  *     from this software without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  27  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  28  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  30  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  32  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  34  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  35  * POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  * @category   Testing
  38  * @package    PHPUnit
  39  * @author     Kore Nordmann <kn@ez.no>
  40  * @author     Sebastian Bergmann <sb@sebastian-bergmann.de>
  41  * @copyright  2002-2009 Sebastian Bergmann <sb@sebastian-bergmann.de>
  42  * @license    http://www.opensource.org/licenses/bsd-license.php  BSD License
  43
  44  * @link       http://www.phpunit.de/
  45  * @since      File available since Release 3.0.0
  46  */
  47
  48 require_once 'PHPUnit/Framework.php';
  49 require_once 'PHPUnit/Util/Filter.php';
  50 require_once 'PHPUnit/Util/Type.php';
  51
  52 PHPUnit_Util_Filter::addFileToFilter(__FILE__, 'PHPUNIT');
  53
  54 /**
  55  * Constraint that checks if one value is equal to another.
  56  *
  57  * Equality is checked with PHP's == operator, the operator is explained in detail
  58  * at {@url http://www.php.net/manual/en/types.comparisons.php}.
  59  * Two values are equal if they have the same value disregarding type.
  60  *
  61  * The expected value is passed in the constructor.
  62  *
  63  * @category   Testing
  64  * @package    PHPUnit
  65  * @author     Kore Nordmann <kn@ez.no>
  66  * @author     Sebastian Bergmann <sb@sebastian-bergmann.de>
  67  * @copyright  2002-2009 Sebastian Bergmann <sb@sebastian-bergmann.de>
  68  * @license    http://www.opensource.org/licenses/bsd-license.php  BSD License
  69  * @version    Release: 3.3.17
  70  * @link       http://www.phpunit.de/
  71  * @since      Class available since Release 3.0.0
  72  */
  73 class PHPUnit_Framework_Constraint_IsEqual extends PHPUnit_Framework_Constraint
  74 {
  75     protected $value;
  76     protected $delta = 0;
  77     protected $maxDepth = 10;
  78     protected $canonicalizeEol = FALSE;
  79
  80     public function __construct($value, $delta = 0, $maxDepth = 10, $canonicalizeEol = FALSE)
  81     {
  82         $this->value           = $value;
  83         $this->delta           = $delta;
  84         $this->maxDepth        = $maxDepth;
  85         $this->canonicalizeEol = $canonicalizeEol;
  86     }
  87
  88     /**
  89      * Evaluates the constraint for parameter $other. Returns TRUE if the
  90      * constraint is met, FALSE otherwise.
  91      *
  92      * @param mixed $other Value or object to evaluate.
  93      * @return bool
  94      */
  95     public function evaluate($other)
  96     {
  97         return $this->recursiveComparison($this->value, $other);
  98     }
  99
 100     /**
 101      * @param   mixed   $other The value passed to evaluate() which failed the
 102      *                         constraint check.
 103      * @param   string  $description A string with extra description of what was
 104      *                               going on while the evaluation failed.
 105      * @param   boolean $not Flag to indicate negation.
 106      * @throws  PHPUnit_Framework_ExpectationFailedException
 107      */
 108     public function fail($other, $description, $not = FALSE)
 109     {
 110         $failureDescription = $this->failureDescription(
 111           $other,
 112           $description,
 113           $not
 114         );
 115
 116         if (!$not) {
 117             if ($this->value instanceof DOMDocument) {
 118                 $value = $this->domToText($this->value);
 119             } else {
 120                 $value = $this->value;
 121             }
 122
 123             if ($other instanceof DOMDocument) {
 124                 $other = $this->domToText($other);
 125             }
 126
 127             throw new PHPUnit_Framework_ExpectationFailedException(
 128               $failureDescription,
 129               PHPUnit_Framework_ComparisonFailure::diffEqual($value, $other),
 130               $description
 131             );
 132         } else {
 133             throw new PHPUnit_Framework_ExpectationFailedException(
 134               $failureDescription,
 135               NULL
 136             );
 137         }
 138     }
 139
 140     /**
 141      * Returns a string representation of the constraint.
 142      *
 143      * @return string
 144      */
 145     public function toString()
 146     {
 147         $delta = '';
 148
 149         if (is_string($this->value)) {
 150             if (strpos($this->value, "\n") !== FALSE) {
 151                 return 'is equal to <text>';
 152             } else {
 153                 return sprintf(
 154                   'is equal to <string:%s>',
 155
 156                   $this->value
 157                 );
 158             }
 159         } else {
 160             if ($this->delta != 0) {
 161                 $delta = sprintf(
 162                   ' with delta <%F>',
 163
 164                   $this->delta
 165                 );
 166             }
 167
 168             return sprintf(
 169               'is equal to %s%s',
 170
 171               PHPUnit_Util_Type::toString($this->value),
 172               $delta
 173             );
 174         }
 175     }
 176
 177     /**
 178      * Perform the actual recursive comparision of two values
 179      *
 180      * @param mixed $a First value
 181      * @param mixed $b Second value
 182      * @param int $depth Depth
 183      * @return bool
 184      */
 185     protected function recursiveComparison($a, $b, $depth = 0)
 186     {
 187         if ($a === $b) {
 188             return TRUE;
 189         }
 190
 191         if ($depth >= $this->maxDepth) {
 192             return TRUE;
 193         }
 194
 195         if (is_numeric($a) XOR is_numeric($b)) {
 196             return FALSE;
 197         }
 198
 199         if (is_array($a) XOR is_array($b)) {
 200             return FALSE;
 201         }
 202
 203         if (is_object($a) XOR is_object($b)) {
 204             return FALSE;
 205         }
 206
 207         if ($a instanceof SplObjectStorage XOR $b instanceof SplObjectStorage) {
 208             return FALSE;
 209         }
 210
 211         if ($a instanceof SplObjectStorage) {
 212             foreach ($a as $object) {
 213                 if (!$b->contains($object)) {
 214                     return FALSE;
 215                 }
 216             }
 217
 218             foreach ($b as $object) {
 219                 if (!$a->contains($object)) {
 220                     return FALSE;
 221                 }
 222             }
 223
 224             return TRUE;
 225         }
 226
 227         if ($a instanceof DOMDocument || $b instanceof DOMDocument) {
 228             if (!$a instanceof DOMDocument) {
 229                 $_a = new DOMDocument;
 230                 $_a->preserveWhiteSpace = FALSE;
 231                 $_a->loadXML($a);
 232                 $a = $_a;
 233                 unset($_a);
 234             }
 235
 236             if (!$b instanceof DOMDocument) {
 237                 $_b = new DOMDocument;
 238                 $_b->preserveWhiteSpace = FALSE;
 239                 $_b->loadXML($b);
 240                 $b = $_b;
 241                 unset($_b);
 242             }
 243
 244             if (version_compare(PHP_VERSION, '5.2.0RC1', '>=')) {
 245                 return ($a->C14N() == $b->C14N());
 246             } else {
 247                 return ($a->saveXML() == $b->saveXML());
 248             }
 249         }
 250
 251         if (is_object($a) && is_object($b) &&
 252            (get_class($a) !== get_class($b))) {
 253             return FALSE;
 254         }
 255
 256         // Normal comparision for scalar values.
 257         if ((!is_array($a) && !is_object($a)) ||
 258             (!is_array($b) && !is_object($b))) {
 259             if (is_numeric($a) && is_numeric($b)) {
 260                 // Optionally apply delta on numeric values.
 261                 return $this->numericComparison($a, $b);
 262             }
 263
 264             if ($this->canonicalizeEol && PHP_EOL != "\n" &&
 265                 is_string($a) && is_string($b)) {
 266                 $a = str_replace(PHP_EOL, "\n", $a);
 267                 $b = str_replace(PHP_EOL, "\n", $b);
 268             }
 269
 270             return ($a == $b);
 271         }
 272
 273         if (is_object($a)) {
 274             $a = (array)$a;
 275             $b = (array)$b;
 276         }
 277
 278         foreach ($a as $key => $v) {
 279             if (!array_key_exists($key, $b)) {
 280                 // Abort on missing key in $b.
 281                 return FALSE;
 282             }
 283
 284             if (!$this->recursiveComparison($a[$key], $b[$key], $depth + 1)) {
 285                 // FALSE, if child comparision fails.
 286                 return FALSE;
 287             }
 288
 289             // Unset key to check whether all keys of b are compared.
 290             unset($b[$key]);
 291         }
 292
 293         if (count($b)) {
 294             // There is something in $b, that is missing in $a.
 295             return FALSE;
 296         }
 297
 298         return TRUE;
 299     }
 300
 301     /**
 302      * Compares two numeric values - use delta if applicable.
 303      *
 304      * @param mixed $a
 305      * @param mixed $b
 306      * @return bool
 307      */
 308     protected function numericComparison($a, $b)
 309     {
 310         if ($this->delta === FALSE) {
 311             return ($a == $b);
 312         } else {
 313             return (abs($a - $b) <= $this->delta);
 314         }
 315     }
 316
 317     /**
 318      * Returns the normalized, whitespace-cleaned, and indented textual
 319      * representation of a DOMDocument.
 320      *
 321      * @param DOMDocument $document
 322      * @return string
 323      */
 324     protected function domToText(DOMDocument $document)
 325     {
 326         $document->formatOutput = TRUE;
 327         $document->normalizeDocument();
 328
 329         return $document->saveXML();
 330     }
 331 }
 332 ?>