source: trunk/server/www/vendors/simpletest/test/reflection_php5_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: 8.9 KB
Line 
1<?php
2// $Id: reflection_php5_test.php 1541 2007-06-10 02:27:59Z tswicegood $
3require_once(dirname(__FILE__) . '/../autorun.php');
4require_once(dirname(__FILE__) . '/../reflection_php5.php');
5
6class AnyOldLeafClass {
7        function aMethod() { }
8}
9
10abstract class AnyOldClass {
11        function aMethod() { }
12}
13
14class AnyOldLeafClassWithAFinal {
15        final function aMethod() { }
16}
17
18interface AnyOldInterface {
19        function aMethod();
20}
21
22interface AnyOldArgumentInterface {
23        function aMethod(AnyOldInterface $argument);
24}
25
26interface AnyDescendentInterface extends AnyOldInterface {
27}
28
29class AnyOldImplementation implements AnyOldInterface {
30        function aMethod() { }
31        function extraMethod() { }
32}
33
34abstract class AnyAbstractImplementation implements AnyOldInterface {
35}
36
37abstract class AnotherOldAbstractClass {
38    protected abstract function aMethod(AnyOldInterface $argument);
39}
40
41class AnyOldSubclass extends AnyOldImplementation { }
42
43class AnyOldArgumentClass {
44        function aMethod($argument) { }
45}
46
47class AnyOldArgumentImplementation implements AnyOldArgumentInterface {
48        function aMethod(AnyOldInterface $argument) { }
49}
50
51class AnyOldTypeHintedClass implements AnyOldArgumentInterface {
52        function aMethod(AnyOldInterface $argument) { }
53}
54
55class AnyDescendentImplementation implements AnyDescendentInterface {
56        function aMethod() { }
57}
58
59class AnyOldOverloadedClass {
60        function __isset($key) { }
61        function __unset($key) { }
62}
63
64class AnyOldClassWithStaticMethods {
65        static function aStatic() { }
66        static function aStaticWithParameters($arg1, $arg2) { }
67}
68
69abstract class AnyOldAbstractClassWithAbstractMethods {
70    abstract function anAbstract();
71    abstract function anAbstractWithParameter($foo);
72    abstract function anAbstractWithMultipleParameters($foo, $bar);
73}
74
75class TestOfReflection extends UnitTestCase {
76
77        function testClassExistence() {
78                $reflection = new SimpleReflection('AnyOldLeafClass');
79                $this->assertTrue($reflection->classOrInterfaceExists());
80                $this->assertTrue($reflection->classOrInterfaceExistsSansAutoload());
81                $this->assertFalse($reflection->isAbstract());
82                $this->assertFalse($reflection->isInterface());
83        }
84
85        function testClassNonExistence() {
86                $reflection = new SimpleReflection('UnknownThing');
87                $this->assertFalse($reflection->classOrInterfaceExists());
88                $this->assertFalse($reflection->classOrInterfaceExistsSansAutoload());
89        }
90
91        function testDetectionOfAbstractClass() {
92                $reflection = new SimpleReflection('AnyOldClass');
93                $this->assertTrue($reflection->isAbstract());
94        }
95
96        function testDetectionOfFinalMethods() {
97                $reflection = new SimpleReflection('AnyOldClass');
98                $this->assertFalse($reflection->hasFinal());
99                $reflection = new SimpleReflection('AnyOldLeafClassWithAFinal');
100                $this->assertTrue($reflection->hasFinal());
101        }
102
103        function testFindingParentClass() {
104                $reflection = new SimpleReflection('AnyOldSubclass');
105                $this->assertEqual($reflection->getParent(), 'AnyOldImplementation');
106        }
107
108        function testInterfaceExistence() {
109                $reflection = new SimpleReflection('AnyOldInterface');
110                $this->assertTrue($reflection->classOrInterfaceExists());
111                $this->assertTrue($reflection->classOrInterfaceExistsSansAutoload());
112                $this->assertTrue($reflection->isInterface());
113        }
114
115        function testMethodsListFromClass() {
116                $reflection = new SimpleReflection('AnyOldClass');
117                $this->assertIdentical($reflection->getMethods(), array('aMethod'));
118        }
119
120        function testMethodsListFromInterface() {
121                $reflection = new SimpleReflection('AnyOldInterface');
122                $this->assertIdentical($reflection->getMethods(), array('aMethod'));
123                $this->assertIdentical($reflection->getInterfaceMethods(), array('aMethod'));
124        }
125
126        function testMethodsComeFromDescendentInterfacesASWell() {
127                $reflection = new SimpleReflection('AnyDescendentInterface');
128                $this->assertIdentical($reflection->getMethods(), array('aMethod'));
129        }
130       
131        function testCanSeparateInterfaceMethodsFromOthers() {
132                $reflection = new SimpleReflection('AnyOldImplementation');
133                $this->assertIdentical($reflection->getMethods(), array('aMethod', 'extraMethod'));
134                $this->assertIdentical($reflection->getInterfaceMethods(), array('aMethod'));
135        }
136
137        function testMethodsComeFromDescendentInterfacesInAbstractClass() {
138                $reflection = new SimpleReflection('AnyAbstractImplementation');
139                $this->assertIdentical($reflection->getMethods(), array('aMethod'));
140        }
141
142        function testInterfaceHasOnlyItselfToImplement() {
143                $reflection = new SimpleReflection('AnyOldInterface');
144                $this->assertEqual(
145                                $reflection->getInterfaces(),
146                                array('AnyOldInterface'));
147        }
148
149        function testInterfacesListedForClass() {
150                $reflection = new SimpleReflection('AnyOldImplementation');
151                $this->assertEqual(
152                                $reflection->getInterfaces(),
153                                array('AnyOldInterface'));
154        }
155
156        function testInterfacesListedForSubclass() {
157                $reflection = new SimpleReflection('AnyOldSubclass');
158                $this->assertEqual(
159                                $reflection->getInterfaces(),
160                                array('AnyOldInterface'));
161        }
162
163        function testNoParameterCreationWhenNoInterface() {
164                $reflection = new SimpleReflection('AnyOldArgumentClass');
165                $function = $reflection->getSignature('aMethod');
166                if (version_compare(phpversion(), '5.0.2', '<=')) {
167                        $this->assertEqual('function amethod()', strtolower($function));
168                } else {
169                        $this->assertEqual('function aMethod()', $function);
170                }
171        }
172
173        function testParameterCreationWithoutTypeHinting() {
174                $reflection = new SimpleReflection('AnyOldArgumentImplementation');
175                $function = $reflection->getSignature('aMethod');
176                if (version_compare(phpversion(), '5.0.2', '<=')) {
177                        $this->assertEqual('function amethod(AnyOldInterface $argument)', $function);
178                } else {
179                        $this->assertEqual('function aMethod(AnyOldInterface $argument)', $function);
180                }
181        }
182
183        function testParameterCreationForTypeHinting() {
184                $reflection = new SimpleReflection('AnyOldTypeHintedClass');
185                $function = $reflection->getSignature('aMethod');
186                if (version_compare(phpversion(), '5.0.2', '<=')) {
187                        $this->assertEqual('function amethod(AnyOldInterface $argument)', $function);
188                } else {
189                        $this->assertEqual('function aMethod(AnyOldInterface $argument)', $function);
190                }
191        }
192
193        function testIssetFunctionSignature() {
194                $reflection = new SimpleReflection('AnyOldOverloadedClass');
195                $function = $reflection->getSignature('__isset');
196                if (version_compare(phpversion(), '5.1.0', '>=')) {
197                        $this->assertEqual('function __isset($key)', $function);
198                } else {
199                        $this->assertEqual('function __isset()', $function);
200                }
201        }
202       
203        function testUnsetFunctionSignature() {
204                $reflection = new SimpleReflection('AnyOldOverloadedClass');
205                $function = $reflection->getSignature('__unset');
206                if (version_compare(phpversion(), '5.1.0', '>=')) {
207                        $this->assertEqual('function __unset($key)', $function);
208                } else {
209                        $this->assertEqual('function __unset()', $function);
210                }
211        }
212
213        function testProperlyReflectsTheFinalInterfaceWhenObjectImplementsAnExtendedInterface() {
214                $reflection = new SimpleReflection('AnyDescendentImplementation');
215                $interfaces = $reflection->getInterfaces();
216                $this->assertEqual(1, count($interfaces));
217                $this->assertEqual('AnyDescendentInterface', array_shift($interfaces));
218        }
219       
220        function testCreatingSignatureForAbstractMethod() {
221            $reflection = new SimpleReflection('AnotherOldAbstractClass');
222            $this->assertEqual($reflection->getSignature('aMethod'), 'function aMethod(AnyOldInterface $argument)');
223        }
224       
225        function testCanProperlyGenerateStaticMethodSignatures() {
226                $reflection = new SimpleReflection('AnyOldClassWithStaticMethods');
227                $this->assertEqual('static function aStatic()', $reflection->getSignature('aStatic'));
228                $this->assertEqual(
229                        'static function aStaticWithParameters($arg1, $arg2)',
230                        $reflection->getSignature('aStaticWithParameters')
231                );
232        }
233}
234
235class TestOfReflectionWithTypeHints extends UnitTestCase {
236        function skip() {
237                $this->skipIf(version_compare(phpversion(), '5.1.0', '<'), 'Reflection with type hints only tested for PHP 5.1.0 and above');
238        }
239
240        function testParameterCreationForTypeHintingWithArray() {
241                eval('interface AnyOldArrayTypeHintedInterface {
242                                  function amethod(array $argument);
243                          }
244                          class AnyOldArrayTypeHintedClass implements AnyOldArrayTypeHintedInterface {
245                                  function amethod(array $argument) {}
246                          }');
247                $reflection = new SimpleReflection('AnyOldArrayTypeHintedClass');
248                $function = $reflection->getSignature('amethod');
249                $this->assertEqual('function amethod(array $argument)', $function);
250        }
251}
252
253class TestOfAbstractsWithAbstractMethods extends UnitTestCase {
254    function testCanProperlyGenerateAbstractMethods() {
255        $reflection = new SimpleReflection('AnyOldAbstractClassWithAbstractMethods');
256        $this->assertEqual(
257            'function anAbstract()',
258            $reflection->getSignature('anAbstract')
259        );
260        $this->assertEqual(
261            'function anAbstractWithParameter($foo)',
262            $reflection->getSignature('anAbstractWithParameter')
263        );
264        $this->assertEqual(
265            'function anAbstractWithMultipleParameters($foo, $bar)',
266            $reflection->getSignature('anAbstractWithMultipleParameters')
267        );
268    }
269}
270
271?>
Note: See TracBrowser for help on using the repository browser.