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

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

Added SimpleTest? test framework

File size: 9.0 KB
Line 
1<?php
2require_once(dirname(__FILE__) . '/../autorun.php');
3require_once(dirname(__FILE__) . '/../errors.php');
4require_once(dirname(__FILE__) . '/../expectation.php');
5require_once(dirname(__FILE__) . '/../test_case.php');
6Mock::generate('SimpleTestCase');
7Mock::generate('SimpleExpectation');
8SimpleTest::ignore('MockSimpleTestCase');
9
10class TestOfErrorQueue extends UnitTestCase {
11
12    function setUp() {
13        $context = &SimpleTest::getContext();
14        $queue = &$context->get('SimpleErrorQueue');
15        $queue->clear();
16    }
17
18    function tearDown() {
19        $context = &SimpleTest::getContext();
20        $queue = &$context->get('SimpleErrorQueue');
21        $queue->clear();
22    }
23
24    function testOrder() {
25        $context = &SimpleTest::getContext();
26        $queue = &$context->get('SimpleErrorQueue');
27        $queue->add(1024, 'Ouch', 'here.php', 100);
28        $queue->add(512, 'Yuk', 'there.php', 101);
29        $this->assertEqual(
30                $queue->extract(),
31                array(1024, 'Ouch', 'here.php', 100));
32        $this->assertEqual(
33                $queue->extract(),
34                array(512, 'Yuk', 'there.php', 101));
35        $this->assertFalse($queue->extract());
36    }
37
38    function testAssertNoErrorsGivesTrueWhenNoErrors() {
39        $test = &new MockSimpleTestCase();
40        $test->expectOnce('assert', array(
41                new IdenticalExpectation(new TrueExpectation()),
42                true,
43                'Should be no errors'));
44        $test->setReturnValue('assert', true);
45        $queue = &new SimpleErrorQueue();
46        $queue->setTestCase($test);
47        $this->assertTrue($queue->assertNoErrors('%s'));
48    }
49
50    function testAssertNoErrorsIssuesFailWhenErrors() {
51        $test = &new MockSimpleTestCase();
52        $test->expectOnce('assert', array(
53                new IdenticalExpectation(new TrueExpectation()),
54                false,
55                'Should be no errors'));
56        $test->setReturnValue('assert', false);
57        $queue = &new SimpleErrorQueue();
58        $queue->setTestCase($test);
59        $queue->add(1024, 'Ouch', 'here.php', 100);
60        $this->assertFalse($queue->assertNoErrors('%s'));
61    }
62
63    function testAssertErrorFailsWhenNoError() {
64        $test = &new MockSimpleTestCase();
65        $test->expectOnce('fail', array('Expected error not found'));
66        $test->setReturnValue('assert', false);
67        $queue = &new SimpleErrorQueue();
68        $queue->setTestCase($test);
69        $this->assertFalse($queue->assertError(false, '%s'));
70    }
71
72    function testAssertErrorFailsWhenErrorDoesntMatchTheExpectation() {
73        $test = &new MockSimpleTestCase();
74        $test->expectOnce('assert', array(
75                new IdenticalExpectation(new FailedExpectation()),
76                'B',
77                'Expected PHP error [B] severity [E_USER_NOTICE] in [b.php] line [100]'));
78        $test->setReturnValue('assert', false);
79        $queue = &new SimpleErrorQueue();
80        $queue->setTestCase($test);
81        $queue->add(1024, 'B', 'b.php', 100);
82        $this->assertFalse($queue->assertError(new FailedExpectation(), '%s'));
83    }
84
85    function testExpectationMatchCancelsIncomingError() {
86        $test = &new MockSimpleTestCase();
87        $test->expectOnce('assert', array(
88                new IdenticalExpectation(new AnythingExpectation()),
89                'B',
90                'a message'));
91        $test->setReturnValue('assert', true);
92        $test->expectNever('error');
93        $queue = &new SimpleErrorQueue();
94        $queue->setTestCase($test);
95        $queue->expectError(new AnythingExpectation(), 'a message');
96        $queue->add(1024, 'B', 'b.php', 100);
97    }
98}
99
100class TestOfErrorTrap extends UnitTestCase {
101    var $_old;
102
103    function setUp() {
104        $this->_old = error_reporting(E_ALL);
105        set_error_handler('SimpleTestErrorHandler');
106    }
107
108    function tearDown() {
109        restore_error_handler();
110        error_reporting($this->_old);
111    }
112
113    function testQueueStartsEmpty() {
114        $context = &SimpleTest::getContext();
115        $queue = &$context->get('SimpleErrorQueue');
116        $this->assertFalse($queue->extract());
117    }
118
119    function testTrappedErrorPlacedInQueue() {
120        trigger_error('Ouch!');
121        $context = &SimpleTest::getContext();
122        $queue = &$context->get('SimpleErrorQueue');
123        list($severity, $message, $file, $line) = $queue->extract();
124        $this->assertEqual($message, 'Ouch!');
125        $this->assertEqual($file, __FILE__);
126        $this->assertFalse($queue->extract());
127    }
128
129    function testErrorsAreSwallowedByMatchingExpectation() {
130        $this->expectError('Ouch!');
131        trigger_error('Ouch!');
132    }
133
134    function testErrorsAreSwallowedInOrder() {
135        $this->expectError('a');
136        $this->expectError('b');
137        trigger_error('a');
138        trigger_error('b');
139    }
140
141    function testAnyErrorCanBeSwallowed() {
142        $this->expectError();
143        trigger_error('Ouch!');
144    }
145
146    function testErrorCanBeSwallowedByPatternMatching() {
147        $this->expectError(new PatternExpectation('/ouch/i'));
148        trigger_error('Ouch!');
149    }
150
151    function testErrorWithPercentsPassesWithNoSprintfError() {
152        $this->expectError("%");
153        trigger_error('%');
154    }
155}
156
157class TestOfErrors extends UnitTestCase {
158    var $_old;
159
160    function setUp() {
161        $this->_old = error_reporting(E_ALL);
162    }
163
164    function tearDown() {
165        error_reporting($this->_old);
166    }
167
168    function testDefaultWhenAllReported() {
169        error_reporting(E_ALL);
170        trigger_error('Ouch!');
171        $this->assertError('Ouch!');
172    }
173
174    function testNoticeWhenReported() {
175        error_reporting(E_ALL);
176        trigger_error('Ouch!', E_USER_NOTICE);
177        $this->assertError('Ouch!');
178    }
179
180    function testWarningWhenReported() {
181        error_reporting(E_ALL);
182        trigger_error('Ouch!', E_USER_WARNING);
183        $this->assertError('Ouch!');
184    }
185
186    function testErrorWhenReported() {
187        error_reporting(E_ALL);
188        trigger_error('Ouch!', E_USER_ERROR);
189        $this->assertError('Ouch!');
190    }
191
192    function testNoNoticeWhenNotReported() {
193        error_reporting(0);
194        trigger_error('Ouch!', E_USER_NOTICE);
195    }
196
197    function testNoWarningWhenNotReported() {
198        error_reporting(0);
199        trigger_error('Ouch!', E_USER_WARNING);
200    }
201
202    function testNoticeSuppressedWhenReported() {
203        error_reporting(E_ALL);
204        @trigger_error('Ouch!', E_USER_NOTICE);
205    }
206
207    function testWarningSuppressedWhenReported() {
208        error_reporting(E_ALL);
209        @trigger_error('Ouch!', E_USER_WARNING);
210    }
211
212    function testErrorWithPercentsReportedWithNoSprintfError() {
213        trigger_error('%');
214        $this->assertError('%');
215    }
216}
217
218class TestOfPHP52RecoverableErrors extends UnitTestCase {
219    function skip() {
220        $this->skipIf(
221                version_compare(phpversion(), '5.2', '<'),
222                'E_RECOVERABLE_ERROR not tested for PHP below 5.2');
223    }
224
225    function testError() {
226        eval('
227            class RecoverableErrorTestingStub {
228                function ouch(RecoverableErrorTestingStub $obj) {
229                }
230            }
231        ');
232
233        $stub = new RecoverableErrorTestingStub();
234        $this->expectError(new PatternExpectation('/must be an instance of RecoverableErrorTestingStub/i'));
235        $stub->ouch(new stdClass());
236    }
237}
238
239class TestOfErrorsExcludingPHP52AndAbove extends UnitTestCase {
240    function skip() {
241        $this->skipIf(
242                version_compare(phpversion(), '5.2', '>='),
243                'E_USER_ERROR not tested for PHP 5.2 and above');
244    }
245
246    function testNoErrorWhenNotReported() {
247        error_reporting(0);
248        trigger_error('Ouch!', E_USER_ERROR);
249    }
250
251    function testErrorSuppressedWhenReported() {
252        error_reporting(E_ALL);
253        @trigger_error('Ouch!', E_USER_ERROR);
254    }
255}
256
257SimpleTest::ignore('TestOfNotEnoughErrors');
258/**
259 * This test is ignored as it is used by {@link TestRunnerForLeftOverAndNotEnoughErrors}
260 * to verify that it fails as expected.
261 *
262 * @ignore
263 */
264class TestOfNotEnoughErrors extends UnitTestCase {
265    function testExpectTwoErrorsThrowOne() {
266        $this->expectError('Error 1');
267        trigger_error('Error 1');
268        $this->expectError('Error 2');
269    }
270}
271
272SimpleTest::ignore('TestOfLeftOverErrors');
273/**
274 * This test is ignored as it is used by {@link TestRunnerForLeftOverAndNotEnoughErrors}
275 * to verify that it fails as expected.
276 *
277 * @ignore
278 */
279class TestOfLeftOverErrors extends UnitTestCase {
280    function testExpectOneErrorGetTwo() {
281        $this->expectError('Error 1');
282        trigger_error('Error 1');
283        trigger_error('Error 2');
284    }
285}
286
287class TestRunnerForLeftOverAndNotEnoughErrors extends UnitTestCase {
288    function testRunLeftOverErrorsTestCase() {
289        $test = new TestOfLeftOverErrors();
290        $this->assertFalse($test->run(new SimpleReporter()));
291    }
292
293    function testRunNotEnoughErrors() {
294        $test = new TestOfNotEnoughErrors();
295        $this->assertFalse($test->run(new SimpleReporter()));
296    }
297}
298
299// TODO: Add stacked error handler test
300?>
Note: See TracBrowser for help on using the repository browser.