Spike PHPCoverage Details: unit_tester.php

Line #FrequencySource Line
1 <?php
2     /**
3      *  base include file for SimpleTest
4      *  @package    SimpleTest
5      *  @subpackage UnitTester
6      *  @version    $Id: unit_tester.php 1698 2008-03-23 04:23:57Z edwardzyang $
7      */
8 
9     /**#@+
10      *  include other SimpleTest class files
11      */
12     require_once(dirname(__FILE__) . '/test_case.php');
13     require_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      */
23     class 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) {
331            if (! $label) {
341                $label = get_class($this);
35             }
361            $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) {
491            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') {
631            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 ?