summaryrefslogtreecommitdiffstats
path: root/Lib/test/test_tools/test_c_analyzer/test_variables/test_known.py
blob: 49ff45c6d1b2cf0e77c637380daed6e8b627c8c3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
import re
import textwrap
import unittest

from .. import tool_imports_for_tests
with tool_imports_for_tests():
    from c_analyzer.common.info import ID
    from c_analyzer.variables.info import Variable
    from c_analyzer.variables.known import (
            read_file,
            from_file,
            )

class _BaseTests(unittest.TestCase):

    maxDiff = None

    @property
    def calls(self):
        try:
            return self._calls
        except AttributeError:
            self._calls = []
            return self._calls


class ReadFileTests(_BaseTests):

    _return_read_tsv = ()

    def _read_tsv(self, *args):
        self.calls.append(('_read_tsv', args))
        return self._return_read_tsv

    def test_typical(self):
        lines = textwrap.dedent('''
            filename    funcname        name    kind    declaration
            file1.c     -       var1    variable        static int
            file1.c     func1   local1  variable        static int
            file1.c     -       var2    variable        int
            file1.c     func2   local2  variable        char *
            file2.c     -       var1    variable        char *
            ''').strip().splitlines()
        lines = [re.sub(r'\s+', '\t', line, 4) for line in lines]
        self._return_read_tsv = [tuple(v.strip() for v in line.split('\t'))
                                 for line in lines[1:]]

        known = list(read_file('known.tsv', _read_tsv=self._read_tsv))

        self.assertEqual(known, [
            ('variable', ID('file1.c', '', 'var1'), 'static int'),
            ('variable', ID('file1.c', 'func1', 'local1'), 'static int'),
            ('variable', ID('file1.c', '', 'var2'), 'int'),
            ('variable', ID('file1.c', 'func2', 'local2'), 'char *'),
            ('variable', ID('file2.c', '', 'var1'), 'char *'),
            ])
        self.assertEqual(self.calls, [
            ('_read_tsv',
             ('known.tsv', 'filename\tfuncname\tname\tkind\tdeclaration')),
            ])

    def test_empty(self):
        self._return_read_tsv = []

        known = list(read_file('known.tsv', _read_tsv=self._read_tsv))

        self.assertEqual(known, [])
        self.assertEqual(self.calls, [
            ('_read_tsv', ('known.tsv', 'filename\tfuncname\tname\tkind\tdeclaration')),
            ])


class FromFileTests(_BaseTests):

    _return_read_file = ()
    _return_handle_var = ()

    def _read_file(self, infile):
        self.calls.append(('_read_file', (infile,)))
        return iter(self._return_read_file)

    def _handle_var(self, varid, decl):
        self.calls.append(('_handle_var', (varid, decl)))
        var = self._return_handle_var.pop(0)
        return var

    def test_typical(self):
        expected = [
            Variable.from_parts('file1.c', '', 'var1', 'static int'),
            Variable.from_parts('file1.c', 'func1', 'local1', 'static int'),
            Variable.from_parts('file1.c', '', 'var2', 'int'),
            Variable.from_parts('file1.c', 'func2', 'local2', 'char *'),
            Variable.from_parts('file2.c', '', 'var1', 'char *'),
            ]
        self._return_read_file = [('variable', v.id, v.vartype)
                                  for v in expected]
#            ('variable', ID('file1.c', '', 'var1'), 'static int'),
#            ('variable', ID('file1.c', 'func1', 'local1'), 'static int'),
#            ('variable', ID('file1.c', '', 'var2'), 'int'),
#            ('variable', ID('file1.c', 'func2', 'local2'), 'char *'),
#            ('variable', ID('file2.c', '', 'var1'), 'char *'),
#            ]
        self._return_handle_var = list(expected)  # a copy

        known = from_file('known.tsv',
                          handle_var=self._handle_var,
                          _read_file=self._read_file,
                          )

        self.assertEqual(known, {
            'variables': {v.id: v for v in expected},
            })
#                Variable.from_parts('file1.c', '', 'var1', 'static int'),
#                Variable.from_parts('file1.c', 'func1', 'local1', 'static int'),
#                Variable.from_parts('file1.c', '', 'var2', 'int'),
#                Variable.from_parts('file1.c', 'func2', 'local2', 'char *'),
#                Variable.from_parts('file2.c', '', 'var1', 'char *'),
#                ]},
#            })
        self.assertEqual(self.calls, [
            ('_read_file', ('known.tsv',)),
            *[('_handle_var', (v.id, v.vartype))
              for v in expected],
            ])

    def test_empty(self):
        self._return_read_file = []

        known = from_file('known.tsv',
                          handle_var=self._handle_var,
                          _read_file=self._read_file,
                          )

        self.assertEqual(known, {
            'variables': {},
            })
        self.assertEqual(self.calls, [
            ('_read_file', ('known.tsv',)),
            ])