AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_dis.py

   1 # Minimal tests for dis module
   2
   3 from test.test_support import run_unittest
   4 import unittest
   5 import sys
   6 import dis
   7 import StringIO
   8
   9
  10 def _f(a):
  11     print a
  12     return 1
  13
  14 dis_f = """\
  15  %-4d         0 LOAD_FAST                0 (a)
  16               3 PRINT_ITEM
  17               4 PRINT_NEWLINE
  18
  19  %-4d         5 LOAD_CONST               1 (1)
  20               8 RETURN_VALUE
  21 """%(_f.func_code.co_firstlineno + 1,
  22      _f.func_code.co_firstlineno + 2)
  23
  24
  25 def bug708901():
  26     for res in range(1,
  27                      10):
  28         pass
  29
  30 dis_bug708901 = """\
  31  %-4d         0 SETUP_LOOP              23 (to 26)
  32               3 LOAD_GLOBAL              0 (range)
  33               6 LOAD_CONST               1 (1)
  34
  35  %-4d         9 LOAD_CONST               2 (10)
  36              12 CALL_FUNCTION            2
  37              15 GET_ITER
  38         >>   16 FOR_ITER                 6 (to 25)
  39              19 STORE_FAST               0 (res)
  40
  41  %-4d        22 JUMP_ABSOLUTE           16
  42         >>   25 POP_BLOCK
  43         >>   26 LOAD_CONST               0 (None)
  44              29 RETURN_VALUE
  45 """%(bug708901.func_code.co_firstlineno + 1,
  46      bug708901.func_code.co_firstlineno + 2,
  47      bug708901.func_code.co_firstlineno + 3)
  48
  49
  50 def bug1333982(x=[]):
  51     assert 0, ([s for s in x] +
  52               1)
  53     pass
  54
  55 dis_bug1333982 = """\
  56  %-4d         0 LOAD_CONST               1 (0)
  57               3 POP_JUMP_IF_TRUE        38
  58               6 LOAD_GLOBAL              0 (AssertionError)
  59               9 BUILD_LIST               0
  60              12 LOAD_FAST                0 (x)
  61              15 GET_ITER
  62         >>   16 FOR_ITER                12 (to 31)
  63              19 STORE_FAST               1 (s)
  64              22 LOAD_FAST                1 (s)
  65              25 LIST_APPEND              2
  66              28 JUMP_ABSOLUTE           16
  67
  68  %-4d   >>   31 LOAD_CONST               2 (1)
  69              34 BINARY_ADD
  70              35 RAISE_VARARGS            2
  71
  72  %-4d   >>   38 LOAD_CONST               0 (None)
  73              41 RETURN_VALUE
  74 """%(bug1333982.func_code.co_firstlineno + 1,
  75      bug1333982.func_code.co_firstlineno + 2,
  76      bug1333982.func_code.co_firstlineno + 3)
  77
  78 _BIG_LINENO_FORMAT = """\
  79 %3d           0 LOAD_GLOBAL              0 (spam)
  80               3 POP_TOP
  81               4 LOAD_CONST               0 (None)
  82               7 RETURN_VALUE
  83 """
  84
  85 class DisTests(unittest.TestCase):
  86     def do_disassembly_test(self, func, expected):
  87         s = StringIO.StringIO()
  88         save_stdout = sys.stdout
  89         sys.stdout = s
  90         dis.dis(func)
  91         sys.stdout = save_stdout
  92         got = s.getvalue()
  93         # Trim trailing blanks (if any).
  94         lines = got.split('\n')
  95         lines = [line.rstrip() for line in lines]
  96         expected = expected.split("\n")
  97         import difflib
  98         if expected != lines:
  99             self.fail(
 100                 "events did not match expectation:\n" +
 101                 "\n".join(difflib.ndiff(expected,
 102                                         lines)))
 103
 104     def test_opmap(self):
 105         self.assertEqual(dis.opmap["STOP_CODE"], 0)
 106         self.assertIn(dis.opmap["LOAD_CONST"], dis.hasconst)
 107         self.assertIn(dis.opmap["STORE_NAME"], dis.hasname)
 108
 109     def test_opname(self):
 110         self.assertEqual(dis.opname[dis.opmap["LOAD_FAST"]], "LOAD_FAST")
 111
 112     def test_boundaries(self):
 113         self.assertEqual(dis.opmap["EXTENDED_ARG"], dis.EXTENDED_ARG)
 114         self.assertEqual(dis.opmap["STORE_NAME"], dis.HAVE_ARGUMENT)
 115
 116     def test_dis(self):
 117         self.do_disassembly_test(_f, dis_f)
 118
 119     def test_bug_708901(self):
 120         self.do_disassembly_test(bug708901, dis_bug708901)
 121
 122     def test_bug_1333982(self):
 123         # This one is checking bytecodes generated for an `assert` statement,
 124         # so fails if the tests are run with -O.  Skip this test then.
 125         if __debug__:
 126             self.do_disassembly_test(bug1333982, dis_bug1333982)
 127
 128     def test_big_linenos(self):
 129         def func(count):
 130             namespace = {}
 131             func = "def foo():\n " + "".join(["\n "] * count + ["spam\n"])
 132             exec func in namespace
 133             return namespace['foo']
 134
 135         # Test all small ranges
 136         for i in xrange(1, 300):
 137             expected = _BIG_LINENO_FORMAT % (i + 2)
 138             self.do_disassembly_test(func(i), expected)
 139
 140         # Test some larger ranges too
 141         for i in xrange(300, 5000, 10):
 142             expected = _BIG_LINENO_FORMAT % (i + 2)
 143             self.do_disassembly_test(func(i), expected)
 144
 145 def test_main():
 146     run_unittest(DisTests)
 147
 148
 149 if __name__ == "__main__":
 150     test_main()