← Back to branch summary

~rjwills/ensoft-sextant/packaging-fix

« back to all changes in this revision

Viewing changes to src/sextant/test_parser.py

  • Committer: Tarmac
  • Author(s): Ben Hutchings
  • Date: 2014-12-18 15:01:01 UTC
  • mfrom: (30.8.7 wierd-names-merge)
  • Revision ID: tarmac-20141218150101-pl5pkixozsekf86i
Function names are now cleaned up by a helper function, which removes __be_ prefixes if they are there (bi-endian builds) and converts names like <name>.<other stuff> to just <name>.

Tests extended to check that this works.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/sextant/test_parser.py
5
5
 
6
6
import objdump_parser as parser
7
7
 
 
8
OBJ_FILE = 'test_resources/parser_test'
8
9
DUMP_FILE = 'test_resources/parser_test.dump'
9
10
 
10
11
class TestSequence(unittest.TestCase):
12
13
        pass
13
14
    
14
15
    def add_function(self, dct, name, typ, source):
15
 
        self.assertFalse(name in dct, "duplicate function added: {} into {}".format(name, dct.keys()))
 
16
        self.assertFalse(name in dct, ("duplicate function added: {} into {}"
 
17
                                       .format(name, dct.keys())))
16
18
        dct[name] = (typ, source)
17
19
 
18
20
    def add_call(self, dct, caller, callee, is_internal):
26
28
        add_function = lambda n, t, s: self.add_function(functions, n, t, s)
27
29
        add_call = lambda a, b, i: self.add_call(calls, a, b, i)
28
30
 
29
 
        p = parser.Parser(path, sections=sections, ignore_ptrs=ignore_ptrs, 
 
31
        file_path, file_object = parser.run_objdump(OBJ_FILE, add_file_paths=True)
 
32
        p = parser.Parser(file_path=None, file_object=file_object, 
 
33
                          sections=sections, ignore_ptrs=ignore_ptrs, 
30
34
                          add_function=add_function, add_call=add_call)
31
35
        res = p.parse()
32
36
 
44
48
        res, funcs, calls = self.do_parse()
45
49
 
46
50
        known = 'parser_test.c'
 
51
        files = 'parser_file2.c'
47
52
        unknown = 'unknown'
48
53
 
49
 
        for name, typ, fle in zip(['normal', 'duplicates', 'wierd$name', 'printf', 'func_ptr_3'], 
50
 
                                  ['normal', 'normal', 'normal', 'stub', 'pointer'],
51
 
                                  [known, known, known, unknown, unknown]):
 
54
        for name, typ, fle in zip(['normal', 'duplicates', 'wierd$name', 'printf', 'func_ptr_3',
 
55
                                   'name', 'puts', 'inl_func'], 
 
56
                                  ['normal', 'normal', 'normal', 'stub', 'pointer', 
 
57
                                   'normal', 'stub', 'normal'],
 
58
                                  [known, known, files, unknown, unknown, 
 
59
                                   files, unknown, 'parser_header.h']):
52
60
            self.assertTrue(name in funcs, "'{}' not found in function dictionary".format(name))
53
61
            self.assertEquals(funcs[name][0], typ)
54
 
            self.assertTrue(funcs[name][1].endswith(fle))
 
62
            self.assertTrue(funcs[name][1].endswith(fle), "{}-{}".format(name, fle))
55
63
 
56
64
 
57
65
    def test_no_ptrs(self):
58
66
        # ensure that the ignore_ptrs flags is working
59
67
        res, funcs, calls = self.do_parse(ignore_ptrs=True)
60
68
 
61
 
        self.assertFalse('pointer' in funcs.values())
62
 
        self.assertEqual(len(calls['normal']), 2)
 
69
        self.assertFalse('pointer' in (typ for typ, src in funcs.values()))
 
70
        self.assertEqual(len(calls['normal']), 3)
63
71
 
64
72
 
65
73
    def test_calls(self):
68
76
        self.assertTrue(('normal', True) in calls['main'])
69
77
        self.assertTrue(('duplicates', True) in calls['main'])
70
78
 
71
 
        normal_calls = sorted(['wierd$name', 'printf', 'func_ptr_3'])
 
79
        self.assertTrue(('wierd$name', False) in calls['normal'])
 
80
        self.assertTrue(('name', True) in calls['wierd$name'])
 
81
        self.assertTrue(('puts', False) in calls['name'])
 
82
 
 
83
        normal_calls = sorted(['wierd$name', 'printf', 'inl_func', 'func_ptr_3'])
72
84
        self.assertEquals(sorted(zip(*calls['normal'])[0]), normal_calls)
73
85
 
74
86
        self.assertEquals(calls['duplicates'].count(('normal', True)), 1)
77
89
        self.assertTrue(('func_ptr_4', True) in calls['duplicates'])
78
90
        self.assertTrue(('func_ptr_5', True) in calls['duplicates'])
79
91
 
 
92
        # A function that should only be visible in the plt section
 
93
        self.assertFalse('__gmon_start__' in funcs)
 
94
 
80
95
    def test_sections(self):
81
96
        res, funcs, calls = self.do_parse(sections=['.plt', '.text'])
82
97
 
84
99
        self.assertTrue('@' not in ''.join(funcs.keys()), "check names are extracted correctly")
85
100
        self.assertTrue('__gmon_start__' in funcs, "see a function defined only in .plt")
86
101
 
87
 
    
 
102
    def test_clean_names(self):
 
103
        clean_id = parser.Parser.clean_id
 
104
        # Stripping of ios be prefixes
 
105
        self.assertEquals(clean_id('__be_test__be_name'), 'test__be_name')
 
106
        self.assertEquals(clean_id('_be_test_name'), '_be_test_name')
 
107
        self.assertEquals(clean_id('__betest_name'), '__betest_name')
 
108
 
 
109
        # Removing of extra bits at end
 
110
        self.assertEquals(clean_id('test_name.'), 'test_name')
 
111
        self.assertEquals(clean_id('test_name..0'), 'test_name')
 
112
 
 
113
 
88
114
if __name__ == '__main__':
89
115
    unittest.main()