t/pmc/object-mro.t

   1 #! perl
   2 # Copyright (C) 2001-2005, Parrot Foundation.
   3 # $Id$
   4
   5 use strict;
   6 use warnings;
   7 use lib qw( . lib ../lib ../../lib );
   8 use Test::More;
   9 use Parrot::Test tests => 6;
  10
  11 =head1 NAME
  12
  13 t/pmc/object-mro.t - Object Methods Resolution Order
  14
  15 =head1 SYNOPSIS
  16
  17     % prove t/pmc/object-mro.t
  18
  19 =head1 DESCRIPTION
  20
  21 These are tests for the C3 MRO order
  22
  23 =cut
  24
  25 pir_output_is( <<'CODE', <<'OUTPUT', "print mro diamond" );
  26 #
  27 # A   B A   E
  28 #  \ /   \ /
  29 #   C     D
  30 #    \   /
  31 #     \ /
  32 #      F
  33 .sub main :main
  34     .local pmc A, B, C, D, E, F, mro, p, it
  35     newclass A, "A"
  36     newclass B, "B"
  37     subclass C, A, "C"
  38     addparent C, B
  39
  40     subclass D, A, "D"
  41     newclass E, "E"
  42     addparent D, E
  43
  44     subclass F, C, "F"
  45     addparent F, D
  46     mro = F.'inspect'('all_parents')
  47     it = iter mro
  48     it = 0
  49 loop:
  50     unless it goto ex
  51     p = shift it
  52     $S0 = p
  53     print $S0
  54     print ' '
  55     goto loop
  56 ex:
  57     say 'G'
  58 .end
  59 CODE
  60 F C D A B E G
  61 OUTPUT
  62
  63 pir_output_is( <<'CODE', <<'OUTPUT', "print mro 1" );
  64 #
  65 # example take from: http://www.python.org/2.3/mro.html
  66 #
  67 # class O: pass
  68 # class F(O): pass
  69 # class E(O): pass
  70 # class D(O): pass
  71 # class C(D,F): pass
  72 # class B(D,E): pass
  73 # class A(B,C): pass
  74 #
  75 #                           6
  76 #                          ---
  77 # Level 3                 | O |                  (more general)
  78 #                       /  ---  \
  79 #                      /    |    \                      |
  80 #                     /     |     \                     |
  81 #                    /      |      \                    |
  82 #                   ---    ---    ---                   |
  83 # Level 2        3 | D | 4| E |  | F | 5                |
  84 #                   ---    ---    ---                   |
  85 #                    \  \ _ /       |                   |
  86 #                     \    / \ _    |                   |
  87 #                      \  /      \  |                   |
  88 #                       ---      ---                    |
  89 # Level 1            1 | B |    | C | 2                 |
  90 #                       ---      ---                    |
  91 #                         \      /                      |
  92 #                          \    /                      \ /
  93 #                            ---
  94 # Level 0                 0 | A |                (more specialized)
  95 #                            ---
  96 #
  97 .sub main :main
  98     .local pmc A, B, C, D, E, F, O
  99     newclass O, "O"
 100     subclass F, O, "F"
 101     subclass E, O, "E"
 102     subclass D, O, "D"
 103
 104     subclass C, D, "C"
 105     addparent C, F
 106
 107     subclass B, D, "B"
 108     addparent B, E
 109
 110     subclass A, B, "A"
 111     addparent A, C
 112
 113     .local pmc mro, it, p
 114
 115     mro = A.'inspect'('all_parents')
 116     it = iter mro
 117     it = 0
 118 loop:
 119     unless it goto ex
 120     p = shift it
 121     $S0 = p
 122     print $S0
 123     print ' '
 124     goto loop
 125 ex:
 126     say 'G'
 127 .end
 128 CODE
 129 A B C D E F O G
 130 OUTPUT
 131
 132 pir_output_is( <<'CODE', <<'OUTPUT', "print mro 2" );
 133 #
 134 # example take from: http://www.python.org/2.3/mro.html
 135 #
 136 # class O: pass
 137 # class F(O): pass
 138 # class E(O): pass
 139 # class D(O): pass
 140 # class C(D,F): pass
 141 # class B(E,D): pass
 142 # class A(B,C): pass
 143 #
 144 #                            6
 145 #                           ---
 146 # Level 3                  | O |
 147 #                        /  ---  \
 148 #                       /    |    \
 149 #                      /     |     \
 150 #                     /      |      \
 151 #                   ---     ---    ---
 152 # Level 2        2 | E | 4 | D |  | F | 5
 153 #                   ---     ---    ---
 154 #                    \      / \     /
 155 #                     \    /   \   /
 156 #                      \  /     \ /
 157 #                       ---     ---
 158 # Level 1            1 | B |   | C | 3
 159 #                       ---     ---
 160 #                        \       /
 161 #                         \     /
 162 #                           ---
 163 # Level 0                0 | A |
 164 #                           ---
 165 #
 166
 167 .sub main :main
 168     .local pmc A, B, C, D, E, F, O
 169     newclass O, "O"
 170     subclass F, O, "F"
 171     subclass E, O, "E"
 172     subclass D, O, "D"
 173
 174     subclass C, D, "C"
 175     addparent C, F
 176
 177     subclass B, E, "B"
 178     addparent B, D
 179
 180     subclass A, B, "A"
 181     addparent A, C
 182
 183     .local pmc mro, it, p
 184
 185     mro = A.'inspect'('all_parents')
 186     it = iter mro
 187     it = 0
 188 loop:
 189     unless it goto ex
 190     p = shift it
 191     $S0 = p
 192     print $S0
 193     print ' '
 194     goto loop
 195 ex:
 196     say 'G'
 197 .end
 198 CODE
 199 A B E C D F O G
 200 OUTPUT
 201
 202 pir_output_is( <<'CODE', <<'OUTPUT', "print mro 3" );
 203 #
 204 #    C
 205 #   / \
 206 #  /   \
 207 # A     B
 208 #  \   /
 209 #   \ /
 210 #    D
 211 #
 212 .sub main :main
 213     .local pmc A, B, C, D
 214     newclass C, "C"
 215     subclass A, C, "A"
 216     subclass B, C, "B"
 217     subclass D, A, "D"
 218     addparent D, B
 219
 220     .local pmc mro, it, p
 221
 222     mro = D.'inspect'('all_parents')
 223     it = iter mro
 224     it = 0
 225 loop:
 226     unless it goto ex
 227     p = shift it
 228     $S0 = p
 229     print $S0
 230     print ' '
 231     goto loop
 232 ex:
 233     say 'G'
 234 .end
 235 CODE
 236 D A B C G
 237 OUTPUT
 238
 239 pir_output_is( <<'CODE', <<'OUTPUT', "print mro 4" );
 240 #
 241 #        TestObject
 242 #            ^
 243 #            |
 244 #         LifeForm
 245 #          ^    ^
 246 #         /      \
 247 #    Sentient    BiPedal
 248 #       ^          ^
 249 #       |          |
 250 #  Intelligent  Humanoid
 251 #        ^        ^
 252 #         \      /
 253 #          Vulcan
 254 #
 255 # example taken from: L<http://gauss.gwydiondylan.org/books/drm/drm_50.html>
 256 #
 257 #  define class <sentient> (<life-form>) end class;
 258 #  define class <bipedal> (<life-form>) end class;
 259 #  define class <intelligent> (<sentient>) end class;
 260 #  define class <humanoid> (<bipedal>) end class;
 261 #  define class <vulcan> (<intelligent>, <humanoid>) end class;
 262 #
 263 .sub main :main
 264     .local pmc TestObject, LifeForm, Sentient, BiPedal, Intelligent, Humanoid, Vulcan
 265
 266     newclass TestObject, "TestObject"
 267
 268     subclass LifeForm, TestObject, "LifeForm"
 269
 270     subclass Sentient, LifeForm, "Sentient"
 271     subclass Intelligent, Sentient, "Intelligent"
 272
 273     subclass BiPedal, LifeForm, "BiPedal"
 274     subclass Humanoid, BiPedal, "Humanoid"
 275
 276     subclass Vulcan, Intelligent, "Vulcan"
 277     addparent Vulcan, Humanoid
 278
 279     .local pmc mro, it, p
 280
 281     mro = Vulcan.'inspect'('all_parents')
 282     it = iter mro
 283     it = 0
 284 loop:
 285     unless it goto ex
 286     p = shift it
 287     $S0 = p
 288     print $S0
 289     print ' '
 290     goto loop
 291 ex:
 292     say 'R'
 293 .end
 294 CODE
 295 Vulcan Intelligent Sentient Humanoid BiPedal LifeForm TestObject R
 296 OUTPUT
 297
 298 # ... now some tests which fail to compose the class
 299
 300 pir_error_output_like( <<'CODE', <<'OUTPUT', "mro error 1" );
 301 #
 302 # example take from: http://www.python.org/2.3/mro.html
 303 #
 304 # "Serious order disagreement" # From Guido
 305 # class O: pass
 306 # class X(O): pass
 307 # class Y(O): pass
 308 # class A(X,Y): pass
 309 # class B(Y,X): pass
 310 # try:
 311 #     class Z(A,B): pass # creates Z(A,B) in Python 2.2
 312 # except TypeError:
 313 #     pass # Z(A,B) cannot be created in Python 2.3
 314 #
 315 .sub main :main
 316     .local pmc O, X, Y, A, B, Z
 317
 318     newclass O, "O"
 319     subclass X, O, "X"
 320     subclass Y, O, "Y"
 321
 322     subclass A, X, "A"
 323     addparent A, Y
 324
 325     subclass B, Y, "B"
 326     addparent B, X
 327
 328     subclass Z, A, "Z"
 329     addparent Z, B
 330 .end
 331 CODE
 332 /ambiguous hierarchy/
 333 OUTPUT
 334
 335 # Local Variables:
 336 #   mode: cperl
 337 #   cperl-indent-level: 4
 338 #   fill-column: 100
 339 # End:
 340 # vim: expandtab shiftwidth=4: