/hphp/test/quick/cuf.php

https://github.com/tstarling/hiphop-php · PHP · 689 lines · 566 code · 10 blank · 113 comment · 0 complexity · dd34eb46d5d7bced9c156b2aec69e0ca MD5 · raw file 

    

  1. <?php
    2. 

  2. error_reporting(-1);
    3. 

  3. 

  4. class A {
    5. 

  5.   public function meth() {
    6. 

  6.     echo __CLASS__ . ' ' . get_called_class() .
    7. 

  7.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    8. 

  8.   }
    9. 

  9.   public static function staticMeth() {
    10. 

  10.     echo __CLASS__ . ' ' . get_called_class() .
    11. 

  11.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    12. 

  12.   }
    13. 

  13. }
    14. 

  14. 

  15. class B extends A {
    16. 

  16.   public function meth() {
    17. 

  17.     echo __CLASS__ . ' ' . get_called_class() .
    18. 

  18.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    19. 

  19.   }
    20. 

  20.   public static function staticMeth() {
    21. 

  21.     echo __CLASS__ . ' ' . get_called_class() .
    22. 

  22.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    23. 

  23.   }
    24. 

  24.   public function doMeth() {
    25. 

  25.     $this->meth();  // B B B
    26. 

  26.     B::meth();      // B B B
    27. 

  27.     C::meth();      // C C   (Zend outputs: C B B) (Rule 1)
    28. 

  28.     D::meth();      // D D   (Zend outputs: D B B) (Rule 1)
    29. 

  29.     F::meth();      // F F   (Zend outputs: F B B) (Rule 1)
    30. 

  30.     G::meth();      // G G   (Zend outputs: G B B) (Rule 1)
    31. 

  31.     H::meth();      // H H   (Zend outputs: H B B) (Rule 1)
    32. 

  32.     parent::meth(); // A B B
    33. 

  33.     self::meth();   // B B B
    34. 

  34.     static::meth(); // B B B
    35. 

  35.     echo "****************\n";
    36. 

  36.   }
    37. 

  37.   public function doStaticMeth() {
    38. 

  38.     $this->staticMeth();  // B B
    39. 

  39.     B::staticMeth();      // B B
    40. 

  40.     C::staticMeth();      // C C
    41. 

  41.     D::staticMeth();      // D D
    42. 

  42.     F::staticMeth();      // F F
    43. 

  43.     G::staticMeth();      // G G
    44. 

  44.     H::staticMeth();      // H H
    45. 

  45.     parent::staticMeth(); // A B
    46. 

  46.     self::staticMeth();   // B B
    47. 

  47.     static::staticMeth(); // B B
    48. 

  48.     echo "****************\n";
    49. 

  49.   }
    50. 

  50. }
    51. 

  51. 

  52. class C extends B {
    53. 

  53.   public function meth() {
    54. 

  54.     echo __CLASS__ . ' ' . get_called_class() .
    55. 

  55.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    56. 

  56.   }
    57. 

  57.   public static function staticMeth() {
    58. 

  58.     echo __CLASS__ . ' ' . get_called_class() .
    59. 

  59.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    60. 

  60.   }
    61. 

  61.   /**
    62. 

  62.    * Zend's implementation of call_user_func() and forward_static_call() has
    63. 

  63.    * a few corner cases where its behavior is strictly incorrect. HipHop will
    64. 

  64.    * match Zend's behavior except for cases that violate one of the following
    65. 

  65.    * invariants:
    66. 

  66.    *   1) If the current instance ($this) is non-null, the class of the current
    67. 

  67.    *      instance must be the same or a descendent of the class enclosing the
    68. 

  68.    *      current method. The PHP group is in the process of depracating this
    69. 

  69.    *      behavior. HipHop explicitly lists this in the inconsistencies doc.
    70. 

  70.    *   2) If the current instance ($this) is non-null, the class of the current
    71. 

  71.    *      instance must be the same as the current late bound class (aka the
    72. 

  72.    *      "called class"). This invariant is stated explicitly in Zend PHP's
    73. 

  73.    *      documentation: "In non-static contexts, the called class will be the
    74. 

  74.    *      class of the object instance."
    75. 

  75.    *   3) Normal style calls and call_user_func style calls should produce
    76. 

  76.    *      consistent results aside from any exceptions mentioned in Zend PHP's
    77. 

  77.    *      documentation. Therefore, "B::meth()" and "call_user_func('B::meth')"
    78. 

  78.    *      and "call_user_func(array('B', 'meth'))" should all produce consistent
    79. 

  79.    *      results.
    80. 

  80.    *   4) call_user_func() and forward_static_call() must never forward the
    81. 

  81.    *      caller's late bound class to the callee if the late bound class is
    82. 

  82.    *      not the same or a descendent of the class enclosing the method.
    83. 

  83.    *      Zend's implementation of forward_static_call contains a check for
    84. 

  84.    *      this, implying intent to uphold this invariant.
    85. 

  85.    */
    86. 

  86.   public function testMeth1() {
    87. 

  87.     echo "############# testMeth1 ##############\n";
    88. 

  88.     B::meth(); // B D D
    89. 

  89.     C::meth(); // C D D
    90. 

  90.     D::meth(); // D D D
    91. 

  91.     F::meth(); // F F    (Zend: F D D) (Rule 1)
    92. 

  92.     G::meth(); // G G    (Zend: G D D) (Rule 1)
    93. 

  93.     H::meth(); // H H    (Zend: H D D) (Rule 1)
    94. 

  94.     parent::meth(); // B D D
    95. 

  95.     self::meth();   // C D D
    96. 

  96.     static::meth(); // D D D
    97. 

  97.     echo "****************\n";
    98. 

  98.     call_user_func('B::meth'); // B D D
    99. 

  99.     call_user_func('C::meth'); // C D D
    100. 

  100.     call_user_func('D::meth'); // D D D
    101. 

  101.     call_user_func('F::meth'); // F F
    102. 

  102.     call_user_func('G::meth'); // G G
    103. 

  103.     call_user_func('H::meth'); // H H
    104. 

  104.     call_user_func('parent::meth'); // B D D
    105. 

  105.     call_user_func('self::meth');   // C D D
    106. 

  106.     call_user_func('static::meth'); // D D D
    107. 

  107.     echo "****************\n";
    108. 

  108.     call_user_func(array('B','meth')); // B D D
    109. 

  109.     call_user_func(array('C','meth')); // C D D
    110. 

  110.     call_user_func(array('D','meth')); // D D D
    111. 

  111.     call_user_func(array('F','meth')); // F F
    112. 

  112.     call_user_func(array('G','meth')); // G G
    113. 

  113.     call_user_func(array('H','meth')); // H H
    114. 

  114.     call_user_func(array('parent','meth')); // B D D
    115. 

  115.     call_user_func(array('self','meth'));   // C D D
    116. 

  116.     call_user_func(array('static','meth')); // D D D
    117. 

  117.     echo "****************\n";
    118. 

  118.     call_user_func(array('B','B::meth')); // B D D
    119. 

  119.     call_user_func(array('B','C::meth')); // warning
    120. 

  120.     call_user_func(array('B','D::meth')); // warning
    121. 

  121.     call_user_func(array('B','F::meth')); // warning
    122. 

  122.     call_user_func(array('B','G::meth')); // warning
    123. 

  123.     call_user_func(array('B','H::meth')); // warning
    124. 

  124.     call_user_func(array('B','parent::meth')); // A D D
    125. 

  125.     call_user_func(array('B','self::meth'));   // B D D
    126. 

  126.     call_user_func(array('B','static::meth')); // warning
    127. 

  127.     echo "****************\n";
    128. 

  128.     $call = array('B','B::meth'); $call(); // B D D
    129. 

  129.     // $call = array('B','C::meth'); $call(); // expected fatal
    130. 

  130.     // $call = array('B','D::meth'); $call(); // expected fatal
    131. 

  131.     // $call = array('B','F::meth'); $call(); // expected fatal
    132. 

  132.     // $call = array('B','G::meth'); $call(); // expected fatal
    133. 

  133.     // $call = array('B','H::meth'); $call(); // expected fatal
    134. 

  134.     $call = array('B','parent::meth'); $call(); // A D D
    135. 

  135.     $call = array('B','self::meth'); $call();   // B D D
    136. 

  136.     // $call = array('B','static::meth'); $call(); // expected fatal
    137. 

  137.     echo "****************\n";
    138. 

  138.     call_user_func(array('G','B::meth')); // warning
    139. 

  139.     call_user_func(array('G','C::meth')); // warning
    140. 

  140.     call_user_func(array('G','D::meth')); // warning
    141. 

  141.     call_user_func(array('G','F::meth')); // F F
    142. 

  142.     call_user_func(array('G','G::meth')); // G G
    143. 

  143.     call_user_func(array('G','H::meth')); // warning
    144. 

  144.     call_user_func(array('G','parent::meth')); // F F  (Zend: F D D) (Rule 1)
    145. 

  145.     call_user_func(array('G','self::meth'));   // G G  (Zend: G D D) (Rule 1)
    146. 

  146.     call_user_func(array('G','static::meth')); // warning
    147. 

  147.     echo "****************\n";
    148. 

  148.     // $call = array('G','B::meth'); $call(); // expected fatal
    149. 

  149.     // $call = array('G','C::meth'); $call(); // expected fatal
    150. 

  150.     // $call = array('G','D::meth'); $call(); // expected fatal
    151. 

  151.     $call = array('G','F::meth'); $call(); // F F
    152. 

  152.     $call = array('G','G::meth'); $call(); // G G
    153. 

  153.     // $call = array('G','H::meth'); $call(); // expected fatal
    154. 

  154.     $call = array('G','parent::meth'); $call(); // F F  (Zend: F D D) (Rule 1)
    155. 

  155.     $call = array('G','self::meth'); $call();   // G G  (Zend: G D D) (Rule 1)
    156. 

  156.     // $call = array('G','static::meth'); $call(); // expected fatal
    157. 

  157.     echo "****************\n";
    158. 

  158.     $b = new B;
    159. 

  159.     call_user_func(array($b,'meth')); // B B B
    160. 

  160.     call_user_func(array($b,'B::meth')); // B B B
    161. 

  161.     call_user_func(array($b,'C::meth')); // warning
    162. 

  162.     call_user_func(array($b,'D::meth')); // warning
    163. 

  163.     call_user_func(array($b,'F::meth')); // warning
    164. 

  164.     call_user_func(array($b,'G::meth')); // warning
    165. 

  165.     call_user_func(array($b,'H::meth')); // warning
    166. 

  166.     call_user_func(array($b,'parent::meth')); // A B B
    167. 

  167.     call_user_func(array($b,'self::meth'));   // B B B
    168. 

  168.     call_user_func(array($b,'static::meth')); // warning
    169. 

  169.     echo "****************\n";
    170. 

  170.     $b = new B;
    171. 

  171.     $call = array($b,'meth'); $call(); // B B B
    172. 

  172.     $call = array($b,'B::meth'); $call(); // B B B
    173. 

  173.     // $call = array($b,'C::meth'); $call(); // expected fatal
    174. 

  174.     // $call = array($b,'D::meth'); $call(); // expected fatal
    175. 

  175.     // $call = array($b,'F::meth'); $call(); // expected fatal
    176. 

  176.     // $call = array($b,'G::meth'); $call(); // expected fatal
    177. 

  177.     // $call = array($b,'H::meth'); $call(); // expected fatal
    178. 

  178.     $call = array($b,'parent::meth'); $call(); // A B B
    179. 

  179.     $call = array($b,'self::meth'); $call();   // B B B
    180. 

  180.     // $call = array($b,'static::meth'); $call(); // expected fatal
    181. 

  181.     echo "****************\n";
    182. 

  182.     $g = new G;
    183. 

  183.     call_user_func(array($g,'meth')); // G G G
    184. 

  184.     call_user_func(array($g,'B::meth')); // warning
    185. 

  185.     call_user_func(array($g,'C::meth')); // warning
    186. 

  186.     call_user_func(array($g,'D::meth')); // warning
    187. 

  187.     call_user_func(array($g,'F::meth')); // F G G
    188. 

  188.     call_user_func(array($g,'G::meth')); // G G G
    189. 

  189.     call_user_func(array($g,'H::meth')); // warning
    190. 

  190.     call_user_func(array($g,'parent::meth')); // F G G
    191. 

  191.     call_user_func(array($g,'self::meth'));   // G G G
    192. 

  192.     call_user_func(array($g,'static::meth')); // warning
    193. 

  193.     echo "****************\n";
    194. 

  194.     $g = new G;
    195. 

  195.     $call = array($g,'meth'); $call(); // G G G
    196. 

  196.     // $call = array($g,'B::meth'); $call(); // expected fatal
    197. 

  197.     // $call = array($g,'C::meth'); $call(); // expected fatal
    198. 

  198.     // $call = array($g,'D::meth'); $call(); // expected fatal
    199. 

  199.     $call = array($g,'F::meth'); $call(); // F G G
    200. 

  200.     $call = array($g,'G::meth'); $call(); // G G G
    201. 

  201.     // $call = array($g,'H::meth'); $call(); // expected fatal
    202. 

  202.     $call = array($g,'parent::meth'); $call(); // F G G
    203. 

  203.     $call = array($g,'self::meth'); $call();   // G G G
    204. 

  204.     // $call = array($g,'static::meth'); $call(); // expected fatal
    205. 

  205.     echo "****************\n";
    206. 

  206.   }
    207. 

  207.   public static function testMeth2() {
    208. 

  208.     echo "############# testMeth2 ##############\n";
    209. 

  209.     B::meth(); // B B
    210. 

  210.     C::meth(); // C C
    211. 

  211.     D::meth(); // D D
    212. 

  212.     F::meth(); // F F
    213. 

  213.     G::meth(); // G G
    214. 

  214.     H::meth(); // H H
    215. 

  215.     parent::meth(); // B D
    216. 

  216.     self::meth();   // C D
    217. 

  217.     static::meth(); // D D
    218. 

  218.     echo "****************\n";
    219. 

  219.     call_user_func('B::meth'); // B B
    220. 

  220.     call_user_func('C::meth'); // C C
    221. 

  221.     call_user_func('D::meth'); // D D
    222. 

  222.     call_user_func('F::meth'); // F F
    223. 

  223.     call_user_func('G::meth'); // G G
    224. 

  224.     call_user_func('H::meth'); // H H
    225. 

  225.     call_user_func('parent::meth'); // B D
    226. 

  226.     call_user_func('self::meth');   // C D
    227. 

  227.     call_user_func('static::meth'); // D D
    228. 

  228.     echo "****************\n";
    229. 

  229.     call_user_func(array('B','meth')); // B B
    230. 

  230.     call_user_func(array('C','meth')); // C C
    231. 

  231.     call_user_func(array('D','meth')); // D D
    232. 

  232.     call_user_func(array('F','meth')); // F F
    233. 

  233.     call_user_func(array('G','meth')); // G G
    234. 

  234.     call_user_func(array('H','meth')); // H H
    235. 

  235.     call_user_func(array('parent','meth')); // B D
    236. 

  236.     call_user_func(array('self','meth'));   // C D
    237. 

  237.     call_user_func(array('static','meth')); // D D
    238. 

  238.     echo "****************\n";
    239. 

  239.     $call = array('B','meth'); $call(); // B B
    240. 

  240.     $call = array('C','meth'); $call(); // C C
    241. 

  241.     $call = array('D','meth'); $call(); // D D
    242. 

  242.     $call = array('F','meth'); $call(); // F F
    243. 

  243.     $call = array('G','meth'); $call(); // G G
    244. 

  244.     $call = array('H','meth'); $call(); // H H
    245. 

  245.     $call = array('parent','meth'); $call(); // B D
    246. 

  246.     $call = array('self','meth'); $call();   // C D
    247. 

  247.     $call = array('static','meth'); $call(); // D D
    248. 

  248.     echo "****************\n";
    249. 

  249.     call_user_func(array('B','B::meth')); // B B
    250. 

  250.     call_user_func(array('B','C::meth')); // warning
    251. 

  251.     call_user_func(array('B','D::meth')); // warning
    252. 

  252.     call_user_func(array('B','F::meth')); // warning
    253. 

  253.     call_user_func(array('B','G::meth')); // warning
    254. 

  254.     call_user_func(array('B','H::meth')); // warning
    255. 

  255.     call_user_func(array('B','parent::meth')); // A D
    256. 

  256.     call_user_func(array('B','self::meth'));   // B D
    257. 

  257.     call_user_func(array('B','static::meth')); // warning
    258. 

  258.     echo "****************\n";
    259. 

  259.     $call = array('B','B::meth'); $call(); // B B
    260. 

  260.     // $call = array('B','C::meth'); $call(); // expected fatal
    261. 

  261.     // $call = array('B','D::meth'); $call(); // expected fatal
    262. 

  262.     // $call = array('B','F::meth'); $call(); // expected fatal
    263. 

  263.     // $call = array('B','G::meth'); $call(); // expected fatal
    264. 

  264.     // $call = array('B','H::meth'); $call(); // expected fatal
    265. 

  265.     $call = array('B','parent::meth'); $call(); // A D
    266. 

  266.     $call = array('B','self::meth'); $call();   // B D
    267. 

  267.     // $call = array('B','static::meth'); $call(); // expected fatal
    268. 

  268.     echo "****************\n";
    269. 

  269.     call_user_func(array('G','B::meth')); // warning
    270. 

  270.     call_user_func(array('G','C::meth')); // warning
    271. 

  271.     call_user_func(array('G','D::meth')); // warning
    272. 

  272.     call_user_func(array('G','F::meth')); // F F
    273. 

  273.     call_user_func(array('G','G::meth')); // G G
    274. 

  274.     call_user_func(array('G','H::meth')); // warning
    275. 

  275.     call_user_func(array('G','parent::meth')); // F F   (Zend: F D) (Rule 4)
    276. 

  276.     call_user_func(array('G','self::meth'));   // G G   (Zend: G D) (Rule 4)
    277. 

  277.     call_user_func(array('G','static::meth')); // warning
    278. 

  278.     echo "****************\n";
    279. 

  279.     // $call = array('G','B::meth'); $call(); // warning
    280. 

  280.     // $call = array('G','C::meth'); $call(); // warning
    281. 

  281.     // $call = array('G','D::meth'); $call(); // warning
    282. 

  282.     $call = array('G','F::meth'); $call(); // F F
    283. 

  283.     $call = array('G','G::meth'); $call(); // G G
    284. 

  284.     // $call = array('G','H::meth'); $call(); // warning
    285. 

  285.     $call = array('G','parent::meth'); $call(); // F F   (Zend: F D) (Rule 4)
    286. 

  286.     $call = array('G','self::meth'); $call();   // G G   (Zend: G D) (Rule 4)
    287. 

  287.     // $call = array('G','static::meth'); $call(); // warning
    288. 

  288.     echo "****************\n";
    289. 

  289.     $b = new B;
    290. 

  290.     call_user_func(array($b,'meth'));    // B B B
    291. 

  291.     call_user_func(array($b,'B::meth')); // B B B
    292. 

  292.     call_user_func(array($b,'C::meth')); // warning
    293. 

  293.     call_user_func(array($b,'D::meth')); // warning
    294. 

  294.     call_user_func(array($b,'F::meth')); // warning
    295. 

  295.     call_user_func(array($b,'G::meth')); // warning
    296. 

  296.     call_user_func(array($b,'H::meth')); // warning
    297. 

  297.     call_user_func(array($b,'parent::meth')); // A B B
    298. 

  298.     call_user_func(array($b,'self::meth'));   // B B B
    299. 

  299.     call_user_func(array($b,'static::meth')); // warning
    300. 

  300.     echo "****************\n";
    301. 

  301.     $b = new B;
    302. 

  302.     $call = array($b,'meth'); $call();    // B B B
    303. 

  303.     $call = array($b,'B::meth'); $call(); // B B B
    304. 

  304.     // $call = array($b,'C::meth'); $call(); // expected fatal
    305. 

  305.     // $call = array($b,'D::meth'); $call(); // expected fatal
    306. 

  306.     // $call = array($b,'F::meth'); $call(); // expected fatal
    307. 

  307.     // $call = array($b,'G::meth'); $call(); // expected fatal
    308. 

  308.     // $call = array($b,'H::meth'); $call(); // expected fatal
    309. 

  309.     $call = array($b,'parent::meth'); $call(); // A B B
    310. 

  310.     $call = array($b,'self::meth'); $call();   // B B B
    311. 

  311.     // $call = array($b,'static::meth'); $call(); // expected fatal
    312. 

  312.     echo "****************\n";
    313. 

  313.     $g = new G;
    314. 

  314.     call_user_func(array($g,'meth'));    // G G G
    315. 

  315.     call_user_func(array($g,'B::meth')); // warning
    316. 

  316.     call_user_func(array($g,'C::meth')); // warning
    317. 

  317.     call_user_func(array($g,'D::meth')); // warning
    318. 

  318.     call_user_func(array($g,'F::meth')); // F G G
    319. 

  319.     call_user_func(array($g,'G::meth')); // G G G
    320. 

  320.     call_user_func(array($g,'H::meth')); // warning
    321. 

  321.     call_user_func(array($g,'parent::meth')); // F G G
    322. 

  322.     call_user_func(array($g,'self::meth'));   // G G G
    323. 

  323.     call_user_func(array($g,'static::meth')); // warning
    324. 

  324.     echo "****************\n";
    325. 

  325.     $g = new G;
    326. 

  326.     $call = array($g,'meth'); $call();    // G G G
    327. 

  327.     // $call = array($g,'B::meth'); $call(); // expected fatal
    328. 

  328.     // $call = array($g,'C::meth'); $call(); // expected fatal
    329. 

  329.     // $call = array($g,'D::meth'); $call(); // expected fatal
    330. 

  330.     $call = array($g,'F::meth'); $call(); // F G G
    331. 

  331.     $call = array($g,'G::meth'); $call(); // G G G
    332. 

  332.     // $call = array($g,'H::meth'); $call(); // expected fatal
    333. 

  333.     $call = array($g,'parent::meth'); $call(); // F G G
    334. 

  334.     $call = array($g,'self::meth'); $call();   // G G G
    335. 

  335.     // $call = array($g,'static::meth'); $call(); // expected fatal
    336. 

  336.     echo "****************\n";
    337. 

  337.   }
    338. 

  338.   public function testStaticMeth1() {
    339. 

  339.     echo "############# testStaticMeth1 ##############\n";
    340. 

  340.     B::staticMeth(); // B B
    341. 

  341.     C::staticMeth(); // C C
    342. 

  342.     D::staticMeth(); // D D
    343. 

  343.     F::staticMeth(); // F F
    344. 

  344.     G::staticMeth(); // G G
    345. 

  345.     H::staticMeth(); // H H
    346. 

  346.     parent::staticMeth(); // B D
    347. 

  347.     self::staticMeth();   // C D
    348. 

  348.     static::staticMeth(); // D D
    349. 

  349.     echo "****************\n";
    350. 

  350.     call_user_func('B::staticMeth'); // B B   (Zend: B D) (Rule 3)
    351. 

  351.     call_user_func('C::staticMeth'); // C C   (Zend: C D) (Rule 3)
    352. 

  352.     call_user_func('D::staticMeth'); // D D
    353. 

  353.     call_user_func('F::staticMeth'); // F F
    354. 

  354.     call_user_func('G::staticMeth'); // G G
    355. 

  355.     call_user_func('H::staticMeth'); // H H
    356. 

  356.     call_user_func('parent::staticMeth'); // B D
    357. 

  357.     call_user_func('self::staticMeth');   // C D
    358. 

  358.     call_user_func('static::staticMeth'); // D D
    359. 

  359.     echo "****************\n";
    360. 

  360.     call_user_func(array('B','staticMeth')); // B B   (Zend: B D) (Rule 3)
    361. 

  361.     call_user_func(array('C','staticMeth')); // C C   (Zend: C D) (Rule 3)
    362. 

  362.     call_user_func(array('D','staticMeth')); // D D
    363. 

  363.     call_user_func(array('F','staticMeth')); // F F
    364. 

  364.     call_user_func(array('G','staticMeth')); // G G
    365. 

  365.     call_user_func(array('H','staticMeth')); // H H
    366. 

  366.     call_user_func(array('parent','staticMeth')); // B D
    367. 

  367.     call_user_func(array('self','staticMeth'));   // C D
    368. 

  368.     call_user_func(array('static','staticMeth')); // D D
    369. 

  369.     echo "****************\n";
    370. 

  370.     $call = array('B','staticMeth'); $call(); // B B   (Zend: B D) (Rule 3)
    371. 

  371.     $call = array('C','staticMeth'); $call(); // C C   (Zend: C D) (Rule 3)
    372. 

  372.     $call = array('D','staticMeth'); $call(); // D D
    373. 

  373.     $call = array('F','staticMeth'); $call(); // F F
    374. 

  374.     $call = array('G','staticMeth'); $call(); // G G
    375. 

  375.     $call = array('H','staticMeth'); $call(); // H H
    376. 

  376.     $call = array('parent','staticMeth'); $call(); // B D
    377. 

  377.     $call = array('self','staticMeth'); $call();   // C D
    378. 

  378.     $call = array('static','staticMeth'); $call(); // D D
    379. 

  379.     echo "****************\n";
    380. 

  380.     call_user_func(array('B','B::staticMeth')); // B B   (Zend: B D) (Rule 3)
    381. 

  381.     call_user_func(array('B','C::staticMeth')); // warning
    382. 

  382.     call_user_func(array('B','D::staticMeth')); // warning
    383. 

  383.     call_user_func(array('B','F::staticMeth')); // warning
    384. 

  384.     call_user_func(array('B','G::staticMeth')); // warning
    385. 

  385.     call_user_func(array('B','H::staticMeth')); // warning
    386. 

  386.     call_user_func(array('B','parent::staticMeth')); // A D
    387. 

  387.     call_user_func(array('B','self::staticMeth'));   // B D
    388. 

  388.     call_user_func(array('B','static::staticMeth')); // warning
    389. 

  389.     echo "****************\n";
    390. 

  390.     $call = array('B','B::staticMeth'); $call(); // B B   (Zend: B D) (Rule 3)
    391. 

  391.     // $call = array('B','C::staticMeth'); $call(); // expected fatal
    392. 

  392.     // $call = array('B','D::staticMeth'); $call(); // expected fatal
    393. 

  393.     // $call = array('B','F::staticMeth'); $call(); // expected fatal
    394. 

  394.     // $call = array('B','G::staticMeth'); $call(); // expected fatal
    395. 

  395.     // $call = array('B','H::staticMeth'); $call(); // expected fatal
    396. 

  396.     $call = array('B','parent::staticMeth'); $call(); // A D
    397. 

  397.     $call = array('B','self::staticMeth'); $call();   // B D
    398. 

  398.     // $call = array('B','static::staticMeth'); $call(); // expected fatal
    399. 

  399.     echo "****************\n";
    400. 

  400.     call_user_func(array('G','B::staticMeth')); // warning
    401. 

  401.     call_user_func(array('G','C::staticMeth')); // warning
    402. 

  402.     call_user_func(array('G','D::staticMeth')); // warning
    403. 

  403.     call_user_func(array('G','F::staticMeth')); // F F
    404. 

  404.     call_user_func(array('G','G::staticMeth')); // G G
    405. 

  405.     call_user_func(array('G','H::staticMeth')); // warning
    406. 

  406.     call_user_func(array('G','parent::staticMeth')); // F F   (Zend: F D) (Rule 4)
    407. 

  407.     call_user_func(array('G','self::staticMeth'));   // G G   (Zend: G D) (Rule 4)
    408. 

  408.     call_user_func(array('G','static::staticMeth')); // warning
    409. 

  409.     echo "****************\n";
    410. 

  410.     // $call = array('G','B::staticMeth'); $call(); // expected fatal
    411. 

  411.     // $call = array('G','C::staticMeth'); $call(); // expected fatal
    412. 

  412.     // $call = array('G','D::staticMeth'); $call(); // expected fatal
    413. 

  413.     $call = array('G','F::staticMeth'); $call(); // F F
    414. 

  414.     $call = array('G','G::staticMeth'); $call(); // G G
    415. 

  415.     // $call = array('G','H::staticMeth'); $call(); // expected fatal
    416. 

  416.     $call = array('G','parent::staticMeth'); $call(); // F F   (Zend: F D) (Rule 4)
    417. 

  417.     $call = array('G','self::staticMeth'); $call();   // G G   (Zend: G D) (Rule 4)
    418. 

  418.     // $call = array('G','static::staticMeth'); $call(); // expected fatal
    419. 

  419.     echo "****************\n";
    420. 

  420.     $b = new B;
    421. 

  421.     call_user_func(array($b,'staticMeth'));    // B B
    422. 

  422.     call_user_func(array($b,'B::staticMeth')); // B B
    423. 

  423.     call_user_func(array($b,'C::staticMeth')); // warning
    424. 

  424.     call_user_func(array($b,'D::staticMeth')); // warning
    425. 

  425.     call_user_func(array($b,'F::staticMeth')); // warning
    426. 

  426.     call_user_func(array($b,'G::staticMeth')); // warning
    427. 

  427.     call_user_func(array($b,'H::staticMeth')); // warning
    428. 

  428.     call_user_func(array($b,'parent::staticMeth')); // A B
    429. 

  429.     call_user_func(array($b,'self::staticMeth'));   // B B
    430. 

  430.     call_user_func(array($b,'static::staticMeth')); // warning
    431. 

  431.     echo "****************\n";
    432. 

  432.     $b = new B;
    433. 

  433.     $call = array($b,'staticMeth'); $call();    // B B
    434. 

  434.     $call = array($b,'B::staticMeth'); $call(); // B B
    435. 

  435.     // $call = array($b,'C::staticMeth'); $call(); // expected fatal
    436. 

  436.     // $call = array($b,'D::staticMeth'); $call(); // expected fatal
    437. 

  437.     // $call = array($b,'F::staticMeth'); $call(); // expected fatal
    438. 

  438.     // $call = array($b,'G::staticMeth'); $call(); // expected fatal
    439. 

  439.     // $call = array($b,'H::staticMeth'); $call(); // expected fatal
    440. 

  440.     $call = array($b,'parent::staticMeth'); $call(); // A B
    441. 

  441.     $call = array($b,'self::staticMeth'); $call();   // B B
    442. 

  442.     // $call = array($b,'static::staticMeth'); $call(); // expected fatal
    443. 

  443.     echo "****************\n";
    444. 

  444.     $g = new G;
    445. 

  445.     call_user_func(array($g,'staticMeth'));    // G G
    446. 

  446.     call_user_func(array($g,'B::staticMeth')); // warning
    447. 

  447.     call_user_func(array($g,'C::staticMeth')); // warning
    448. 

  448.     call_user_func(array($g,'D::staticMeth')); // warning
    449. 

  449.     call_user_func(array($g,'F::staticMeth')); // F G
    450. 

  450.     call_user_func(array($g,'G::staticMeth')); // G G
    451. 

  451.     call_user_func(array($g,'H::staticMeth')); // warning
    452. 

  452.     call_user_func(array($g,'parent::staticMeth')); // F G
    453. 

  453.     call_user_func(array($g,'self::staticMeth'));   // G G
    454. 

  454.     call_user_func(array($g,'static::staticMeth')); // warning
    455. 

  455.     echo "****************\n";
    456. 

  456.     $g = new G;
    457. 

  457.     $call = array($g,'staticMeth'); $call();    // G G
    458. 

  458.     // $call = array($g,'B::staticMeth'); $call(); // expected fatal
    459. 

  459.     // $call = array($g,'C::staticMeth'); $call(); // expected fatal
    460. 

  460.     // $call = array($g,'D::staticMeth'); $call(); // expected fatal
    461. 

  461.     $call = array($g,'F::staticMeth'); $call(); // F G
    462. 

  462.     $call = array($g,'G::staticMeth'); $call(); // G G
    463. 

  463.     // $call = array($g,'H::staticMeth'); $call(); // expected fatal
    464. 

  464.     $call = array($g,'parent::staticMeth'); $call(); // F G
    465. 

  465.     $call = array($g,'self::staticMeth'); $call();   // G G
    466. 

  466.     // $call = array($g,'static::staticMeth'); $call(); // expected fatal
    467. 

  467.     echo "****************\n";
    468. 

  468.   }
    469. 

  469.   public static function testStaticMeth2() {
    470. 

  470.     echo "############# testStaticMeth2 ##############\n";
    471. 

  471.     B::staticMeth(); // B B
    472. 

  472.     C::staticMeth(); // C C
    473. 

  473.     D::staticMeth(); // D D
    474. 

  474.     F::staticMeth(); // F F
    475. 

  475.     G::staticMeth(); // G G
    476. 

  476.     H::staticMeth(); // H H
    477. 

  477.     parent::staticMeth(); // B D
    478. 

  478.     self::staticMeth();   // C D
    479. 

  479.     static::staticMeth(); // D D
    480. 

  480.     echo "****************\n";
    481. 

  481.     call_user_func('B::staticMeth'); // B B
    482. 

  482.     call_user_func('C::staticMeth'); // C C
    483. 

  483.     call_user_func('D::staticMeth'); // D D
    484. 

  484.     call_user_func('F::staticMeth'); // F F
    485. 

  485.     call_user_func('G::staticMeth'); // G G
    486. 

  486.     call_user_func('H::staticMeth'); // H H
    487. 

  487.     call_user_func('parent::staticMeth'); // B D
    488. 

  488.     call_user_func('self::staticMeth');   // C D
    489. 

  489.     call_user_func('static::staticMeth'); // D D
    490. 

  490.     echo "****************\n";
    491. 

  491.     call_user_func(array('B','staticMeth')); // B B
    492. 

  492.     call_user_func(array('C','staticMeth')); // C C
    493. 

  493.     call_user_func(array('D','staticMeth')); // D D
    494. 

  494.     call_user_func(array('F','staticMeth')); // F F
    495. 

  495.     call_user_func(array('G','staticMeth')); // G G
    496. 

  496.     call_user_func(array('H','staticMeth')); // H H
    497. 

  497.     call_user_func(array('parent','staticMeth')); // B D
    498. 

  498.     call_user_func(array('self','staticMeth'));   // C D
    499. 

  499.     call_user_func(array('static','staticMeth')); // D D
    500. 

  500.     echo "****************\n";
    501. 

  501.     $call = array('B','staticMeth'); $call(); // B B
    502. 

  502.     $call = array('C','staticMeth'); $call(); // C C
    503. 

  503.     $call = array('D','staticMeth'); $call(); // D D
    504. 

  504.     $call = array('F','staticMeth'); $call(); // F F
    505. 

  505.     $call = array('G','staticMeth'); $call(); // G G
    506. 

  506.     $call = array('H','staticMeth'); $call(); // H H
    507. 

  507.     $call = array('parent','staticMeth'); $call(); // B D
    508. 

  508.     $call = array('self','staticMeth'); $call();   // C D
    509. 

  509.     $call = array('static','staticMeth'); $call(); // D D
    510. 

  510.     echo "****************\n";
    511. 

  511.     call_user_func(array('B','B::staticMeth')); // B B
    512. 

  512.     call_user_func(array('B','C::staticMeth')); // warning
    513. 

  513.     call_user_func(array('B','D::staticMeth')); // warning
    514. 

  514.     call_user_func(array('B','F::staticMeth')); // warning
    515. 

  515.     call_user_func(array('B','G::staticMeth')); // warning
    516. 

  516.     call_user_func(array('B','H::staticMeth')); // warning
    517. 

  517.     call_user_func(array('B','parent::staticMeth')); // A D
    518. 

  518.     call_user_func(array('B','self::staticMeth'));   // B D
    519. 

  519.     call_user_func(array('B','static::staticMeth')); // warning
    520. 

  520.     echo "****************\n";
    521. 

  521.     $call = array('B','B::staticMeth'); $call(); // B B
    522. 

  522.     // $call = array('B','C::staticMeth'); $call(); // expected fatal
    523. 

  523.     // $call = array('B','D::staticMeth'); $call(); // expected fatal
    524. 

  524.     // $call = array('B','F::staticMeth'); $call(); // expected fatal
    525. 

  525.     // $call = array('B','G::staticMeth'); $call(); // expected fatal
    526. 

  526.     // $call = array('B','H::staticMeth'); $call(); // expected fatal
    527. 

  527.     $call = array('B','parent::staticMeth'); $call(); // A D
    528. 

  528.     $call = array('B','self::staticMeth'); $call();   // B D
    529. 

  529.     // $call = array('B','static::staticMeth'); $call(); // expected fatal
    530. 

  530.     echo "****************\n";
    531. 

  531.     call_user_func(array('G','B::staticMeth')); // warning
    532. 

  532.     call_user_func(array('G','C::staticMeth')); // warning
    533. 

  533.     call_user_func(array('G','D::staticMeth')); // warning
    534. 

  534.     call_user_func(array('G','F::staticMeth')); // F F
    535. 

  535.     call_user_func(array('G','G::staticMeth')); // G G
    536. 

  536.     call_user_func(array('G','H::staticMeth')); // warning
    537. 

  537.     call_user_func(array('G','parent::staticMeth')); // F F   (Zend: F D) (Rule 4)
    538. 

  538.     call_user_func(array('G','self::staticMeth'));   // G G   (Zend: G D) (Rule 4)
    539. 

  539.     call_user_func(array('G','static::staticMeth')); // warning
    540. 

  540.     echo "****************\n";
    541. 

  541.     // $call = array('G','B::staticMeth'); $call(); // expected fatal
    542. 

  542.     // $call = array('G','C::staticMeth'); $call(); // expected fatal
    543. 

  543.     // $call = array('G','D::staticMeth'); $call(); // expected fatal
    544. 

  544.     $call = array('G','F::staticMeth'); $call(); // F F
    545. 

  545.     $call = array('G','G::staticMeth'); $call(); // G G
    546. 

  546.     // $call = array('G','H::staticMeth'); $call(); // expected fatal
    547. 

  547.     $call = array('G','parent::staticMeth'); $call(); // F F   (Zend: F D) (Rule 4)
    548. 

  548.     $call = array('G','self::staticMeth'); $call();   // G G   (Zend: G D) (Rule 4)
    549. 

  549.     // $call = array('G','static::staticMeth'); $call(); // expected fatal
    550. 

  550.     echo "****************\n";
    551. 

  551.     $b = new B;
    552. 

  552.     call_user_func(array($b,'staticMeth'));    // B B
    553. 

  553.     call_user_func(array($b,'B::staticMeth')); // B B
    554. 

  554.     call_user_func(array($b,'C::staticMeth')); // warning
    555. 

  555.     call_user_func(array($b,'D::staticMeth')); // warning
    556. 

  556.     call_user_func(array($b,'F::staticMeth')); // warning
    557. 

  557.     call_user_func(array($b,'G::staticMeth')); // warning
    558. 

  558.     call_user_func(array($b,'H::staticMeth')); // warning
    559. 

  559.     call_user_func(array($b,'parent::staticMeth')); // A B
    560. 

  560.     call_user_func(array($b,'self::staticMeth'));   // B B
    561. 

  561.     call_user_func(array($b,'static::staticMeth')); // warning
    562. 

  562.     echo "****************\n";
    563. 

  563.     $b = new B;
    564. 

  564.     $call = array($b,'staticMeth'); $call();    // B B
    565. 

  565.     $call = array($b,'B::staticMeth'); $call(); // B B
    566. 

  566.     // $call = array($b,'C::staticMeth'); $call(); // expected fatal
    567. 

  567.     // $call = array($b,'D::staticMeth'); $call(); // expected fatal
    568. 

  568.     // $call = array($b,'F::staticMeth'); $call(); // expected fatal
    569. 

  569.     // $call = array($b,'G::staticMeth'); $call(); // expected fatal
    570. 

  570.     // $call = array($b,'H::staticMeth'); $call(); // expected fatal
    571. 

  571.     $call = array($b,'parent::staticMeth'); $call(); // A B
    572. 

  572.     $call = array($b,'self::staticMeth'); $call();   // B B
    573. 

  573.     // $call = array($b,'static::staticMeth'); $call(); // expected fatal
    574. 

  574.     echo "****************\n";
    575. 

  575.     $g = new G;
    576. 

  576.     call_user_func(array($g,'staticMeth'));    // G G
    577. 

  577.     call_user_func(array($g,'B::staticMeth')); // warning
    578. 

  578.     call_user_func(array($g,'C::staticMeth')); // warning
    579. 

  579.     call_user_func(array($g,'D::staticMeth')); // warning
    580. 

  580.     call_user_func(array($g,'F::staticMeth')); // F G
    581. 

  581.     call_user_func(array($g,'G::staticMeth')); // G G
    582. 

  582.     call_user_func(array($g,'H::staticMeth')); // warning
    583. 

  583.     call_user_func(array($g,'parent::staticMeth')); // F G
    584. 

  584.     call_user_func(array($g,'self::staticMeth'));   // G G
    585. 

  585.     call_user_func(array($g,'static::staticMeth')); // warning
    586. 

  586.     echo "****************\n";
    587. 

  587.     $g = new G;
    588. 

  588.     $call = array($g,'staticMeth'); $call();    // G G
    589. 

  589.     // $call = array($g,'B::staticMeth'); $call(); // warning
    590. 

  590.     // $call = array($g,'C::staticMeth'); $call(); // warning
    591. 

  591.     // $call = array($g,'D::staticMeth'); $call(); // warning
    592. 

  592.     $call = array($g,'F::staticMeth'); $call(); // F G
    593. 

  593.     $call = array($g,'G::staticMeth'); $call(); // G G
    594. 

  594.     // $call = array($g,'H::staticMeth'); $call(); // warning
    595. 

  595.     $call = array($g,'parent::staticMeth'); $call(); // F G
    596. 

  596.     $call = array($g,'self::staticMeth'); $call();   // G G
    597. 

  597.     // $call = array($g,'static::staticMeth'); $call(); // warning
    598. 

  598.     echo "****************\n";
    599. 

  599.   }
    600. 

  600. }
    601. 

  601. 

  602. class D extends C {
    603. 

  603.   public function meth() {
    604. 

  604.     echo __CLASS__ . ' ' . get_called_class() .
    605. 

  605.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    606. 

  606.   }
    607. 

  607.   public static function staticMeth() {
    608. 

  608.     echo __CLASS__ . ' ' . get_called_class() .
    609. 

  609.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    610. 

  610.   }
    611. 

  611. }
    612. 

  612. 

  613. class F {
    614. 

  614.   public function meth() {
    615. 

  615.     echo __CLASS__ . ' ' . get_called_class() .
    616. 

  616.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    617. 

  617.   }
    618. 

  618.   public static function staticMeth() {
    619. 

  619.     echo __CLASS__ . ' ' . get_called_class() .
    620. 

  620.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    621. 

  621.   }
    622. 

  622. }
    623. 

  623. 

  624. class G extends F {
    625. 

  625.   public function meth() {
    626. 

  626.     echo __CLASS__ . ' ' . get_called_class() .
    627. 

  627.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    628. 

  628.   }
    629. 

  629.   public static function staticMeth() {
    630. 

  630.     echo __CLASS__ . ' ' . get_called_class() .
    631. 

  631.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    632. 

  632.   }
    633. 

  633.   public function doMeth() {
    634. 

  634.     $this->meth();  // G G G
    635. 

  635.     B::meth();      // B B    (Zend: B G G) (Rule 1)
    636. 

  636.     C::meth();      // C C    (Zend: C G G) (Rule 1)
    637. 

  637.     D::meth();      // D D    (Zend: D G G) (Rule 1)
    638. 

  638.     F::meth();      // F G G
    639. 

  639.     G::meth();      // G G G
    640. 

  640.     H::meth();      // H H    (Zend: H G G) (Rule 1)
    641. 

  641.     parent::meth(); // F G G
    642. 

  642.     self::meth();   // G G G
    643. 

  643.     static::meth(); // G G G
    644. 

  644.     echo "****************\n";
    645. 

  645.   }
    646. 

  646.   public function doStaticMeth() {
    647. 

  647.     $this->staticMeth();  // G G
    648. 

  648.     B::staticMeth();      // B B
    649. 

  649.     C::staticMeth();      // C C
    650. 

  650.     D::staticMeth();      // D D
    651. 

  651.     F::staticMeth();      // F F
    652. 

  652.     G::staticMeth();      // G G
    653. 

  653.     H::staticMeth();      // H H
    654. 

  654.     parent::staticMeth(); // F G
    655. 

  655.     self::staticMeth();   // G G
    656. 

  656.     static::staticMeth(); // G G
    657. 

  657.     echo "****************\n";
    658. 

  658.   }
    659. 

  659. }
    660. 

  660. 

  661. class H extends G {
    662. 

  662.   public function meth() {
    663. 

  663.     echo __CLASS__ . ' ' . get_called_class() .
    664. 

  664.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    665. 

  665.   }
    666. 

  666.   public static function staticMeth() {
    667. 

  667.     echo __CLASS__ . ' ' . get_called_class() .
    668. 

  668.          (isset($this) ? ' '.get_class($this) : '') . "\n";
    669. 

  669.   }
    670. 

  670. }
    671. 

  671. 

  672. 

  673. function main() {
    674. 

  674.   $d = new D;
    675. 

  675.   $d->testMeth1();
    676. 

  676.   D::testMeth2();
    677. 

  677.   $d->testStaticMeth1();
    678. 

  678.   D::testStaticMeth2();
    679. 

  679. 

  680.   $b = new B;
    681. 

  681.   $g = new G;
    682. 

  682.   echo "############# doMeth ##############\n";
    683. 

  683.   $b->doMeth();
    684. 

  684.   $g->doMeth();
    685. 

  685.   echo "############# doStaticMeth ##############\n";
    686. 

  686.   $b->doStaticMeth();
    687. 

  687.   $g->doStaticMeth();
    688. 

  688. }
    689. 

  689. main();
    690.