home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_dis.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  4.7 KB  |  157 lines
  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 JUMP_IF_TRUE            41 (to 47)
  58.               6 POP_TOP
  59.               7 LOAD_GLOBAL              0 (AssertionError)
  60.              10 BUILD_LIST               0
  61.              13 DUP_TOP
  62.              14 STORE_FAST               1 (_[1])
  63.              17 LOAD_FAST                0 (x)
  64.              20 GET_ITER
  65.         >>   21 FOR_ITER                13 (to 37)
  66.              24 STORE_FAST               2 (s)
  67.              27 LOAD_FAST                1 (_[1])
  68.              30 LOAD_FAST                2 (s)
  69.              33 LIST_APPEND
  70.              34 JUMP_ABSOLUTE           21
  71.         >>   37 DELETE_FAST              1 (_[1])
  72.  
  73.  %-4d        40 LOAD_CONST               2 (1)
  74.              43 BINARY_ADD
  75.              44 RAISE_VARARGS            2
  76.         >>   47 POP_TOP
  77.  
  78.  %-4d        48 LOAD_CONST               0 (None)
  79.              51 RETURN_VALUE
  80. """%(bug1333982.func_code.co_firstlineno + 1,
  81.      bug1333982.func_code.co_firstlineno + 2,
  82.      bug1333982.func_code.co_firstlineno + 3)
  83.  
  84. _BIG_LINENO_FORMAT = """\
  85. %3d           0 LOAD_GLOBAL              0 (spam)
  86.               3 POP_TOP
  87.               4 LOAD_CONST               0 (None)
  88.               7 RETURN_VALUE
  89. """
  90.  
  91. class DisTests(unittest.TestCase):
  92.     def do_disassembly_test(self, func, expected):
  93.         s = StringIO.StringIO()
  94.         save_stdout = sys.stdout
  95.         sys.stdout = s
  96.         dis.dis(func)
  97.         sys.stdout = save_stdout
  98.         got = s.getvalue()
  99.         # Trim trailing blanks (if any).
  100.         lines = got.split('\n')
  101.         lines = [line.rstrip() for line in lines]
  102.         expected = expected.split("\n")
  103.         import difflib
  104.         if expected != lines:
  105.             self.fail(
  106.                 "events did not match expectation:\n" +
  107.                 "\n".join(difflib.ndiff(expected,
  108.                                         lines)))
  109.  
  110.     def test_opmap(self):
  111.         self.assertEqual(dis.opmap["STOP_CODE"], 0)
  112.         self.assertEqual(dis.opmap["LOAD_CONST"] in dis.hasconst, True)
  113.         self.assertEqual(dis.opmap["STORE_NAME"] in dis.hasname, True)
  114.  
  115.     def test_opname(self):
  116.         self.assertEqual(dis.opname[dis.opmap["LOAD_FAST"]], "LOAD_FAST")
  117.  
  118.     def test_boundaries(self):
  119.         self.assertEqual(dis.opmap["EXTENDED_ARG"], dis.EXTENDED_ARG)
  120.         self.assertEqual(dis.opmap["STORE_NAME"], dis.HAVE_ARGUMENT)
  121.  
  122.     def test_dis(self):
  123.         self.do_disassembly_test(_f, dis_f)
  124.  
  125.     def test_bug_708901(self):
  126.         self.do_disassembly_test(bug708901, dis_bug708901)
  127.  
  128.     def test_bug_1333982(self):
  129.         # This one is checking bytecodes generated for an `assert` statement,
  130.         # so fails if the tests are run with -O.  Skip this test then.
  131.         if __debug__:
  132.             self.do_disassembly_test(bug1333982, dis_bug1333982)
  133.  
  134.     def test_big_linenos(self):
  135.         def func(count):
  136.             namespace = {}
  137.             func = "def foo():\n " + "".join(["\n "] * count + ["spam\n"])
  138.             exec func in namespace
  139.             return namespace['foo']
  140.  
  141.         # Test all small ranges
  142.         for i in xrange(1, 300):
  143.             expected = _BIG_LINENO_FORMAT % (i + 2)
  144.             self.do_disassembly_test(func(i), expected)
  145.  
  146.         # Test some larger ranges too
  147.         for i in xrange(300, 5000, 10):
  148.             expected = _BIG_LINENO_FORMAT % (i + 2)
  149.             self.do_disassembly_test(func(i), expected)
  150.  
  151. def test_main():
  152.     run_unittest(DisTests)
  153.  
  154.  
  155. if __name__ == "__main__":
  156.     test_main()
  157.