path: root/Lib/test/test_tools/test_c_analyzer/test_parser/test_declarations.py

import textwrap
import unittest

from .. import tool_imports_for_tests
with tool_imports_for_tests():
    from c_analyzer.parser.declarations import (
        iter_global_declarations, iter_local_statements,
        parse_func, _parse_var, parse_compound,
        iter_variables,
        )


class TestCaseBase(unittest.TestCase):

    maxDiff = None

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


class IterGlobalDeclarationsTests(TestCaseBase):

    def test_functions(self):
        tests = [
            (textwrap.dedent('''
                void func1() {
                    return;
                }
                '''),
             textwrap.dedent('''
                void func1() {
                return;
                }
                ''').strip(),
             ),
            (textwrap.dedent('''
                static unsigned int * _func1(
                    const char *arg1,
                    int *arg2
                    long long arg3
                    )
                {
                    return _do_something(arg1, arg2, arg3);
                }
                '''),
             textwrap.dedent('''
                static unsigned int * _func1( const char *arg1, int *arg2 long long arg3 ) {
                return _do_something(arg1, arg2, arg3);
                }
                ''').strip(),
             ),
            (textwrap.dedent('''
                static PyObject *
                _func1(const char *arg1, PyObject *arg2)
                {
                    static int initialized = 0;
                    if (!initialized) {
                        initialized = 1;
                        _init(arg1);
                    }

                    PyObject *result = _do_something(arg1, arg2);
                    Py_INCREF(result);
                    return result;
                }
                '''),
             textwrap.dedent('''
                static PyObject * _func1(const char *arg1, PyObject *arg2) {
                static int initialized = 0;
                if (!initialized) {
                initialized = 1;
                _init(arg1);
                }
                PyObject *result = _do_something(arg1, arg2);
                Py_INCREF(result);
                return result;
                }
                ''').strip(),
             ),
            ]
        for lines, expected in tests:
            body = textwrap.dedent(
                    expected.partition('{')[2].rpartition('}')[0]
                    ).strip()
            expected = (expected, body)
            with self.subTest(lines):
                lines = lines.splitlines()

                stmts = list(iter_global_declarations(lines))

                self.assertEqual(stmts, [expected])

    @unittest.expectedFailure
    def test_declarations(self):
        tests = [
            'int spam;',
            'long long spam;',
            'static const int const *spam;',
            'int spam;',
            'typedef int myint;',
            'typedef PyObject * (*unaryfunc)(PyObject *);',
            # typedef struct
            # inline struct
            # enum
            # inline enum
            ]
        for text in tests:
            expected = (text,
                        ' '.join(l.strip() for l in text.splitlines()))
            with self.subTest(lines):
                lines = lines.splitlines()

                stmts = list(iter_global_declarations(lines))

                self.assertEqual(stmts, [expected])

    @unittest.expectedFailure
    def test_declaration_multiple_vars(self):
        lines = ['static const int const *spam, *ham=NULL, eggs = 3;']

        stmts = list(iter_global_declarations(lines))

        self.assertEqual(stmts, [
            ('static const int const *spam;', None),
            ('static const int *ham=NULL;', None),
            ('static const int eggs = 3;', None),
            ])

    def test_mixed(self):
        lines = textwrap.dedent('''
           int spam;
           static const char const *eggs;

           PyObject * start(void) {
               static int initialized = 0;
               if (initialized) {
                   initialized = 1;
                   init();
               }
               return _start();
           }

           char* ham;

           static int stop(char *reason) {
               ham = reason;
               return _stop();
           }
           ''').splitlines()
        expected = [
            (textwrap.dedent('''
                PyObject * start(void) {
                static int initialized = 0;
                if (initialized) {
                initialized = 1;
                init();
                }
                return _start();
                }
                ''').strip(),
             textwrap.dedent('''
                static int initialized = 0;
                if (initialized) {
                initialized = 1;
                init();
                }
                return _start();
                ''').strip(),
             ),
            (textwrap.dedent('''
                static int stop(char *reason) {
                ham = reason;
                return _stop();
                }
                ''').strip(),
             textwrap.dedent('''
                ham = reason;
                return _stop();
                ''').strip(),
             ),
            ]

        stmts = list(iter_global_declarations(lines))

        self.assertEqual(stmts, expected)
        #self.assertEqual([stmt for stmt, _ in stmts],
        #                 [stmt for stmt, _ in expected])
        #self.assertEqual([body for _, body in stmts],
        #                 [body for _, body in expected])

    def test_no_statements(self):
        lines = []

        stmts = list(iter_global_declarations(lines))

        self.assertEqual(stmts, [])

    def test_bogus(self):
        tests = [
                (textwrap.dedent('''
                    int spam;
                    static const char const *eggs;

                    PyObject * start(void) {
                        static int initialized = 0;
                        if (initialized) {
                            initialized = 1;
                            init();
                        }
                        return _start();
                    }

                    char* ham;

                    static int _stop(void) {
                    // missing closing bracket

                    static int stop(char *reason) {
                        ham = reason;
                        return _stop();
                    }
                    '''),
                 [(textwrap.dedent('''
                    PyObject * start(void) {
                    static int initialized = 0;
                    if (initialized) {
                    initialized = 1;
                    init();
                    }
                    return _start();
                    }
                    ''').strip(),
                   textwrap.dedent('''
                    static int initialized = 0;
                    if (initialized) {
                    initialized = 1;
                    init();
                    }
                    return _start();
                    ''').strip(),
                   ),
                   # Neither "stop()" nor "_stop()" are here.
                  ],
                 ),
                ]
        for lines, expected in tests:
            with self.subTest(lines):
                lines = lines.splitlines()

                stmts = list(iter_global_declarations(lines))

                self.assertEqual(stmts, expected)
                #self.assertEqual([stmt for stmt, _ in stmts],
                #                 [stmt for stmt, _ in expected])
                #self.assertEqual([body for _, body in stmts],
                #                 [body for _, body in expected])

    def test_ignore_comments(self):
        tests = [
            ('// msg', None),
            ('// int stmt;', None),
            ('    // ...    ', None),
            ('// /*', None),
            ('/* int stmt; */', None),
            ("""
             /**
              * ...
              * int stmt;
              */
             """, None),
            ]
        for lines, expected in tests:
            with self.subTest(lines):
                lines = lines.splitlines()

                stmts = list(iter_global_declarations(lines))

                self.assertEqual(stmts, [expected] if expected else [])


class IterLocalStatementsTests(TestCaseBase):

    def test_vars(self):
        tests = [
            # POTS
            'int spam;',
            'unsigned int spam;',
            'char spam;',
            'float spam;',

            # typedefs
            'uint spam;',
            'MyType spam;',

            # complex
            'struct myspam spam;',
            'union choice spam;',
            # inline struct
            # inline union
            # enum?
            ]
        # pointers
        tests.extend([
            # POTS
            'int * spam;',
            'unsigned int * spam;',
            'char *spam;',
            'char const *spam = "spamspamspam...";',
            # typedefs
            'MyType *spam;',
            # complex
            'struct myspam *spam;',
            'union choice *spam;',
            # packed with details
            'const char const *spam;',
            # void pointer
            'void *data = NULL;',
            # function pointers
            'int (* func)(char *arg1);',
            'char * (* func)(void);',
            ])
        # storage class
        tests.extend([
            'static int spam;',
            'extern int spam;',
            'static unsigned int spam;',
            'static struct myspam spam;',
            ])
        # type qualifier
        tests.extend([
            'const int spam;',
            'const unsigned int spam;',
            'const struct myspam spam;',
            ])
        # combined
        tests.extend([
            'const char *spam = eggs;',
            'static const char const *spam = "spamspamspam...";',
            'extern const char const *spam;',
            'static void *data = NULL;',
            'static int (const * func)(char *arg1) = func1;',
            'static char * (* func)(void);',
            ])
        for line in tests:
            expected = line
            with self.subTest(line):
                stmts = list(iter_local_statements([line]))

                self.assertEqual(stmts, [(expected, None)])

    @unittest.expectedFailure
    def test_vars_multiline_var(self):
        lines = textwrap.dedent('''
            PyObject *
            spam
            = NULL;
            ''').splitlines()
        expected = 'PyObject * spam = NULL;'

        stmts = list(iter_local_statements(lines))

        self.assertEqual(stmts, [(expected, None)])

    @unittest.expectedFailure
    def test_declaration_multiple_vars(self):
        lines = ['static const int const *spam, *ham=NULL, ham2[]={1, 2, 3}, ham3[2]={1, 2}, eggs = 3;']

        stmts = list(iter_global_declarations(lines))

        self.assertEqual(stmts, [
            ('static const int const *spam;', None),
            ('static const int *ham=NULL;', None),
            ('static const int ham[]={1, 2, 3};', None),
            ('static const int ham[2]={1, 2};', None),
            ('static const int eggs = 3;', None),
            ])

    @unittest.expectedFailure
    def test_other_simple(self):
        raise NotImplementedError

    @unittest.expectedFailure
    def test_compound(self):
        raise NotImplementedError

    @unittest.expectedFailure
    def test_mixed(self):
        raise NotImplementedError

    def test_no_statements(self):
        lines = []

        stmts = list(iter_local_statements(lines))

        self.assertEqual(stmts, [])

    @unittest.expectedFailure
    def test_bogus(self):
        raise NotImplementedError

    def test_ignore_comments(self):
        tests = [
            ('// msg', None),
            ('// int stmt;', None),
            ('    // ...    ', None),
            ('// /*', None),
            ('/* int stmt; */', None),
            ("""
             /**
              * ...
              * int stmt;
              */
             """, None),
            # mixed with statements
            ('int stmt; // ...', ('int stmt;', None)),
            ( 'int stmt; /* ...  */', ('int stmt;', None)),
            ( '/* ...  */ int stmt;', ('int stmt;', None)),
            ]
        for lines, expected in tests:
            with self.subTest(lines):
                lines = lines.splitlines()

                stmts = list(iter_local_statements(lines))

                self.assertEqual(stmts, [expected] if expected else [])


class ParseFuncTests(TestCaseBase):

    def test_typical(self):
        tests = [
            ('PyObject *\nspam(char *a)\n{\nreturn _spam(a);\n}',
             'return _spam(a);',
             ('spam', 'PyObject * spam(char *a)'),
             ),
            ]
        for stmt, body, expected in tests:
            with self.subTest(stmt):
                name, signature = parse_func(stmt, body)

                self.assertEqual((name, signature), expected)


class ParseVarTests(TestCaseBase):

    def test_typical(self):
        tests = [
            # POTS
            ('int spam;', ('spam', 'int')),
            ('unsigned int spam;', ('spam', 'unsigned int')),
            ('char spam;', ('spam', 'char')),
            ('float spam;', ('spam', 'float')),

            # typedefs
            ('uint spam;', ('spam', 'uint')),
            ('MyType spam;', ('spam', 'MyType')),

            # complex
            ('struct myspam spam;', ('spam', 'struct myspam')),
            ('union choice spam;', ('spam', 'union choice')),
            # inline struct
            # inline union
            # enum?
            ]
        # pointers
        tests.extend([
            # POTS
            ('int * spam;', ('spam', 'int *')),
            ('unsigned int * spam;', ('spam', 'unsigned int *')),
            ('char *spam;', ('spam', 'char *')),
            ('char const *spam = "spamspamspam...";', ('spam', 'char const *')),
            # typedefs
            ('MyType *spam;', ('spam', 'MyType *')),
            # complex
            ('struct myspam *spam;', ('spam', 'struct myspam *')),
            ('union choice *spam;', ('spam', 'union choice *')),
            # packed with details
            ('const char const *spam;', ('spam', 'const char const *')),
            # void pointer
            ('void *data = NULL;', ('data', 'void *')),
            # function pointers
            ('int (* func)(char *);', ('func', 'int (*)(char *)')),
            ('char * (* func)(void);', ('func', 'char * (*)(void)')),
            ])
        # storage class
        tests.extend([
            ('static int spam;', ('spam', 'static int')),
            ('extern int spam;', ('spam', 'extern int')),
            ('static unsigned int spam;', ('spam', 'static unsigned int')),
            ('static struct myspam spam;', ('spam', 'static struct myspam')),
            ])
        # type qualifier
        tests.extend([
            ('const int spam;', ('spam', 'const int')),
            ('const unsigned int spam;', ('spam', 'const unsigned int')),
            ('const struct myspam spam;', ('spam', 'const struct myspam')),
            ])
        # combined
        tests.extend([
            ('const char *spam = eggs;', ('spam', 'const char *')),
            ('static const char const *spam = "spamspamspam...";',
             ('spam', 'static const char const *')),
            ('extern const char const *spam;',
             ('spam', 'extern const char const *')),
            ('static void *data = NULL;', ('data', 'static void *')),
            ('static int (const * func)(char *) = func1;',
             ('func', 'static int (const *)(char *)')),
            ('static char * (* func)(void);',
             ('func', 'static char * (*)(void)')),
            ])
        for stmt, expected in tests:
            with self.subTest(stmt):
                name, vartype = _parse_var(stmt)

                self.assertEqual((name, vartype), expected)


@unittest.skip('not finished')
class ParseCompoundTests(TestCaseBase):

    def test_typical(self):
        headers, bodies = parse_compound(stmt, blocks)
        ...


class IterVariablesTests(TestCaseBase):

    _return_iter_source_lines = None
    _return_iter_global = None
    _return_iter_local = None
    _return_parse_func = None
    _return_parse_var = None
    _return_parse_compound = None

    def _iter_source_lines(self, filename):
        self.calls.append(
                ('_iter_source_lines', (filename,)))
        return self._return_iter_source_lines.splitlines()

    def _iter_global(self, lines):
        self.calls.append(
                ('_iter_global', (lines,)))
        try:
            return self._return_iter_global.pop(0)
        except IndexError:
            return ('???', None)

    def _iter_local(self, lines):
        self.calls.append(
                ('_iter_local', (lines,)))
        try:
            return self._return_iter_local.pop(0)
        except IndexError:
            return ('???', None)

    def _parse_func(self, stmt, body):
        self.calls.append(
                ('_parse_func', (stmt, body)))
        try:
            return self._return_parse_func.pop(0)
        except IndexError:
            return ('???', '???')

    def _parse_var(self, lines):
        self.calls.append(
                ('_parse_var', (lines,)))
        try:
            return self._return_parse_var.pop(0)
        except IndexError:
            return ('???', '???')

    def _parse_compound(self, stmt, blocks):
        self.calls.append(
                ('_parse_compound', (stmt, blocks)))
        try:
            return self._return_parse_compound.pop(0)
        except IndexError:
            return (['???'], ['???'])

    def test_empty_file(self):
        self._return_iter_source_lines = ''
        self._return_iter_global = [
            [],
            ]
        self._return_parse_func = None
        self._return_parse_var = None
        self._return_parse_compound = None

        srcvars = list(iter_variables('spam.c',
                                      _iter_source_lines=self._iter_source_lines,
                                      _iter_global=self._iter_global,
                                      _iter_local=self._iter_local,
                                      _parse_func=self._parse_func,
                                      _parse_var=self._parse_var,
                                      _parse_compound=self._parse_compound,
                                      ))

        self.assertEqual(srcvars, [])
        self.assertEqual(self.calls, [
            ('_iter_source_lines', ('spam.c',)),
            ('_iter_global', ([],)),
            ])

    def test_no_statements(self):
        content = textwrap.dedent('''
        ...
        ''')
        self._return_iter_source_lines = content
        self._return_iter_global = [
            [],
            ]
        self._return_parse_func = None
        self._return_parse_var = None
        self._return_parse_compound = None

        srcvars = list(iter_variables('spam.c',
                                      _iter_source_lines=self._iter_source_lines,
                                      _iter_global=self._iter_global,
                                      _iter_local=self._iter_local,
                                      _parse_func=self._parse_func,
                                      _parse_var=self._parse_var,
                                      _parse_compound=self._parse_compound,
                                      ))

        self.assertEqual(srcvars, [])
        self.assertEqual(self.calls, [
            ('_iter_source_lines', ('spam.c',)),
            ('_iter_global', (content.splitlines(),)),
            ])

    def test_typical(self):
        content = textwrap.dedent('''
        ...
        ''')
        self._return_iter_source_lines = content
        self._return_iter_global = [
            [('<lines 1>', None),  # var1
             ('<lines 2>', None),  # non-var
             ('<lines 3>', None),  # var2
             ('<lines 4>', '<body 1>'),  # func1
             ('<lines 9>', None),  # var4
             ],
            ]
        self._return_iter_local = [
            # func1
            [('<lines 5>', None),  # var3
             ('<lines 6>', [('<header 1>', '<block 1>')]),  # if
             ('<lines 8>', None),  # non-var
             ],
            # if
            [('<lines 7>', None),  # var2 ("collision" with global var)
             ],
            ]
        self._return_parse_func = [
            ('func1', '<sig 1>'),
            ]
        self._return_parse_var = [
            ('var1', '<vartype 1>'),
            (None, None),
            ('var2', '<vartype 2>'),
            ('var3', '<vartype 3>'),
            ('var2', '<vartype 2b>'),
            ('var4', '<vartype 4>'),
            (None, None),
            (None, None),
            (None, None),
            ('var5', '<vartype 5>'),
            ]
        self._return_parse_compound = [
            ([[
                'if (',
                '<simple>',
                ')',
                ],
              ],
             ['<block 1>']),
            ]

        srcvars = list(iter_variables('spam.c',
                                      _iter_source_lines=self._iter_source_lines,
                                      _iter_global=self._iter_global,
                                      _iter_local=self._iter_local,
                                      _parse_func=self._parse_func,
                                      _parse_var=self._parse_var,
                                      _parse_compound=self._parse_compound,
                                      ))

        self.assertEqual(srcvars, [
            (None, 'var1', '<vartype 1>'),
            (None, 'var2', '<vartype 2>'),
            ('func1', 'var3', '<vartype 3>'),
            ('func1', 'var2', '<vartype 2b>'),
            ('func1', 'var4', '<vartype 4>'),
            (None, 'var5', '<vartype 5>'),
            ])
        self.assertEqual(self.calls, [
            ('_iter_source_lines', ('spam.c',)),
            ('_iter_global', (content.splitlines(),)),
            ('_parse_var', ('<lines 1>',)),
            ('_parse_var', ('<lines 2>',)),
            ('_parse_var', ('<lines 3>',)),
            ('_parse_func', ('<lines 4>', '<body 1>')),
            ('_iter_local', (['<body 1>'],)),
            ('_parse_var', ('<lines 5>',)),
            ('_parse_compound', ('<lines 6>', [('<header 1>', '<block 1>')])),
            ('_parse_var', ('if (',)),
            ('_parse_var', ('<simple>',)),
            ('_parse_var', (')',)),
            ('_parse_var', ('<lines 8>',)),
            ('_iter_local', (['<block 1>'],)),
            ('_parse_var', ('<lines 7>',)),
            ('_parse_var', ('<lines 9>',)),
            ])

    def test_no_locals(self):
        content = textwrap.dedent('''
        ...
        ''')
        self._return_iter_source_lines = content
        self._return_iter_global = [
            [('<lines 1>', None),  # var1
             ('<lines 2>', None),  # non-var
             ('<lines 3>', None),  # var2
             ('<lines 4>', '<body 1>'),  # func1
             ],
            ]
        self._return_iter_local = [
            # func1
            [('<lines 5>', None),  # non-var
             ('<lines 6>', [('<header 1>', '<block 1>')]),  # if
             ('<lines 8>', None),  # non-var
             ],
            # if
            [('<lines 7>', None),  # non-var
             ],
            ]
        self._return_parse_func = [
            ('func1', '<sig 1>'),
            ]
        self._return_parse_var = [
            ('var1', '<vartype 1>'),
            (None, None),
            ('var2', '<vartype 2>'),
            (None, None),
            (None, None),
            (None, None),
            (None, None),
            (None, None),
            (None, None),
            ]
        self._return_parse_compound = [
            ([[
                'if (',
                '<simple>',
                ')',
                ],
              ],
             ['<block 1>']),
            ]

        srcvars = list(iter_variables('spam.c',
                                      _iter_source_lines=self._iter_source_lines,
                                      _iter_global=self._iter_global,
                                      _iter_local=self._iter_local,
                                      _parse_func=self._parse_func,
                                      _parse_var=self._parse_var,
                                      _parse_compound=self._parse_compound,
                                      ))

        self.assertEqual(srcvars, [
            (None, 'var1', '<vartype 1>'),
            (None, 'var2', '<vartype 2>'),
            ])
        self.assertEqual(self.calls, [
            ('_iter_source_lines', ('spam.c',)),
            ('_iter_global', (content.splitlines(),)),
            ('_parse_var', ('<lines 1>',)),
            ('_parse_var', ('<lines 2>',)),
            ('_parse_var', ('<lines 3>',)),
            ('_parse_func', ('<lines 4>', '<body 1>')),
            ('_iter_local', (['<body 1>'],)),
            ('_parse_var', ('<lines 5>',)),
            ('_parse_compound', ('<lines 6>', [('<header 1>', '<block 1>')])),
            ('_parse_var', ('if (',)),
            ('_parse_var', ('<simple>',)),
            ('_parse_var', (')',)),
            ('_parse_var', ('<lines 8>',)),
            ('_iter_local', (['<block 1>'],)),
            ('_parse_var', ('<lines 7>',)),
            ])