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
|
<?php
/**
* Base include file for SimpleTest
* @package SimpleTest
* @subpackage UnitTester
* @version $Id: runner.php 1398 2006-09-08 19:31:03Z xue $
*/
/**#@+
* Includes SimpleTest files and defined the root constant
* for dependent libraries.
*/
require_once(dirname(__FILE__) . '/errors.php');
require_once(dirname(__FILE__) . '/options.php');
require_once(dirname(__FILE__) . '/scorer.php');
require_once(dirname(__FILE__) . '/expectation.php');
require_once(dirname(__FILE__) . '/dumper.php');
if (! defined('SIMPLE_TEST')) {
define('SIMPLE_TEST', dirname(__FILE__) . '/');
}
/**#@-*/
/**
* This is called by the class runner to run a
* single test method. Will also run the setUp()
* and tearDown() methods.
* @package SimpleTest
* @subpackage UnitTester
*/
class SimpleInvoker {
protected $_test_case;
/**
* Stashes the test case for later.
* @param SimpleTestCase $test_case Test case to run.
*/
function SimpleInvoker($test_case) {
$this->_test_case = $test_case;
}
/**
* Accessor for test case being run.
* @return SimpleTestCase Test case.
* @access public
*/
function getTestCase() {
return $this->_test_case;
}
/**
* Invokes a test method and buffered with setUp()
* and tearDown() calls.
* @param string $method Test method to call.
* @access public
*/
function invoke($method) {
$this->_test_case->setUp();
$this->_test_case->$method();
$this->_test_case->tearDown();
}
}
/**
* Do nothing decorator. Just passes the invocation
* straight through.
* @package SimpleTest
* @subpackage UnitTester
*/
class SimpleInvokerDecorator {
protected $_invoker;
/**
* Stores the invoker to wrap.
* @param SimpleInvoker $invoker Test method runner.
*/
function SimpleInvokerDecorator($invoker) {
$this->_invoker = $invoker;
}
/**
* Accessor for test case being run.
* @return SimpleTestCase Test case.
* @access public
*/
function getTestCase() {
return $this->_invoker->getTestCase();
}
/**
* Invokes a test method and buffered with setUp()
* and tearDown() calls.
* @param string $method Test method to call.
* @access public
*/
function invoke($method) {
$this->_invoker->invoke($method);
}
}
/**
* Extension that traps errors into an error queue.
* @package SimpleTest
* @subpackage UnitTester
*/
class SimpleErrorTrappingInvoker extends SimpleInvokerDecorator {
/**
/**
* Stores the invoker to wrap.
* @param SimpleInvoker $invoker Test method runner.
*/
function SimpleErrorTrappingInvoker($invoker) {
$this->SimpleInvokerDecorator($invoker);
}
/**
* Invokes a test method and dispatches any
* untrapped errors. Called back from
* the visiting runner.
* @param string $method Test method to call.
* @access public
*/
function invoke($method) {
set_error_handler('simpleTestErrorHandler');
parent::invoke($method);
$queue = SimpleErrorQueue::instance();
while (list($severity, $message, $file, $line, $globals) = $queue->extract()) {
$test_case = $this->getTestCase();
$test_case->error($severity, $message, $file, $line, $globals);
}
restore_error_handler();
}
}
/**
* The standard runner. Will run every method starting
* with test Basically the
* Mediator pattern.
* @package SimpleTest
* @subpackage UnitTester
*/
class SimpleRunner {
protected $_test_case;
protected $_scorer;
/**
* Takes in the test case and reporter to mediate between.
* @param SimpleTestCase $test_case Test case to run.
* @param SimpleScorer $scorer Reporter to receive events.
*/
function SimpleRunner($test_case, $scorer) {
$this->_test_case = $test_case;
$this->_scorer = $scorer;
}
/**
* Accessor for test case being run.
* @return SimpleTestCase Test case.
* @access public
*/
function getTestCase() {
return $this->_test_case;
}
/**
* Runs the test methods in the test case.
* @param SimpleTest $test_case Test case to run test on.
* @param string $method Name of test method.
* @access public
*/
function run() {
$methods = get_class_methods(get_class($this->_test_case));
$invoker = $this->_test_case->createInvoker();
foreach ($methods as $method) {
if (! $this->_isTest($method)) {
continue;
}
if ($this->_isConstructor($method)) {
continue;
}
$this->_scorer->paintMethodStart($method);
if ($this->_scorer->shouldInvoke($this->_test_case->getLabel(), $method)) {
$invoker->invoke($method);
}
$this->_scorer->paintMethodEnd($method);
}
}
/**
* Tests to see if the method is the constructor and
* so should be ignored.
* @param string $method Method name to try.
* @return boolean True if constructor.
* @access protected
*/
function _isConstructor($method) {
return SimpleTestCompatibility::isA(
$this->_test_case,
strtolower($method));
}
/**
* Tests to see if the method is a test that should
* be run. Currently any method that starts with 'test'
* is a candidate.
* @param string $method Method name to try.
* @return boolean True if test method.
* @access protected
*/
function _isTest($method) {
return strtolower(substr($method, 0, 4)) == 'test';
}
/**
* Paints the start of a test method.
* @param string $test_name Name of test or other label.
* @access public
*/
function paintMethodStart($test_name) {
$this->_scorer->paintMethodStart($test_name);
}
/**
* Paints the end of a test method.
* @param string $test_name Name of test or other label.
* @access public
*/
function paintMethodEnd($test_name) {
$this->_scorer->paintMethodEnd($test_name);
}
/**
* Chains to the wrapped reporter.
* @param string $message Message is ignored.
* @access public
*/
function paintPass($message) {
$this->_scorer->paintPass($message);
}
/**
* Chains to the wrapped reporter.
* @param string $message Message is ignored.
* @access public
*/
function paintFail($message) {
$this->_scorer->paintFail($message);
}
/**
* Chains to the wrapped reporter.
* @param string $message Text of error formatted by
* the test case.
* @access public
*/
function paintError($message) {
$this->_scorer->paintError($message);
}
/**
* Chains to the wrapped reporter.
* @param Exception $exception Object thrown.
* @access public
*/
function paintException($exception) {
$this->_scorer->paintException($exception);
}
/**
* Chains to the wrapped reporter.
* @param string $message Text to display.
* @access public
*/
function paintMessage($message) {
$this->_scorer->paintMessage($message);
}
/**
* Chains to the wrapped reporter.
* @param string $message Text to display.
* @access public
*/
function paintFormattedMessage($message) {
$this->_scorer->paintFormattedMessage($message);
}
/**
* Chains to the wrapped reporter.
* @param string $type Event type as text.
* @param mixed $payload Message or object.
* @return boolean Should return false if this
* type of signal should fail the
* test suite.
* @access public
*/
function paintSignal($type, $payload) {
$this->_scorer->paintSignal($type, $payload);
}
}
?>
|
