Subversion-Projekte lars-tiefland.php_share

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
1 lars 1 
<?php
2 
@include_once 'Text/Diff.php';
3 
@include_once 'Text/Diff/Renderer.php';
4 
@include_once 'Text/Diff/Renderer/unified.php';
5 
require_once 'PEAR/ErrorStack.php';
6 
require_once 'PEAR.php';
7 
class PEAR_PHPTest
8 
{
9 
    var $_diffonly;
10 
    var $_errors;
11 
    function PEAR_PHPTest($diffonly = false)
12 
    {
13 
        $this->_diffonly = $diffonly;
14 
        $this->_errors = array();
15 
        PEAR::setErrorHandling(PEAR_ERROR_CALLBACK, array(&$this, 'pearerrorCallback'));
16 
        PEAR_ErrorStack::setDefaultCallback(array(&$this, 'pearerrorstackCallback'));
17 
    }
18 
 
19 
    function pearerrorCallback($err)
20 
    {
21 
        PEAR_ErrorStack::staticPush('PEAR_Error', -1, 'error', array('obj' => $err),
22 
            $err->getMessage());
23 
    }
24 
 
25 
    function pearerrorstackCallback($err)
26 
    {
27 
        $this->_errors[] = $err;
28 
    }
29 
 
30 
    function assertPEARError($err, $message)
31 
    {
32 
        if (is_a($err, 'PEAR_Error')) {
33 
            return true;
34 
        }
35 
        $this->_failTest(debug_backtrace(), $message);
36 
        echo "Not a PEAR_Error\n";
37 
        return false;
38 
    }
39 
 
40 
    function assertNoErrors($message, $trace = null)
41 
    {
42 
        if (count($this->_errors) == 0) {
43 
            return true;
44 
        }
45 
        if ($trace === null) {
46 
            $trace = debug_backtrace();
47 
        }
48 
        $this->_failTest($trace, $message);
49 
        foreach ($this->_errors as $err) {
50 
            if ($err['package'] == 'PEAR_Error') {
51 
                echo "Unexpected PEAR_Error:\n";
52 
                echo 'message "' . $err['message'] . "\"\n";
53 
            } else {
54 
                echo "Unexpected PEAR_ErrorStack error:\n";
55 
                echo 'package "' . $err['package'] . "\"\n";
56 
                echo 'message "' . $err['message'] . "\"\n";
57 
            }
58 
        }
59 
        $this->_errors = array();
60 
        return false;
61 
    }
62 
 
63 
    function assertErrors($errors, $message, $trace = null)
64 
    {
65 
        if (!count($this->_errors)) {
66 
            if ($trace === null) {
67 
                $trace = debug_backtrace();
68 
            }
69 
            $this->_failTest($trace, $message);
70 
            echo "No errors caught, but errors were expected\n";
71 
            return false;
72 
        }
73 
        if (!isset($errors[0])) {
74 
            $errors = array($errors);
75 
        }
76 
        $failed = false;
77 
        foreach ($errors as $err) {
78 
            $found = false;
79 
            foreach ($this->_errors as $i => $caughterror) {
80 
                if ($caughterror['package'] == $err['package']) {
81 
                    if ($caughterror['message'] == $err['message']) {
82 
                        $found = true;
83 
                        break;
84 
                    }
85 
                }
86 
            }
87 
            if ($found) {
88 
                unset($this->_errors[$i]);
89 
                continue;
90 
            }
91 
            if (!$failed) {
92 
                if ($trace === null) {
93 
                    $trace = debug_backtrace();
94 
                }
95 
                $failed = true;
96 
                $this->_failTest($trace, $message);
97 
            }
98 
            echo "Unthrown error:\n";
99 
            if ($err['package'] == 'PEAR_Error') {
100 
                echo "PEAR_Error:\n";
101 
            } else {
102 
                echo "error package: \"$err[package]\"\n";
103 
            }
104 
            echo "message: \"$err[message]\"\n";
105 
        }
106 
        if (count($this->_errors)) {
107 
            if (!$failed) {
108 
                if ($trace === null) {
109 
                    $trace = debug_backtrace();
110 
                }
111 
                $failed = true;
112 
                $this->_failTest($trace, $message);
113 
            }
114 
            foreach ($this->_errors as $err) {
115 
                echo "Unexpected error:\n";
116 
                if ($err['package'] == 'PEAR_Error') {
117 
                    echo "PEAR_Error:\n";
118 
                } else {
119 
                    echo "error package: \"$err[package]\"\n";
120 
                }
121 
                echo "message: \"$err[message]\"\n";
122 
            }
123 
        }
124 
        $this->_errors = array();
125 
        return !$failed;
126 
    }
127 
 
128 
    function assertTrue($test, $message)
129 
    {
130 
        $this->assertNoErrors($message, debug_backtrace());
131 
        if ($test === true) {
132 
            return true;
133 
        }
134 
        $this->_failTest(debug_backtrace(), $message);
135 
        echo "Unexpected non-true value: \n";
136 
        var_export($test);
137 
        echo "\n'$message'\n";
138 
        return false;
139 
    }
140 
 
141 
    function assertIsa($control, $test, $message)
142 
    {
143 
        $this->assertNoErrors($message, debug_backtrace());
144 
        if (is_a($test, $control)) {
145 
            return true;
146 
        }
147 
        $this->_failTest(debug_backtrace(), $message);
148 
        echo "Unexpected non-$control object: \n";
149 
        var_export($test);
150 
        echo "\n'$message'\n";
151 
        return false;
152 
    }
153 
 
154 
    function assertNull($test, $message)
155 
    {
156 
        $this->assertNoErrors($message, debug_backtrace());
157 
        if ($test === null) {
158 
            return true;
159 
        }
160 
        $this->_failTest(debug_backtrace(), $message);
161 
        echo "Unexpected non-null value: \n";
162 
        var_export($test);
163 
        echo "\n'$message'\n";
164 
        return false;
165 
    }
166 
 
167 
    function assertNotNull($test, $message)
168 
    {
169 
        $this->assertNoErrors($message, debug_backtrace());
170 
        if ($test !== null) {
171 
            return true;
172 
        }
173 
        $this->_failTest(debug_backtrace(), $message);
174 
        echo "Unexpected null: \n";
175 
        var_export($test);
176 
        echo "\n'$message'\n";
177 
        return false;
178 
    }
179 
 
180 
    function assertSame($test, $test1, $message)
181 
    {
182 
        $this->assertNoErrors($message, debug_backtrace());
183 
        if ($test === $test1) {
184 
            return true;
185 
        }
186 
        $this->_failTest(debug_backtrace(), $message);
187 
        echo "Unexpectedly two vars are not the same thing: \n";
188 
        echo "\n'$message'\n";
189 
        return false;
190 
    }
191 
 
192 
    function assertNotSame($test, $test1, $message)
193 
    {
194 
        $this->assertNoErrors($message, debug_backtrace());
195 
        if ($test !== $test1) {
196 
            return true;
197 
        }
198 
        $this->_failTest(debug_backtrace(), $message);
199 
        echo "Unexpectedly two vars are the same thing: \n";
200 
        echo "\n'$message'\n";
201 
        return false;
202 
    }
203 
 
204 
    function assertFalse($test, $message)
205 
    {
206 
        $this->assertNoErrors($message, debug_backtrace());
207 
        if ($test === false) {
208 
            return true;
209 
        }
210 
        $this->_failTest(debug_backtrace(), $message);
211 
        echo "Unexpected non-false value: \n";
212 
        var_export($test);
213 
        echo "\n'$message'\n";
214 
        return false;
215 
    }
216 
 
217 
    function assertNotTrue($test, $message)
218 
    {
219 
        $this->assertNoErrors($message, debug_backtrace());
220 
        if (!$test) {
221 
            return true;
222 
        }
223 
        $this->_failTest(debug_backtrace(), $message);
224 
        echo "Unexpected loose true value: \n";
225 
        var_export($test);
226 
        echo "\n'$message'\n";
227 
        return false;
228 
    }
229 
 
230 
    function assertNotFalse($test, $message)
231 
    {
232 
        $this->assertNoErrors($message, debug_backtrace());
233 
        if ($test) {
234 
            return true;
235 
        }
236 
        $this->_failTest(debug_backtrace(), $message);
237 
        echo "Unexpected loose false value: \n";
238 
        var_export($test);
239 
        echo "\n'$message'\n";
240 
        return false;
241 
    }
242 
 
243 
    function assertEquals($control, $test, $message)
244 
    {
245 
        $this->assertNoErrors($message, debug_backtrace());
246 
        if (str_replace(array("\r", "\n"), array('', ''),
247 
            var_export($control, true)) != str_replace(array("\r", "\n"), array('', ''),
248 
            var_export($test, true))) {
249 
            $this->_failTest(debug_backtrace(), $message);
250 
            if (class_exists('Text_Diff')) {
251 
                echo "Diff of expecting/received:\n";
252 
                $diff = &new Text_Diff(
253 
                    explode("\n", var_export($control, true)),
254 
                    explode("\n", var_export($test, true)));
255 
 
256 
                // Output the diff in unified format.
257 
                $renderer = &new Text_Diff_Renderer_unified();
258 
                echo $renderer->render($diff);
259 
                if ($this->_diffonly) {
260 
                    return false;
261 
                }
262 
            }
263 
            echo "Expecting:\n";
264 
            var_export($control);
265 
            echo "\nReceived:\n";
266 
            var_export($test);
267 
            return false;
268 
        }
269 
        return true;
270 
    }
271 
 
272 
    function assertFileExists($fname, $message)
273 
    {
274 
        $this->assertNoErrors($message, debug_backtrace());
275 
        if (!@file_exists($fname)) {
276 
            $this->_failTest(debug_backtrace(), $message);
277 
            echo "File '$fname' does not exist, and should\n";
278 
            return false;
279 
        }
280 
        return true;
281 
    }
282 
 
283 
    function assertFileNotExists($fname, $message)
284 
    {
285 
        $this->assertNoErrors($message, debug_backtrace());
286 
        if (@file_exists($fname)) {
287 
            $this->_failTest(debug_backtrace(), $message);
288 
            echo "File '$fname' exists, and should not\n";
289 
            return false;
290 
        }
291 
        return true;
292 
    }
293 
 
294 
    function assertRegEquals($dump, &$reg, $message)
295 
    {
296 
        $actualdump = var_export(trim($this->dumpReg($reg)), true);
297 
        $testdump = var_export(trim($dump), true);
298 
        return $this->assertEquals($testdump, $actualdump, $message);
299 
    }
300 
 
301 
    function assertPackageInfoEquals($control, $test, $message)
302 
    {
303 
        $this->assertNoErrors($message, debug_backtrace());
304 
        if (isset($control[0])) {
305 
            if (!isset($test[0]) || (count($control) != count($test))) {
306 
                echo "Invalid packageInfo\n";
307 
                $ret = $this->assertEquals($control, $test, $message);
308 
            }
309 
            $ret = true;
310 
            foreach ($control as $i => $packageinfo) {
311 
                $ret = $ret &&
312 
                    $this->assertPackageInfoEquals($packageinfo, $test[$i], $message . $i);
313 
            }
314 
            return $ret;
315 
        }
316 
        if (isset($control['_lastmodified'])) {
317 
            if (!isset($test['_lastmodified'])) {
318 
                echo "_lastmodified is not set in packageInfo() output\n";
319 
                $this->_failTest(debug_backtrace(), $message);
320 
                return false;
321 
            }
322 
        }
323 
        $savecontrol = $control;
324 
        $savetest = $test;
325 
        unset($control['_lastmodified']);
326 
        unset($test['_lastmodified']);
327 
        if (var_export($control, true) != var_export($test, true)) {
328 
            $this->_failTest(debug_backtrace(), $message);
329 
            if (class_exists('Text_Diff')) {
330 
                echo "Diff of expecting/received:\n";
331 
                $diff = &new Text_Diff(
332 
                    explode("\n", var_export($control, true)),
333 
                    explode("\n", var_export($test, true)));
334 
 
335 
                // Output the diff in unified format.
336 
                $renderer = &new Text_Diff_Renderer_unified();
337 
                echo $renderer->render($diff);
338 
                if ($this->_diffonly) {
339 
                    return false;
340 
                }
341 
            }
342 
            echo "Expecting:\n";
343 
            var_export($savecontrol);
344 
            echo "\nReceived:\n";
345 
            var_export($savetest);
346 
            return false;
347 
        }
348 
        return true;
349 
    }
350 
 
351 
    function dumpReg(&$reg)
352 
    {
353 
        ob_start();
354 
        print "dumping registry...\n";
355 
        $infos = $reg->packageInfo(null, null, null);
356 
        foreach ($infos as $channel => $info) {
357 
            echo "channel $channel:\n";
358 
            foreach ($info as $pkg) {
359 
                print $pkg["name"] . ":";
360 
                unset($pkg["name"]);
361 
                foreach ($pkg as $k => $v) {
362 
                    if ($k == '_lastmodified') {
363 
                        print " _lastmodified is set";
364 
                        continue;
365 
                    }
366 
                    if (is_array($v) && $k == 'filelist') {
367 
                        print " $k=array(";
368 
                        $i = 0;
369 
                        foreach ($v as $k2 => $v2) {
370 
                            if ($i++ > 0) print ",";
371 
                            print "{$k2}[";
372 
                            $j = 0;
373 
                            foreach ($v2 as $k3 => $v3) {
374 
                                if ($j++ > 0) print ",";
375 
                                print "$k3=$v3";
376 
                            }
377 
                            print "]";
378 
                        }
379 
                        print ")";
380 
                    } else {
381 
                        print " $k=\"$v\"";
382 
                    }
383 
                }
384 
                print "\n";
385 
            }
386 
        }
387 
        print "dump done\n";
388 
        $ret = ob_get_contents();
389 
        ob_end_clean();
390 
        return $ret;
391 
    }
392 
 
393 
    function _failTest($trace, $message)
394 
    {
395 
        echo 'Test Failure: "' . $message  . "\"\n in " . $trace[0]['file'] . ' line ' .
396 
            $trace[0]['line'] . "\n";
397 
    }
398 
 
399 
    function showAll()
400 
    {
401 
        $this->_diffonly = false;
402 
    }
403 
}
404 
?>