Source for file compatibility.php

Documentation is available at compatibility.php

  1. <?php
  2. /**
  3.  *  base include file for SimpleTest
  4.  *  @package    SimpleTest
  5.  *  @version    $Id: compatibility.php 1900 2009-07-29 11:44:37Z lastcraft $
  6.  */
  7.  
  8. /**
  9.  *  Static methods for compatibility between different
  10.  *  PHP versions.
  11.  *  @package    SimpleTest
  12.  */
  13. class SimpleTestCompatibility {
  14.  
  15.     /**
  16.      *    Creates a copy whether in PHP5 or PHP4.
  17.      *    @param object $object     Thing to copy.
  18.      *    @return object            A copy.
  19.      *    @access public
  20.      */
  21.     static function copy($object) {
  22.         if (version_compare(phpversion(), '5') >= 0) {
  23.             eval('$copy = clone $object;');
  24.             return $copy;
  25.         }
  26.         return $object;
  27.     }
  28.  
  29.     /**
  30.      *    Identity test. Drops back to equality + types for PHP5
  31.      *    objects as the === operator counts as the
  32.      *    stronger reference constraint.
  33.      *    @param mixed $first    Test subject.
  34.      *    @param mixed $second   Comparison object.
  35.      *    @return boolean        True if identical.
  36.      *    @access public
  37.      */
  38.     static function isIdentical($first, $second) {
  39.         if (version_compare(phpversion(), '5') >= 0) {
  40.             return SimpleTestCompatibility::isIdenticalType($first, $second);
  41.         }
  42.         if ($first != $second) {
  43.             return false;
  44.         }
  45.         return ($first === $second);
  46.     }
  47.  
  48.     /**
  49.      *    Recursive type test.
  50.      *    @param mixed $first    Test subject.
  51.      *    @param mixed $second   Comparison object.
  52.      *    @return boolean        True if same type.
  53.      *    @access private
  54.      */
  55.     protected static function isIdenticalType($first, $second) {
  56.         if (gettype($first) != gettype($second)) {
  57.             return false;
  58.         }
  59.         if (is_object($first) && is_object($second)) {
  60.             if (get_class($first) != get_class($second)) {
  61.                 return false;
  62.             }
  63.             return SimpleTestCompatibility::isArrayOfIdenticalTypes(
  64.                     (array) $first,
  65.                     (array) $second);
  66.         }
  67.         if (is_array($first) && is_array($second)) {
  68.             return SimpleTestCompatibility::isArrayOfIdenticalTypes($first, $second);
  69.         }
  70.         if ($first !== $second) {
  71.             return false;
  72.         }
  73.         return true;
  74.     }
  75.  
  76.     /**
  77.      *    Recursive type test for each element of an array.
  78.      *    @param mixed $first    Test subject.
  79.      *    @param mixed $second   Comparison object.
  80.      *    @return boolean        True if identical.
  81.      *    @access private
  82.      */
  83.     protected static function isArrayOfIdenticalTypes($first, $second) {
  84.         if (array_keys($first) != array_keys($second)) {
  85.             return false;
  86.         }
  87.         foreach (array_keys($first) as $key) {
  88.             $is_identical = SimpleTestCompatibility::isIdenticalType(
  89.                     $first[$key],
  90.                     $second[$key]);
  91.             if (! $is_identical) {
  92.                 return false;
  93.             }
  94.         }
  95.         return true;
  96.     }
  97.  
  98.     /**
  99.      *    Test for two variables being aliases.
  100.      *    @param mixed $first    Test subject.
  101.      *    @param mixed $second   Comparison object.
  102.      *    @return boolean        True if same.
  103.      *    @access public
  104.      */
  105.     static function isReference(&$first, &$second) {
  106.         if (version_compare(phpversion(), '5', '>=') && is_object($first)) {
  107.             return ($first === $second);
  108.         }
  109.         if (is_object($first) && is_object($second)) {
  110.             $id = uniqid("test");
  111.             $first->$id = true;
  112.             $is_ref = isset($second->$id);
  113.             unset($first->$id);
  114.             return $is_ref;
  115.         }
  116.         $temp = $first;
  117.         $first = uniqid("test");
  118.         $is_ref = ($first === $second);
  119.         $first = $temp;
  120.         return $is_ref;
  121.     }
  122.  
  123.     /**
  124.      *    Test to see if an object is a member of a
  125.      *    class hiearchy.
  126.      *    @param object $object    Object to test.
  127.      *    @param string $class     Root name of hiearchy.
  128.      *    @return boolean         True if class in hiearchy.
  129.      *    @access public
  130.      */
  131.     static function isA($object, $class) {
  132.         if (version_compare(phpversion(), '5') >= 0) {
  133.             if (! class_exists($class, false)) {
  134.                 if (function_exists('interface_exists')) {
  135.                     if (! interface_exists($class, false))  {
  136.                         return false;
  137.                     }
  138.                 }
  139.             }
  140.             eval("\$is_a = \$object instanceof $class;");
  141.             return $is_a;
  142.         }
  143.         if (function_exists('is_a')) {
  144.             return is_a($object, $class);
  145.         }
  146.         return ((strtolower($class) == get_class($object))
  147.                 or (is_subclass_of($object, $class)));
  148.     }
  149.  
  150.     /**
  151.      *    Sets a socket timeout for each chunk.
  152.      *    @param resource $handle    Socket handle.
  153.      *    @param integer $timeout    Limit in seconds.
  154.      *    @access public
  155.      */
  156.     static function setTimeout($handle, $timeout) {
  157.         if (function_exists('stream_set_timeout')) {
  158.             stream_set_timeout($handle, $timeout, 0);
  159.         } elseif (function_exists('socket_set_timeout')) {
  160.             socket_set_timeout($handle, $timeout, 0);
  161.         } elseif (function_exists('set_socket_timeout')) {
  162.             set_socket_timeout($handle, $timeout, 0);
  163.         }
  164.     }
  165. }
  166. ?>

Documentation generated on Thu, 01 Oct 2009 20:54:27 -0500 by phpDocumentor 1.4.2