Subversion-Projekte lars-tiefland.prado

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
1 lars 1 
<?php
2 
    /**
3 
     *	Global state for SimpleTest and kicker script in future versions.
4 
     *	@package	SimpleTest
5 
     *	@subpackage	UnitTester
6 
     *	@version	$Id: simpletest.php 1532 2006-12-01 12:28:55Z xue $
7 
     */
8 
 
9 
    /**#@+
10 
     * include SimpleTest files
11 
     */
12 
    if (version_compare(phpversion(), '5') >= 0) {
13 
        require_once(dirname(__FILE__) . '/reflection_php5.php');
14 
    } else {
15 
        require_once(dirname(__FILE__) . '/reflection_php4.php');
16 
    }
17 
    /**#@-*/
18 
 
19 
    /**
20 
     *    Static global directives and options. I hate this
21 
     *    class. It's a mixture of reference hacks, configuration
22 
     *    and previous design screw-ups that I have to maintain
23 
     *    to keep backward compatibility.
24 
     *	  @package	SimpleTest
25 
     */
26 
    class SimpleTest {
27 
 
28 
        /**
29 
         *    Reads the SimpleTest version from the release file.
30 
         *    @return string        Version string.
31 
         *    @static
32 
         *    @access public
33 
         */
34 
        static function getVersion() {
35 
            $content = file(dirname(__FILE__) . '/VERSION');
36 
            return trim($content[0]);
37 
        }
38 
 
39 
        /**
40 
         *    Sets the name of a test case to ignore, usually
41 
         *    because the class is an abstract case that should
42 
         *    not be run. Once PHP4 is dropped this will disappear
43 
         *    as a public method and "abstract" will rule.
44 
         *    @param string $class        Add a class to ignore.
45 
         *    @static
46 
         *    @access public
47 
         */
48 
        static function ignore($class) {
49 
            $registry = &SimpleTest::_getRegistry();
50 
            $registry['IgnoreList'][strtolower($class)] = true;
51 
        }
52 
 
53 
        /**
54 
         *    Scans the now complete ignore list, and adds
55 
         *    all parent classes to the list. If a class
56 
         *    is not a runnable test case, then it's parents
57 
         *    wouldn't be either. This is syntactic sugar
58 
         *    to cut down on ommissions of ignore()'s or
59 
         *    missing abstract declarations. This cannot
60 
         *    be done whilst loading classes wiithout forcing
61 
         *    a particular order on the class declarations and
62 
         *    the ignore() calls. It's nice to havethe ignore()
63 
         *    calls at the top of teh file.
64 
         *    @param array $classes     Class names of interest.
65 
         *    @static
66 
         *    @access public
67 
         */
68 
        static function ignoreParentsIfIgnored($classes) {
69 
            $registry = &SimpleTest::_getRegistry();
70 
            foreach ($classes as $class) {
71 
                if (SimpleTest::isIgnored($class)) {
72 
                    $reflection = new SimpleReflection($class);
73 
                    if ($parent = $reflection->getParent()) {
74 
                        SimpleTest::ignore($parent);
75 
                    }
76 
                }
77 
            }
78 
        }
79 
 
80 
        /**
81 
         *    Test to see if a test case is in the ignore
82 
         *    list. Quite obviously the ignore list should
83 
         *    be a separate object and will be one day.
84 
         *    This method is internal to SimpleTest. Don't
85 
         *    use it.
86 
         *    @param string $class        Class name to test.
87 
         *    @return boolean             True if should not be run.
88 
         *    @access public
89 
         *    @static
90 
         */
91 
        static function isIgnored($class) {
92 
            $registry = &SimpleTest::_getRegistry();
93 
            return isset($registry['IgnoreList'][strtolower($class)]);
94 
        }
95 
 
96 
        /**
97 
         *    @deprecated
98 
         */
99 
        function setMockBaseClass($mock_base) {
100 
            $registry = &SimpleTest::_getRegistry();
101 
            $registry['MockBaseClass'] = $mock_base;
102 
        }
103 
 
104 
        /**
105 
         *    @deprecated
106 
         */
107 
        function getMockBaseClass() {
108 
            $registry = &SimpleTest::_getRegistry();
109 
            return $registry['MockBaseClass'];
110 
        }
111 
 
112 
        /**
113 
         *    Sets proxy to use on all requests for when
114 
         *    testing from behind a firewall. Set host
115 
         *    to false to disable. This will take effect
116 
         *    if there are no other proxy settings.
117 
         *    @param string $proxy     Proxy host as URL.
118 
         *    @param string $username  Proxy username for authentication.
119 
         *    @param string $password  Proxy password for authentication.
120 
         *    @access public
121 
         */
122 
        function useProxy($proxy, $username = false, $password = false) {
123 
            $registry = &SimpleTest::_getRegistry();
124 
            $registry['DefaultProxy'] = $proxy;
125 
            $registry['DefaultProxyUsername'] = $username;
126 
            $registry['DefaultProxyPassword'] = $password;
127 
        }
128 
 
129 
        /**
130 
         *    Accessor for default proxy host.
131 
         *    @return string       Proxy URL.
132 
         *    @access public
133 
         */
134 
        function getDefaultProxy() {
135 
            $registry = &SimpleTest::_getRegistry();
136 
            return $registry['DefaultProxy'];
137 
        }
138 
 
139 
        /**
140 
         *    Accessor for default proxy username.
141 
         *    @return string    Proxy username for authentication.
142 
         *    @access public
143 
         */
144 
        function getDefaultProxyUsername() {
145 
            $registry = &SimpleTest::_getRegistry();
146 
            return $registry['DefaultProxyUsername'];
147 
        }
148 
 
149 
        /**
150 
         *    Accessor for default proxy password.
151 
         *    @return string    Proxy password for authentication.
152 
         *    @access public
153 
         */
154 
        function getDefaultProxyPassword() {
155 
            $registry = &SimpleTest::_getRegistry();
156 
            return $registry['DefaultProxyPassword'];
157 
        }
158 
 
159 
        /**
160 
         *    Sets the current test case instance. This
161 
         *    global instance can be used by the mock objects
162 
         *    to send message to the test cases.
163 
         *    @param SimpleTestCase $test        Test case to register.
164 
         *    @access public
165 
         *    @static
166 
         */
167 
        static function setCurrent($test) {
168 
            $registry = &SimpleTest::_getRegistry();
169 
            $registry['CurrentTestCase'] = $test;
170 
        }
171 
 
172 
        /**
173 
         *    Accessor for current test instance.
174 
         *    @return SimpleTEstCase        Currently running test.
175 
         *    @access public
176 
         *    @static
177 
         */
178 
        static function &getCurrent() {
179 
            $registry = &SimpleTest::_getRegistry();
180 
            return $registry['CurrentTestCase'];
181 
        }
182 
 
183 
        /**
184 
         *    Accessor for global registry of options.
185 
         *    @return hash           All stored values.
186 
         *    @access private
187 
         *    @static
188 
         */
189 
        static function &_getRegistry() {
190 
            static $registry = false;
191 
            if (! $registry) {
192 
                $registry = SimpleTest::_getDefaults();
193 
            }
194 
            return $registry;
195 
        }
196 
 
197 
        /**
198 
         *    Constant default values.
199 
         *    @return hash       All registry defaults.
200 
         *    @access private
201 
         *    @static
202 
         */
203 
        static function _getDefaults() {
204 
            return array(
205 
                    'StubBaseClass' => 'SimpleStub',
206 
                    'MockBaseClass' => 'SimpleMock',
207 
                    'IgnoreList' => array(),
208 
                    'DefaultProxy' => false,
209 
                    'DefaultProxyUsername' => false,
210 
                    'DefaultProxyPassword' => false);
211 
        }
212 
    }
213 
 
214 
    /**
215 
     *    @deprecated
216 
     */
217 
    class SimpleTestOptions extends SimpleTest {
218 
 
219 
        /**
220 
         *    @deprecated
221 
         */
222 
        static function getVersion() {
223 
            return Simpletest::getVersion();
224 
        }
225 
 
226 
        /**
227 
         *    @deprecated
228 
         */
229 
        static function ignore($class) {
230 
            return Simpletest::ignore($class);
231 
        }
232 
 
233 
        /**
234 
         *    @deprecated
235 
         */
236 
        static function isIgnored($class) {
237 
            return Simpletest::isIgnored($class);
238 
        }
239 
 
240 
        /**
241 
         *    @deprecated
242 
         */
243 
        function setMockBaseClass($mock_base) {
244 
            return Simpletest::setMockBaseClass($mock_base);
245 
        }
246 
 
247 
        /**
248 
         *    @deprecated
249 
         */
250 
        function getMockBaseClass() {
251 
            return Simpletest::getMockBaseClass();
252 
        }
253 
 
254 
        /**
255 
         *    @deprecated
256 
         */
257 
        function useProxy($proxy, $username = false, $password = false) {
258 
            return Simpletest::useProxy($proxy, $username, $password);
259 
        }
260 
 
261 
        /**
262 
         *    @deprecated
263 
         */
264 
        function getDefaultProxy() {
265 
            return Simpletest::getDefaultProxy();
266 
        }
267 
 
268 
        /**
269 
         *    @deprecated
270 
         */
271 
        function getDefaultProxyUsername() {
272 
            return Simpletest::getDefaultProxyUsername();
273 
        }
274 
 
275 
        /**
276 
         *    @deprecated
277 
         */
278 
        function getDefaultProxyPassword() {
279 
            return Simpletest::getDefaultProxyPassword();
280 
        }
281 
    }
282 
?>