summaryrefslogtreecommitdiff
path: root/test_tools/simpletest/dumper.php
blob: f54140ca94388fe96ec9dd51dc384637003e3fb9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
<?php
    /**
     *	base include file for SimpleTest
     *	@package	SimpleTest
     *	@subpackage	UnitTester
     *	@version	$Id: dumper.php,v 1.22 2005/02/05 04:51:17 lastcraft Exp $
     */
    /**
     * does type matter
     */
    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, 100);
                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, 100, $position) . "] and [" .
                    $this->clipString($second, 100, $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) . "]";
        }
        
        /**
         *    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;
        }

        /**
         *    Extracts the last assertion that was not within
         *    Simpletest itself. The name must start with "assert".
         *    @param array $stack      List of stack frames.
         *    @param string $format    String formatting.
         *    @param string $prefix    Prefix of method to search for.
         *    @access public
         *    @static
         */
        function getFormattedAssertionLine($stack, $format = '%d', $prefix = 'assert') {
            foreach ($stack as $frame) {
                if (isset($frame['file']) && strpos($frame['file'], 'simpletest') !== false) {     // dirname() is a bit slow.
                    if (substr(dirname($frame['file']), -10) == 'simpletest') {
                        continue;
                    }
                }
                if (strncmp($frame['function'], $prefix, strlen($prefix)) == 0) {
                    return sprintf($format, $frame['line']);
                }
            }
            return '';
        }
    }
?>