1  import dis
       2  from test.support.import_helper import import_module
       3  import unittest
       4  import opcode
       5  
       6  _opcode = import_module("_opcode")
       7  from _opcode import stack_effect
       8  
       9  
      10  class ESC[4;38;5;81mOpcodeTests(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
      11  
      12      def test_stack_effect(self):
      13          self.assertEqual(stack_effect(dis.opmap['POP_TOP']), -1)
      14          self.assertEqual(stack_effect(dis.opmap['BUILD_SLICE'], 0), -1)
      15          self.assertEqual(stack_effect(dis.opmap['BUILD_SLICE'], 1), -1)
      16          self.assertEqual(stack_effect(dis.opmap['BUILD_SLICE'], 3), -2)
      17          self.assertRaises(ValueError, stack_effect, 30000)
      18          self.assertRaises(ValueError, stack_effect, dis.opmap['BUILD_SLICE'])
      19          self.assertRaises(ValueError, stack_effect, dis.opmap['POP_TOP'], 0)
      20          # All defined opcodes
      21          has_arg = dis.hasarg
      22          for name, code in filter(lambda item: item[0] not in dis.deoptmap, dis.opmap.items()):
      23              if code >= opcode.MIN_INSTRUMENTED_OPCODE:
      24                  continue
      25              with self.subTest(opname=name):
      26                  if code not in has_arg:
      27                      stack_effect(code)
      28                      self.assertRaises(ValueError, stack_effect, code, 0)
      29                  else:
      30                      stack_effect(code, 0)
      31                      self.assertRaises(ValueError, stack_effect, code)
      32          # All not defined opcodes
      33          for code in set(range(256)) - set(dis.opmap.values()):
      34              with self.subTest(opcode=code):
      35                  self.assertRaises(ValueError, stack_effect, code)
      36                  self.assertRaises(ValueError, stack_effect, code, 0)
      37  
      38      def test_stack_effect_jump(self):
      39          FOR_ITER = dis.opmap['FOR_ITER']
      40          self.assertEqual(stack_effect(FOR_ITER, 0), 1)
      41          self.assertEqual(stack_effect(FOR_ITER, 0, jump=True), 1)
      42          self.assertEqual(stack_effect(FOR_ITER, 0, jump=False), 1)
      43          JUMP_FORWARD = dis.opmap['JUMP_FORWARD']
      44          self.assertEqual(stack_effect(JUMP_FORWARD, 0), 0)
      45          self.assertEqual(stack_effect(JUMP_FORWARD, 0, jump=True), 0)
      46          self.assertEqual(stack_effect(JUMP_FORWARD, 0, jump=False), 0)
      47          # All defined opcodes
      48          has_arg = dis.hasarg
      49          has_exc = dis.hasexc
      50          has_jump = dis.hasjabs + dis.hasjrel
      51          for name, code in filter(lambda item: item[0] not in dis.deoptmap, dis.opmap.items()):
      52              if code >= opcode.MIN_INSTRUMENTED_OPCODE:
      53                  continue
      54              with self.subTest(opname=name):
      55                  if code not in has_arg:
      56                      common = stack_effect(code)
      57                      jump = stack_effect(code, jump=True)
      58                      nojump = stack_effect(code, jump=False)
      59                  else:
      60                      common = stack_effect(code, 0)
      61                      jump = stack_effect(code, 0, jump=True)
      62                      nojump = stack_effect(code, 0, jump=False)
      63                  if code in has_jump or code in has_exc:
      64                      self.assertEqual(common, max(jump, nojump))
      65                  else:
      66                      self.assertEqual(jump, common)
      67                      self.assertEqual(nojump, common)
      68  
      69  
      70  class ESC[4;38;5;81mSpecializationStatsTests(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
      71      def test_specialization_stats(self):
      72          stat_names = ["success", "failure", "hit", "deferred", "miss", "deopt"]
      73          specialized_opcodes = [
      74              op.lower()
      75              for op in opcode._specializations
      76              if opcode._inline_cache_entries[opcode.opmap[op]]
      77          ]
      78          self.assertIn('load_attr', specialized_opcodes)
      79          self.assertIn('binary_subscr', specialized_opcodes)
      80  
      81          stats = _opcode.get_specialization_stats()
      82          if stats is not None:
      83              self.assertIsInstance(stats, dict)
      84              self.assertCountEqual(stats.keys(), specialized_opcodes)
      85              self.assertCountEqual(
      86                  stats['load_attr'].keys(),
      87                  stat_names + ['failure_kinds'])
      88              for sn in stat_names:
      89                  self.assertIsInstance(stats['load_attr'][sn], int)
      90              self.assertIsInstance(
      91                  stats['load_attr']['failure_kinds'],
      92                  tuple)
      93              for v in stats['load_attr']['failure_kinds']:
      94                  self.assertIsInstance(v, int)
      95  
      96  
      97  if __name__ == "__main__":
      98      unittest.main()