1 """This module includes tests of the code object representation.

     2 

     3 >>> def f(x):

     4 ...     def g(y):

     5 ...         return x + y

     6 ...     return g

     7 ...

     8 

     9 >>> dump(f.func_code)

    10 name: f

    11 argcount: 1

    12 names: ()

    13 varnames: ('x', 'g')

    14 cellvars: ('x',)

    15 freevars: ()

    16 nlocals: 2

    17 flags: 3

    18 consts: ('None', '<code object g>')

    19 

    20 >>> dump(f(4).func_code)

    21 name: g

    22 argcount: 1

    23 names: ()

    24 varnames: ('y',)

    25 cellvars: ()

    26 freevars: ('x',)

    27 nlocals: 1

    28 flags: 19

    29 consts: ('None',)

    30 

    31 >>> def h(x, y):

    32 ...     a = x + y

    33 ...     b = x - y

    34 ...     c = a * b

    35 ...     return c

    36 ...

    37 >>> dump(h.func_code)

    38 name: h

    39 argcount: 2

    40 names: ()

    41 varnames: ('x', 'y', 'a', 'b', 'c')

    42 cellvars: ()

    43 freevars: ()

    44 nlocals: 5

    45 flags: 67

    46 consts: ('None',)

    47 

    48 >>> def attrs(obj):

    49 ...     print obj.attr1

    50 ...     print obj.attr2

    51 ...     print obj.attr3

    52 

    53 >>> dump(attrs.func_code)

    54 name: attrs

    55 argcount: 1

    56 names: ('attr1', 'attr2', 'attr3')

    57 varnames: ('obj',)

    58 cellvars: ()

    59 freevars: ()

    60 nlocals: 1

    61 flags: 67

    62 consts: ('None',)

    63 

    64 >>> def optimize_away():

    65 ...     'doc string'

    66 ...     'not a docstring'

    67 ...     53

    68 ...     53L

    69 

    70 >>> dump(optimize_away.func_code)

    71 name: optimize_away

    72 argcount: 0

    73 names: ()

    74 varnames: ()

    75 cellvars: ()

    76 freevars: ()

    77 nlocals: 0

    78 flags: 67

    79 consts: ("'doc string'", 'None')

    80 

    81 """

    82 

    83 def consts(t):

    84     """Yield a doctest-safe sequence of object reprs."""

    85     for elt in t:

    86         r = repr(elt)

    87         if r.startswith("<code object"):

    88             yield "<code object %s>" % elt.co_name

    89         else:

    90             yield r

    91 

    92 def dump(co):

    93     """Print out a text representation of a code object."""

    94     for attr in ["name", "argcount", "names", "varnames", "cellvars",

    95                  "freevars", "nlocals", "flags"]:

    96         print "%s: %s" % (attr, getattr(co, "co_" + attr))

    97     print "consts:", tuple(consts(co.co_consts))

    98 

    99 def test_main(verbose=None):

   100     from test.test_support import run_doctest

   101     from test import test_code

   102     run_doctest(test_code, verbose)

   103 

   104 

   105 if __name__ == '__main__':

   106     test_main()