Merge c_parser.info into c_analyzer_common.info.

Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/test_info.py

@@ -4,7 +4,11 @@
 from ..util import PseudoStr, StrProxy, Object
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_analyzer_common.info import ID
+    from c_analyzer_common.info import (
+            UNKNOWN,
+            ID,
+            normalize_vartype, Variable
+            )
 
 
 class IDTests(unittest.TestCase):
@@ -192,3 +196,237 @@ def test_validate_bad_field(self):
                     id = id._replace(**{field: value})
 
                     id.validate()  # This does not fail.
+
+
+class NormalizeVartypeTests(unittest.TestCase):
+
+    def test_basic(self):
+        tests = [
+                (None, None),
+                ('', ''),
+                ('int', 'int'),
+                (PseudoStr('int'), 'int'),
+                (StrProxy('int'), 'int'),
+                ]
+        for vartype, expected in tests:
+            with self.subTest(vartype):
+                normalized = normalize_vartype(vartype)
+
+                self.assertEqual(normalized, expected)
+
+
+class VariableTests(unittest.TestCase):
+
+    VALID_ARGS = (
+            ('x/y/z/spam.c', 'func', 'eggs'),
+            'static',
+            'int',
+            )
+    VALID_KWARGS = dict(zip(Variable._fields, VALID_ARGS))
+    VALID_EXPECTED = VALID_ARGS
+
+    def test_init_typical_global(self):
+        for storage in ('static', 'extern', 'implicit'):
+            with self.subTest(storage):
+                static = Variable(
+                        id=ID(
+                            filename='x/y/z/spam.c',
+                            funcname=None,
+                            name='eggs',
+                            ),
+                        storage=storage,
+                        vartype='int',
+                        )
+
+                self.assertEqual(static, (
+                        ('x/y/z/spam.c', None, 'eggs'),
+                        storage,
+                        'int',
+                        ))
+
+    def test_init_typical_local(self):
+        for storage in ('static', 'local'):
+            with self.subTest(storage):
+                static = Variable(
+                        id=ID(
+                            filename='x/y/z/spam.c',
+                            funcname='func',
+                            name='eggs',
+                            ),
+                        storage=storage,
+                        vartype='int',
+                        )
+
+        self.assertEqual(static, (
+                ('x/y/z/spam.c', 'func', 'eggs'),
+                storage,
+                'int',
+                ))
+
+    def test_init_all_missing(self):
+        for value in ('', None):
+            with self.subTest(repr(value)):
+                static = Variable(
+                        id=value,
+                        storage=value,
+                        vartype=value,
+                        )
+
+                self.assertEqual(static, (
+                        None,
+                        None,
+                        None,
+                        ))
+
+    def test_init_all_coerced(self):
+        id = ID('x/y/z/spam.c', 'func', 'spam')
+        tests = [
+            ('str subclass',
+             dict(
+                 id=(
+                    PseudoStr('x/y/z/spam.c'),
+                    PseudoStr('func'),
+                    PseudoStr('spam'),
+                    ),
+                 storage=PseudoStr('static'),
+                 vartype=PseudoStr('int'),
+                 ),
+             (id,
+              'static',
+              'int',
+              )),
+            ('non-str 1',
+             dict(
+                 id=id,
+                 storage=Object(),
+                 vartype=Object(),
+                 ),
+             (id,
+              '<object>',
+              '<object>',
+              )),
+            ('non-str 2',
+             dict(
+                 id=id,
+                 storage=StrProxy('static'),
+                 vartype=StrProxy('variable'),
+                 ),
+             (id,
+              'static',
+              'variable',
+              )),
+            ('non-str',
+             dict(
+                 id=id,
+                 storage=('a', 'b', 'c'),
+                 vartype=('x', 'y', 'z'),
+                 ),
+             (id,
+              "('a', 'b', 'c')",
+              "('x', 'y', 'z')",
+              )),
+            ]
+        for summary, kwargs, expected in tests:
+            with self.subTest(summary):
+                static = Variable(**kwargs)
+
+                for field in Variable._fields:
+                    value = getattr(static, field)
+                    if field == 'id':
+                        self.assertIs(type(value), ID)
+                    else:
+                        self.assertIs(type(value), str)
+                self.assertEqual(tuple(static), expected)
+
+    def test_iterable(self):
+        static = Variable(**self.VALID_KWARGS)
+
+        id, storage, vartype = static
+
+        values = (id, storage, vartype)
+        for value, expected in zip(values, self.VALID_EXPECTED):
+            self.assertEqual(value, expected)
+
+    def test_fields(self):
+        static = Variable(('a', 'b', 'z'), 'x', 'y')
+
+        self.assertEqual(static.id, ('a', 'b', 'z'))
+        self.assertEqual(static.storage, 'x')
+        self.assertEqual(static.vartype, 'y')
+
+    def test___getattr__(self):
+        static = Variable(('a', 'b', 'z'), 'x', 'y')
+
+        self.assertEqual(static.filename, 'a')
+        self.assertEqual(static.funcname, 'b')
+        self.assertEqual(static.name, 'z')
+
+    def test_validate_typical(self):
+        validstorage = ('static', 'extern', 'implicit', 'local')
+        self.assertEqual(set(validstorage), set(Variable.STORAGE))
+
+        for storage in validstorage:
+            with self.subTest(storage):
+                static = Variable(
+                        id=ID(
+                            filename='x/y/z/spam.c',
+                            funcname='func',
+                            name='eggs',
+                            ),
+                        storage=storage,
+                        vartype='int',
+                        )
+
+                static.validate()  # This does not fail.
+
+    def test_validate_missing_field(self):
+        for field in Variable._fields:
+            with self.subTest(field):
+                static = Variable(**self.VALID_KWARGS)
+                static = static._replace(**{field: None})
+
+                with self.assertRaises(TypeError):
+                    static.validate()
+        for field in ('storage', 'vartype'):
+            with self.subTest(field):
+                static = Variable(**self.VALID_KWARGS)
+                static = static._replace(**{field: UNKNOWN})
+
+                with self.assertRaises(TypeError):
+                    static.validate()
+
+    def test_validate_bad_field(self):
+        badch = tuple(c for c in string.punctuation + string.digits)
+        notnames = (
+                '1a',
+                'a.b',
+                'a-b',
+                '&a',
+                'a++',
+                ) + badch
+        tests = [
+            ('id', ()),  # Any non-empty str is okay.
+            ('storage', ('external', 'global') + notnames),
+            ('vartype', ()),  # Any non-empty str is okay.
+            ]
+        seen = set()
+        for field, invalid in tests:
+            for value in invalid:
+                seen.add(value)
+                with self.subTest(f'{field}={value!r}'):
+                    static = Variable(**self.VALID_KWARGS)
+                    static = static._replace(**{field: value})
+
+                    with self.assertRaises(ValueError):
+                        static.validate()
+
+        for field, invalid in tests:
+            if field == 'id':
+                continue
+            valid = seen - set(invalid)
+            for value in valid:
+                with self.subTest(f'{field}={value!r}'):
+                    static = Variable(**self.VALID_KWARGS)
+                    static = static._replace(**{field: value})
+
+                    static.validate()  # This does not fail.

Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/test_known.py

@@ -4,8 +4,7 @@
 
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_parser.info import Variable
-    from c_analyzer_common.info import ID
+    from c_analyzer_common.info import ID, Variable
     from c_analyzer_common.known import from_file
 
 

Lib/test/test_tools/test_c_analyzer/test_c_analyzer_common/test_show.py

@@ -2,7 +2,7 @@
 
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_parser import info
+    from c_analyzer_common import info
     from c_analyzer_common.show import basic
 
 

Lib/test/test_tools/test_c_analyzer/test_c_globals/test___main__.py

@@ -3,9 +3,8 @@
 
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_analyzer_common import SOURCE_DIRS
+    from c_analyzer_common import SOURCE_DIRS, info
     from c_analyzer_common.known import DATA_FILE as KNOWN_FILE
-    from c_parser import info
     import c_globals as cg
     from c_globals.supported import IGNORED_FILE
     from c_globals.__main__ import cmd_check, cmd_show, parse_args, main

Lib/test/test_tools/test_c_analyzer/test_c_globals/test_find.py

@@ -2,7 +2,7 @@
 
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_parser import info
+    from c_analyzer_common import info
     from c_globals.find import globals_from_binary, globals
 
 

Lib/test/test_tools/test_c_analyzer/test_c_globals/test_supported.py

@@ -4,8 +4,7 @@
 
 from .. import tool_imports_for_tests
 with tool_imports_for_tests():
-    from c_analyzer_common.info import ID
-    from c_parser import info
+    from c_analyzer_common.info import ID, Variable
     from c_globals.supported import is_supported, ignored_from_file
 
 
@@ -14,8 +13,8 @@ class IsSupportedTests(unittest.TestCase):
     @unittest.expectedFailure
     def test_supported(self):
         statics = [
-                info.StaticVar('src1/spam.c', None, 'var1', 'const char *'),
-                info.StaticVar('src1/spam.c', None, 'var1', 'int'),
+                Variable('src1/spam.c', None, 'var1', 'const char *'),
+                Variable('src1/spam.c', None, 'var1', 'int'),
                 ]
         for static in statics:
             with self.subTest(static):
@@ -26,8 +25,8 @@ def test_supported(self):
     @unittest.expectedFailure
     def test_not_supported(self):
         statics = [
-                info.StaticVar('src1/spam.c', None, 'var1', 'PyObject *'),
-                info.StaticVar('src1/spam.c', None, 'var1', 'PyObject[10]'),
+                Variable('src1/spam.c', None, 'var1', 'PyObject *'),
+                Variable('src1/spam.c', None, 'var1', 'PyObject[10]'),
                 ]
         for static in statics:
             with self.subTest(static):