source: trunk/server/www/vendors/simpletest/unit_tester.php @ 6

Last change on this file since 6 was 6, checked in by sander, 11 years ago

Added SimpleTest? test framework

File size: 14.6 KB
Line 
1<?php
2/**
3 *  base include file for SimpleTest
4 *  @package    SimpleTest
5 *  @subpackage UnitTester
6 *  @version    $Id: unit_tester.php 1723 2008-04-08 00:34:10Z lastcraft $
7 */
8
9/**#@+
10 *  include other SimpleTest class files
11 */
12require_once(dirname(__FILE__) . '/test_case.php');
13require_once(dirname(__FILE__) . '/dumper.php');
14/**#@-*/
15
16/**
17 *    Standard unit test class for day to day testing
18 *    of PHP code XP style. Adds some useful standard
19 *    assertions.
20 *    @package  SimpleTest
21 *    @subpackage   UnitTester
22 */
23class UnitTestCase extends SimpleTestCase {
24
25    /**
26     *    Creates an empty test case. Should be subclassed
27     *    with test methods for a functional test case.
28     *    @param string $label     Name of test case. Will use
29     *                             the class name if none specified.
30     *    @access public
31     */
32    function UnitTestCase($label = false) {
33        if (! $label) {
34            $label = get_class($this);
35        }
36        $this->SimpleTestCase($label);
37    }
38
39    /**
40     *    Called from within the test methods to register
41     *    passes and failures.
42     *    @param boolean $result    Pass on true.
43     *    @param string $message    Message to display describing
44     *                              the test state.
45     *    @return boolean           True on pass
46     *    @access public
47     */
48    function assertTrue($result, $message = false) {
49        return $this->assert(new TrueExpectation(), $result, $message);
50    }
51
52    /**
53     *    Will be true on false and vice versa. False
54     *    is the PHP definition of false, so that null,
55     *    empty strings, zero and an empty array all count
56     *    as false.
57     *    @param boolean $result    Pass on false.
58     *    @param string $message    Message to display.
59     *    @return boolean           True on pass
60     *    @access public
61     */
62    function assertFalse($result, $message = '%s') {
63        return $this->assert(new FalseExpectation(), $result, $message);
64    }
65
66    /**
67     *    Will be true if the value is null.
68     *    @param null $value       Supposedly null value.
69     *    @param string $message   Message to display.
70     *    @return boolean                        True on pass
71     *    @access public
72     */
73    function assertNull($value, $message = '%s') {
74        $dumper = &new SimpleDumper();
75        $message = sprintf(
76                $message,
77                '[' . $dumper->describeValue($value) . '] should be null');
78        return $this->assertTrue(! isset($value), $message);
79    }
80
81    /**
82     *    Will be true if the value is set.
83     *    @param mixed $value           Supposedly set value.
84     *    @param string $message        Message to display.
85     *    @return boolean               True on pass.
86     *    @access public
87     */
88    function assertNotNull($value, $message = '%s') {
89        $dumper = &new SimpleDumper();
90        $message = sprintf(
91                $message,
92                '[' . $dumper->describeValue($value) . '] should not be null');
93        return $this->assertTrue(isset($value), $message);
94    }
95
96    /**
97     *    Type and class test. Will pass if class
98     *    matches the type name or is a subclass or
99     *    if not an object, but the type is correct.
100     *    @param mixed $object         Object to test.
101     *    @param string $type          Type name as string.
102     *    @param string $message       Message to display.
103     *    @return boolean              True on pass.
104     *    @access public
105     */
106    function assertIsA($object, $type, $message = '%s') {
107        return $this->assert(
108                new IsAExpectation($type),
109                $object,
110                $message);
111    }
112
113    /**
114     *    Type and class mismatch test. Will pass if class
115     *    name or underling type does not match the one
116     *    specified.
117     *    @param mixed $object         Object to test.
118     *    @param string $type          Type name as string.
119     *    @param string $message       Message to display.
120     *    @return boolean              True on pass.
121     *    @access public
122     */
123    function assertNotA($object, $type, $message = '%s') {
124        return $this->assert(
125                new NotAExpectation($type),
126                $object,
127                $message);
128    }
129
130    /**
131     *    Will trigger a pass if the two parameters have
132     *    the same value only. Otherwise a fail.
133     *    @param mixed $first          Value to compare.
134     *    @param mixed $second         Value to compare.
135     *    @param string $message       Message to display.
136     *    @return boolean              True on pass
137     *    @access public
138     */
139    function assertEqual($first, $second, $message = '%s') {
140        return $this->assert(
141                new EqualExpectation($first),
142                $second,
143                $message);
144    }
145
146    /**
147     *    Will trigger a pass if the two parameters have
148     *    a different value. Otherwise a fail.
149     *    @param mixed $first           Value to compare.
150     *    @param mixed $second          Value to compare.
151     *    @param string $message        Message to display.
152     *    @return boolean               True on pass
153     *    @access public
154     */
155    function assertNotEqual($first, $second, $message = '%s') {
156        return $this->assert(
157                new NotEqualExpectation($first),
158                $second,
159                $message);
160    }
161
162    /**
163     *    Will trigger a pass if the if the first parameter
164     *    is near enough to the second by the margin.
165     *    @param mixed $first          Value to compare.
166     *    @param mixed $second         Value to compare.
167     *    @param mixed $margin         Fuzziness of match.
168     *    @param string $message       Message to display.
169     *    @return boolean              True on pass
170     *    @access public
171     */
172    function assertWithinMargin($first, $second, $margin, $message = '%s') {
173        return $this->assert(
174                new WithinMarginExpectation($first, $margin),
175                $second,
176                $message);
177    }
178
179    /**
180     *    Will trigger a pass if the two parameters differ
181     *    by more than the margin.
182     *    @param mixed $first          Value to compare.
183     *    @param mixed $second         Value to compare.
184     *    @param mixed $margin         Fuzziness of match.
185     *    @param string $message       Message to display.
186     *    @return boolean              True on pass
187     *    @access public
188     */
189    function assertOutsideMargin($first, $second, $margin, $message = '%s') {
190        return $this->assert(
191                new OutsideMarginExpectation($first, $margin),
192                $second,
193                $message);
194    }
195
196    /**
197     *    Will trigger a pass if the two parameters have
198     *    the same value and same type. Otherwise a fail.
199     *    @param mixed $first           Value to compare.
200     *    @param mixed $second          Value to compare.
201     *    @param string $message        Message to display.
202     *    @return boolean               True on pass
203     *    @access public
204     */
205    function assertIdentical($first, $second, $message = '%s') {
206        return $this->assert(
207                new IdenticalExpectation($first),
208                $second,
209                $message);
210    }
211
212    /**
213     *    Will trigger a pass if the two parameters have
214     *    the different value or different type.
215     *    @param mixed $first           Value to compare.
216     *    @param mixed $second          Value to compare.
217     *    @param string $message        Message to display.
218     *    @return boolean               True on pass
219     *    @access public
220     */
221    function assertNotIdentical($first, $second, $message = '%s') {
222        return $this->assert(
223                new NotIdenticalExpectation($first),
224                $second,
225                $message);
226    }
227
228    /**
229     *    Will trigger a pass if both parameters refer
230     *    to the same object. Fail otherwise.
231     *    @param mixed $first           Object reference to check.
232     *    @param mixed $second          Hopefully the same object.
233     *    @param string $message        Message to display.
234     *    @return boolean               True on pass
235     *    @access public
236     */
237    function assertReference(&$first, &$second, $message = '%s') {
238        $dumper = &new SimpleDumper();
239        $message = sprintf(
240                $message,
241                '[' . $dumper->describeValue($first) .
242                        '] and [' . $dumper->describeValue($second) .
243                        '] should reference the same object');
244        return $this->assertTrue(
245                SimpleTestCompatibility::isReference($first, $second),
246                $message);
247    }
248
249    /**
250     *    Will trigger a pass if both parameters refer
251     *    to different objects. Fail otherwise. The objects
252     *    have to be identical though.
253     *    @param mixed $first           Object reference to check.
254     *    @param mixed $second          Hopefully not the same object.
255     *    @param string $message        Message to display.
256     *    @return boolean               True on pass
257     *    @access public
258     */
259    function assertClone(&$first, &$second, $message = '%s') {
260        $dumper = &new SimpleDumper();
261        $message = sprintf(
262                $message,
263                '[' . $dumper->describeValue($first) .
264                        '] and [' . $dumper->describeValue($second) .
265                        '] should not be the same object');
266        $identical = &new IdenticalExpectation($first);
267        return $this->assertTrue(
268                $identical->test($second) &&
269                        ! SimpleTestCompatibility::isReference($first, $second),
270                $message);
271    }
272
273    /**
274     *    @deprecated
275     */
276    function assertCopy(&$first, &$second, $message = "%s") {
277        $dumper = &new SimpleDumper();
278        $message = sprintf(
279                $message,
280                "[" . $dumper->describeValue($first) .
281                        "] and [" . $dumper->describeValue($second) .
282                        "] should not be the same object");
283        return $this->assertFalse(
284                SimpleTestCompatibility::isReference($first, $second),
285                $message);
286    }
287
288    /**
289     *    Will trigger a pass if the Perl regex pattern
290     *    is found in the subject. Fail otherwise.
291     *    @param string $pattern    Perl regex to look for including
292     *                              the regex delimiters.
293     *    @param string $subject    String to search in.
294     *    @param string $message    Message to display.
295     *    @return boolean           True on pass
296     *    @access public
297     */
298    function assertPattern($pattern, $subject, $message = '%s') {
299        return $this->assert(
300                new PatternExpectation($pattern),
301                $subject,
302                $message);
303    }
304
305    /**
306     *    @deprecated
307     */
308    function assertWantedPattern($pattern, $subject, $message = '%s') {
309        return $this->assertPattern($pattern, $subject, $message);
310    }
311
312    /**
313     *    Will trigger a pass if the perl regex pattern
314     *    is not present in subject. Fail if found.
315     *    @param string $pattern    Perl regex to look for including
316     *                              the regex delimiters.
317     *    @param string $subject    String to search in.
318     *    @param string $message    Message to display.
319     *    @return boolean           True on pass
320     *    @access public
321     */
322    function assertNoPattern($pattern, $subject, $message = '%s') {
323        return $this->assert(
324                new NoPatternExpectation($pattern),
325                $subject,
326                $message);
327    }
328
329    /**
330     *    @deprecated
331     */
332    function assertNoUnwantedPattern($pattern, $subject, $message = '%s') {
333        return $this->assertNoPattern($pattern, $subject, $message);
334    }
335
336    /**
337     *    @deprecated
338     */
339    function swallowErrors() {
340        $context = &SimpleTest::getContext();
341        $queue = &$context->get('SimpleErrorQueue');
342        $queue->clear();
343    }
344
345    /**
346     *    @deprecated
347     */
348    function assertNoErrors($message = '%s') {
349        $context = &SimpleTest::getContext();
350        $queue = &$context->get('SimpleErrorQueue');
351        return $queue->assertNoErrors($message);
352    }
353
354    /**
355     *    @deprecated
356     */
357    function assertError($expected = false, $message = '%s') {
358        $context = &SimpleTest::getContext();
359        $queue = &$context->get('SimpleErrorQueue');
360        return $queue->assertError($this->_coerceExpectation($expected), $message);
361    }
362
363    /**
364     *    Prepares for an error. If the error mismatches it
365     *    passes through, otherwise it is swallowed. Any
366     *    left over errors trigger failures.
367     *    @param SimpleExpectation/string $expected   The error to match.
368     *    @param string $message                      Message on failure.
369     *    @access public
370     */
371    function expectError($expected = false, $message = '%s') {
372        $context = &SimpleTest::getContext();
373        $queue = &$context->get('SimpleErrorQueue');
374        $queue->expectError($this->_coerceExpectation($expected), $message);
375    }
376
377    /**
378     *    Prepares for an exception. If the error mismatches it
379     *    passes through, otherwise it is swallowed. Any
380     *    left over errors trigger failures.
381     *    @param SimpleExpectation/Exception $expected  The error to match.
382     *    @param string $message                        Message on failure.
383     *    @access public
384     */
385    function expectException($expected = false, $message = '%s') {
386        $context = &SimpleTest::getContext();
387        $queue = &$context->get('SimpleExceptionTrap');
388        // :HACK: Directly substituting in seems to cause a segfault with
389        // Zend Optimizer on some systems
390        $line = $this->getAssertionLine();
391        $queue->expectException($expected, $message . $line);
392    }
393
394    /**
395     *    Creates an equality expectation if the
396     *    object/value is not already some type
397     *    of expectation.
398     *    @param mixed $expected      Expected value.
399     *    @return SimpleExpectation   Expectation object.
400     *    @access private
401     */
402    function _coerceExpectation($expected) {
403        if ($expected == false) {
404            return new TrueExpectation();
405        }
406        if (SimpleTestCompatibility::isA($expected, 'SimpleExpectation')) {
407            return $expected;
408        }
409        return new EqualExpectation(
410                is_string($expected) ? str_replace('%', '%%', $expected) : $expected);
411    }
412
413    /**
414     *    @deprecated
415     */
416    function assertErrorPattern($pattern, $message = '%s') {
417        return $this->assertError(new PatternExpectation($pattern), $message);
418    }
419}
420?>
Note: See TracBrowser for help on using the repository browser.