Пример #1
0
    def test_build_dominator_tree_given_2_lvl(self):
        as_tree = ast.parse(
            ms("""\
             z = 2           # 0th block
             while a < 3:    # 1st block
                 if a < 2:   # 2nd block
                      z = 2  # 3rd block
                 b = 2       # Eth block
             c = 3           # Fth block
            """))
        cfg_real = Cfg(as_tree)
        dom_tree = DominatorTree(cfg_real)
        dom_tree.fill_dominates()
        dom_tree.build_tree()

        expected_block_list = build_blocks([5, 5, None], [4, 4, None],
                                           [3, 3, None], [6, 6, None],
                                           [2, 2, None], [1, 1, None],
                                           block_links={
                                               '5': [4],
                                               '4': [2, 3],
                                               '2': [1, 0],
                                               '1': [],
                                               '0': [],
                                               '3': []
                                           })

        self.assertBasicBlockListEqual(dom_tree.dominator_nodes,
                                       expected_block_list)
        pass
Пример #2
0
    def test_build_dominator_tree_given_1_lvl(self):
        as_tree = ast.parse(
            ms("""\
            a = 3           # 1st
            if a > 3:       #  |
                a = E       # 2nd
            else:           # 3rd
                z = F       #  |
            y = F           # Eth
            """))
        cfg_real = Cfg(as_tree)
        dom_tree = DominatorTree(cfg_real)
        dom_tree.fill_dominates()
        dom_tree.build_tree()

        expected_block_list = build_blocks([6, 6, None], [3, 3, None],
                                           [5, 5, None], [1, 2, None],
                                           block_links={
                                               '3': [1, 2, 0],
                                               '2': [],
                                               '1': [],
                                               '0': []
                                           })

        self.assertBasicBlockListEqual(dom_tree.dominator_nodes,
                                       expected_block_list)
Пример #3
0
    def assertCfgWithBasicBlocks(self, cfg_real, *args, block_links):
        cfg_expected = Cfg()

        block_list = build_blocks(*args, block_links=block_links)
        cfg_expected.block_list.extend(block_list)

        self.assertCfgEqual(cfg_real, cfg_expected)
Пример #4
0
    def test_build_while_body_given_body_if(self):
        as_tree = ast.parse(
            ms("""\
            while a < 3:    # 1st block
                if a < 2:   # 2nd block
                     z = 2  # 3rd block
                b = 2       # 4th block
            """))

        while_block = RawBasicBlock(1, 1, 'While')
        cfg_handler = Cfg()
        cfg_handler.as_tree = as_tree
        real_tail_list = cfg_handler.build_while_body(while_block)

        expected_block_list = build_blocks([1, 1, 'While'], [2, 2, 'If'],
                                           [3, 3, None], [4, 4, None],
                                           block_links={
                                               '0': [1],
                                               '1': [2, 3],
                                               '2': [3],
                                               '3': [0]
                                           })

        self.assertBasicBlockEqual(while_block, expected_block_list[0])
        self.assertBasicBlockEqual(real_tail_list[0], expected_block_list[0])
Пример #5
0
    def test_build_while_body_given_only_while(self):
        as_tree = ast.parse(ms("""\
            while a < 3:  # 1st block
                z = 4     # 2nd block
            """))

        while_block = RawBasicBlock(1, 1, 'While')
        cfg_handler = Cfg()
        cfg_handler.as_tree = as_tree
        real_tail_list = cfg_handler.build_while_body(while_block)

        expected_block_list = build_blocks([1, 1, 'While'], [2, 2, None],
                                                block_links={'0': [1], '1': [0]})

        self.assertBasicBlockEqual(while_block, expected_block_list[0])
        self.assertBasicBlockEqual(real_tail_list[0], expected_block_list[0])
Пример #6
0
    def test_walk_given_2_block(self):
        as_tree = ast.parse(ms("""\
            z = 2
            if z < 2:
                y = 3
            """))

        cfg_real = Cfg(as_tree)
        # cfg_real.walk_block(cfg_real.block_list[0])

        blocks_list = []
        for blocks in cfg_real.walk_block(cfg_real.block_list[0]):
            blocks_list.append(blocks)

        expected_block_list = build_blocks([3, 3, None], [1, 2, 'If'],
                                                block_links={'1': [0], '0':[]})

        self.assertBasicBlockListEqual(blocks_list, expected_block_list)