Added simpletest and start of unit tests.

git-svn-id: http://code.elgg.org/elgg/trunk@3503 36083f99-b078-4883-b0ff-0f9b5a30f544

1 files changed, 360 insertions, 0 deletions

diff --git a/vendors/simpletest/dumper.php b/vendors/simpletest/dumper.php
new file mode 100755
index 000000000..2d75985c0
--- /dev/null
+++ b/vendors/simpletest/dumper.php
@@ -0,0 +1,360 @@
+<?php
+/**
+ *  base include file for SimpleTest
+ *  @package    SimpleTest
+ *  @subpackage UnitTester
+ *  @version    $Id: dumper.php 1723 2008-04-08 00:34:10Z lastcraft $
+ */
+/**
+ * does type matter
+ */
+if (! defined('TYPE_MATTERS')) {
+    define('TYPE_MATTERS', true);
+}
+
+/**
+ *    Displays variables as text and does diffs.
+ *    @package  SimpleTest
+ *    @subpackage   UnitTester
+ */
+class SimpleDumper {
+    
+    /**
+     *    Renders a variable in a shorter form than print_r().
+     *    @param mixed $value      Variable to render as a string.
+     *    @return string           Human readable string form.
+     *    @access public
+     */
+    function describeValue($value) {
+        $type = $this->getType($value);
+        switch($type) {
+            case "Null":
+                return "NULL";
+            case "Boolean":
+                return "Boolean: " . ($value ? "true" : "false");
+            case "Array":
+                return "Array: " . count($value) . " items";
+            case "Object":
+                return "Object: of " . get_class($value);
+            case "String":
+                return "String: " . $this->clipString($value, 200);
+            default:
+                return "$type: $value";
+        }
+        return "Unknown";
+    }
+    
+    /**
+     *    Gets the string representation of a type.
+     *    @param mixed $value    Variable to check against.
+     *    @return string         Type.
+     *    @access public
+     */
+    function getType($value) {
+        if (! isset($value)) {
+            return "Null";
+        } elseif (is_bool($value)) {
+            return "Boolean";
+        } elseif (is_string($value)) {
+            return "String";
+        } elseif (is_integer($value)) {
+            return "Integer";
+        } elseif (is_float($value)) {
+            return "Float";
+        } elseif (is_array($value)) {
+            return "Array";
+        } elseif (is_resource($value)) {
+            return "Resource";
+        } elseif (is_object($value)) {
+            return "Object";
+        }
+        return "Unknown";
+    }
+
+    /**
+     *    Creates a human readable description of the
+     *    difference between two variables. Uses a
+     *    dynamic call.
+     *    @param mixed $first        First variable.
+     *    @param mixed $second       Value to compare with.
+     *    @param boolean $identical  If true then type anomolies count.
+     *    @return string             Description of difference.
+     *    @access public
+     */
+    function describeDifference($first, $second, $identical = false) {
+        if ($identical) {
+            if (! $this->_isTypeMatch($first, $second)) {
+                return "with type mismatch as [" . $this->describeValue($first) .
+                    "] does not match [" . $this->describeValue($second) . "]";
+            }
+        }
+        $type = $this->getType($first);
+        if ($type == "Unknown") {
+            return "with unknown type";
+        }
+        $method = '_describe' . $type . 'Difference';
+        return $this->$method($first, $second, $identical);
+    }
+    
+    /**
+     *    Tests to see if types match.
+     *    @param mixed $first        First variable.
+     *    @param mixed $second       Value to compare with.
+     *    @return boolean            True if matches.
+     *    @access private
+     */
+    function _isTypeMatch($first, $second) {
+        return ($this->getType($first) == $this->getType($second));
+    }
+
+    /**
+     *    Clips a string to a maximum length.
+     *    @param string $value         String to truncate.
+     *    @param integer $size         Minimum string size to show.
+     *    @param integer $position     Centre of string section.
+     *    @return string               Shortened version.
+     *    @access public
+     */
+    function clipString($value, $size, $position = 0) {
+        $length = strlen($value);
+        if ($length <= $size) {
+            return $value;
+        }
+        $position = min($position, $length);
+        $start = ($size/2 > $position ? 0 : $position - $size/2);
+        if ($start + $size > $length) {
+            $start = $length - $size;
+        }
+        $value = substr($value, $start, $size);
+        return ($start > 0 ? "..." : "") . $value . ($start + $size < $length ? "..." : "");
+    }
+    
+    /**
+     *    Creates a human readable description of the
+     *    difference between two variables. The minimal
+     *    version.
+     *    @param null $first          First value.
+     *    @param mixed $second        Value to compare with.
+     *    @return string              Human readable description.
+     *    @access private
+     */
+    function _describeGenericDifference($first, $second) {
+        return "as [" . $this->describeValue($first) .
+                "] does not match [" .
+                $this->describeValue($second) . "]";
+    }
+    
+    /**
+     *    Creates a human readable description of the
+     *    difference between a null and another variable.
+     *    @param null $first          First null.
+     *    @param mixed $second        Null to compare with.
+     *    @param boolean $identical   If true then type anomolies count.
+     *    @return string              Human readable description.
+     *    @access private
+     */
+    function _describeNullDifference($first, $second, $identical) {
+        return $this->_describeGenericDifference($first, $second);
+    }
+    
+    /**
+     *    Creates a human readable description of the
+     *    difference between a boolean and another variable.
+     *    @param boolean $first       First boolean.
+     *    @param mixed $second        Boolean to compare with.
+     *    @param boolean $identical   If true then type anomolies count.
+     *    @return string              Human readable description.
+     *    @access private
+     */
+    function _describeBooleanDifference($first, $second, $identical) {
+        return $this->_describeGenericDifference($first, $second);
+    }
+    
+    /**
+     *    Creates a human readable description of the
+     *    difference between a string and another variable.
+     *    @param string $first        First string.
+     *    @param mixed $second        String to compare with.
+     *    @param boolean $identical   If true then type anomolies count.
+     *    @return string              Human readable description.
+     *    @access private
+     */
+    function _describeStringDifference($first, $second, $identical) {
+        if (is_object($second) || is_array($second)) {
+            return $this->_describeGenericDifference($first, $second);
+        }
+        $position = $this->_stringDiffersAt($first, $second);
+        $message = "at character $position";
+        $message .= " with [" .
+                $this->clipString($first, 200, $position) . "] and [" .
+                $this->clipString($second, 200, $position) . "]";
+        return $message;
+    }
+    
+    /**
+     *    Creates a human readable description of the
+     *    difference between an integer and another variable.
+     *    @param integer $first       First number.
+     *    @param mixed $second        Number to compare with.
+     *    @param boolean $identical   If true then type anomolies count.
+     *    @return string              Human readable description.
+     *    @access private
+     */
+    function _describeIntegerDifference($first, $second, $identical) {
+        if (is_object($second) || is_array($second)) {
+            return $this->_describeGenericDifference($first, $second);
+        }
+        return "because [" . $this->describeValue($first) .
+                "] differs from [" .
+                $this->describeValue($second) . "] by " .
+                abs($first - $second);
+    }
+    
+    /**
+     *    Creates a human readable description of the
+     *    difference between two floating point numbers.
+     *    @param float $first         First float.
+     *    @param mixed $second        Float to compare with.
+     *    @param boolean $identical   If true then type anomolies count.
+     *    @return string              Human readable description.
+     *    @access private
+     */
+    function _describeFloatDifference($first, $second, $identical) {
+        if (is_object($second) || is_array($second)) {
+            return $this->_describeGenericDifference($first, $second);
+        }
+        return "because [" . $this->describeValue($first) .
+                "] differs from [" .
+                $this->describeValue($second) . "] by " .
+                abs($first - $second);
+    }
+    
+    /**
+     *    Creates a human readable description of the
+     *    difference between two arrays.
+     *    @param array $first         First array.
+     *    @param mixed $second        Array to compare with.
+     *    @param boolean $identical   If true then type anomolies count.
+     *    @return string              Human readable description.
+     *    @access private
+     */
+    function _describeArrayDifference($first, $second, $identical) {
+        if (! is_array($second)) {
+            return $this->_describeGenericDifference($first, $second);
+        }
+        if (! $this->_isMatchingKeys($first, $second, $identical)) {
+            return "as key list [" .
+                    implode(", ", array_keys($first)) . "] does not match key list [" .
+                    implode(", ", array_keys($second)) . "]";
+        }
+        foreach (array_keys($first) as $key) {
+            if ($identical && ($first[$key] === $second[$key])) {
+                continue;
+            }
+            if (! $identical && ($first[$key] == $second[$key])) {
+                continue;
+            }
+            return "with member [$key] " . $this->describeDifference(
+                    $first[$key],
+                    $second[$key],
+                    $identical);
+        }
+        return "";
+    }
+    
+    /**
+     *    Compares two arrays to see if their key lists match.
+     *    For an identical match, the ordering and types of the keys
+     *    is significant.
+     *    @param array $first         First array.
+     *    @param array $second        Array to compare with.
+     *    @param boolean $identical   If true then type anomolies count.
+     *    @return boolean             True if matching.
+     *    @access private
+     */
+    function _isMatchingKeys($first, $second, $identical) {
+        $first_keys = array_keys($first);
+        $second_keys = array_keys($second);
+        if ($identical) {
+            return ($first_keys === $second_keys);
+        }
+        sort($first_keys);
+        sort($second_keys);
+        return ($first_keys == $second_keys);
+    }
+    
+    /**
+     *    Creates a human readable description of the
+     *    difference between a resource and another variable.
+     *    @param resource $first       First resource.
+     *    @param mixed $second         Resource to compare with.
+     *    @param boolean $identical    If true then type anomolies count.
+     *    @return string              Human readable description.
+     *    @access private
+     */
+    function _describeResourceDifference($first, $second, $identical) {
+        return $this->_describeGenericDifference($first, $second);
+    }
+    
+    /**
+     *    Creates a human readable description of the
+     *    difference between two objects.
+     *    @param object $first        First object.
+     *    @param mixed $second        Object to compare with.
+     *    @param boolean $identical   If true then type anomolies count.
+     *    @return string              Human readable description.
+     *    @access private
+     */
+    function _describeObjectDifference($first, $second, $identical) {
+        if (! is_object($second)) {
+            return $this->_describeGenericDifference($first, $second);
+        }
+        return $this->_describeArrayDifference(
+                get_object_vars($first),
+                get_object_vars($second),
+                $identical);
+    }
+    
+    /**
+     *    Find the first character position that differs
+     *    in two strings by binary chop.
+     *    @param string $first        First string.
+     *    @param string $second       String to compare with.
+     *    @return integer             Position of first differing
+     *                                character.
+     *    @access private
+     */
+    function _stringDiffersAt($first, $second) {
+        if (! $first || ! $second) {
+            return 0;
+        }
+        if (strlen($first) < strlen($second)) {
+            list($first, $second) = array($second, $first);
+        }
+        $position = 0;
+        $step = strlen($first);
+        while ($step > 1) {
+            $step = (integer)(($step + 1) / 2);
+            if (strncmp($first, $second, $position + $step) == 0) {
+                $position += $step;
+            }
+        }
+        return $position;
+    }
+    
+    /**
+     *    Sends a formatted dump of a variable to a string.
+     *    @param mixed $variable    Variable to display.
+     *    @return string            Output from print_r().
+     *    @access public
+     *    @static
+     */
+    function dump($variable) {
+        ob_start();
+        print_r($variable);
+        $formatted = ob_get_contents();
+        ob_end_clean();
+        return $formatted;
+    }
+}
+?>
\ No newline at end of file