Imported Upstream version 6.10.0.49

Former-commit-id: 1d6753294b2993e1fbf92de9366bb9544db4189b

external/llvm-project/clang/bindings/python/tests/cindex/INPUTS/compile_commands.json

@@ -0,0 +1,17 @@
+[
+{
+  "directory": "/home/john.doe/MyProject",
+  "command": "clang++  -o project.o -c /home/john.doe/MyProject/project.cpp",
+  "file": "/home/john.doe/MyProject/project.cpp"
+},
+{
+  "directory": "/home/john.doe/MyProjectA",
+  "command": "clang++ -o project2.o -c /home/john.doe/MyProject/project2.cpp",
+  "file": "/home/john.doe/MyProject/project2.cpp"
+},
+{
+  "directory": "/home/john.doe/MyProjectB",
+  "command": "clang++  -DFEATURE=1 -o project2-feature.o -c /home/john.doe/MyProject/project2.cpp",
+  "file": "/home/john.doe/MyProject/project2.cpp"
+}
+]

external/llvm-project/clang/bindings/python/tests/cindex/INPUTS/header1.h

@@ -0,0 +1,6 @@
+#ifndef HEADER1
+#define HEADER1
+
+#include "header3.h"
+
+#endif

external/llvm-project/clang/bindings/python/tests/cindex/INPUTS/header2.h

@@ -0,0 +1,6 @@
+#ifndef HEADER2
+#define HEADER2
+
+#include "header3.h"
+
+#endif

external/llvm-project/clang/bindings/python/tests/cindex/INPUTS/header3.h

@@ -0,0 +1,3 @@
+// Not a guarded header!
+
+void f();

external/llvm-project/clang/bindings/python/tests/cindex/INPUTS/hello.cpp

@@ -0,0 +1,6 @@
+#include "stdio.h"
+
+int main(int argc, char* argv[]) {
+    printf("hello world\n");
+    return 0;
+}

external/llvm-project/clang/bindings/python/tests/cindex/INPUTS/include.cpp

@@ -0,0 +1,5 @@
+#include "header1.h"
+#include "header2.h"
+#include "header1.h"
+
+int main() { }

external/llvm-project/clang/bindings/python/tests/cindex/INPUTS/parse_arguments.c

@@ -0,0 +1,2 @@
+int DECL_ONE = 1;
+int DECL_TWO = 2;

external/llvm-project/clang/bindings/python/tests/cindex/test_access_specifiers.py

@@ -0,0 +1,37 @@
+
+from clang.cindex import AccessSpecifier
+from clang.cindex import Cursor
+from clang.cindex import TranslationUnit
+
+from .util import get_cursor
+from .util import get_tu
+
+import unittest
+
+
+class TestAccessSpecifiers(unittest.TestCase):
+    def test_access_specifiers(self):
+        """Ensure that C++ access specifiers are available on cursors"""
+
+        tu = get_tu("""
+class test_class {
+public:
+  void public_member_function();
+protected:
+  void protected_member_function();
+private:
+  void private_member_function();
+};
+""", lang = 'cpp')
+
+        test_class = get_cursor(tu, "test_class")
+        self.assertEqual(test_class.access_specifier, AccessSpecifier.INVALID)
+
+        public = get_cursor(tu.cursor, "public_member_function")
+        self.assertEqual(public.access_specifier, AccessSpecifier.PUBLIC)
+
+        protected = get_cursor(tu.cursor, "protected_member_function")
+        self.assertEqual(protected.access_specifier, AccessSpecifier.PROTECTED)
+
+        private = get_cursor(tu.cursor, "private_member_function")
+        self.assertEqual(private.access_specifier, AccessSpecifier.PRIVATE)

external/llvm-project/clang/bindings/python/tests/cindex/test_cdb.py

@@ -0,0 +1,119 @@
+from clang.cindex import CompilationDatabase
+from clang.cindex import CompilationDatabaseError
+from clang.cindex import CompileCommands
+from clang.cindex import CompileCommand
+import os
+import gc
+import unittest
+
+
+kInputsDir = os.path.join(os.path.dirname(__file__), 'INPUTS')
+
+
+class TestCDB(unittest.TestCase):
+    def test_create_fail(self):
+        """Check we fail loading a database with an assertion"""
+        path = os.path.dirname(__file__)
+        with self.assertRaises(CompilationDatabaseError) as cm:
+            cdb = CompilationDatabase.fromDirectory(path)
+        e = cm.exception
+        self.assertEqual(e.cdb_error,
+            CompilationDatabaseError.ERROR_CANNOTLOADDATABASE)
+
+    def test_create(self):
+        """Check we can load a compilation database"""
+        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+
+    def test_lookup_fail(self):
+        """Check file lookup failure"""
+        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        self.assertIsNone(cdb.getCompileCommands('file_do_not_exist.cpp'))
+
+    def test_lookup_succeed(self):
+        """Check we get some results if the file exists in the db"""
+        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project.cpp')
+        self.assertNotEqual(len(cmds), 0)
+
+    def test_all_compilecommand(self):
+        """Check we get all results from the db"""
+        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cmds = cdb.getAllCompileCommands()
+        self.assertEqual(len(cmds), 3)
+        expected = [
+            { 'wd': '/home/john.doe/MyProject',
+              'file': '/home/john.doe/MyProject/project.cpp',
+              'line': ['clang++', '-o', 'project.o', '-c',
+                       '/home/john.doe/MyProject/project.cpp']},
+            { 'wd': '/home/john.doe/MyProjectA',
+              'file': '/home/john.doe/MyProject/project2.cpp',
+              'line': ['clang++', '-o', 'project2.o', '-c',
+                       '/home/john.doe/MyProject/project2.cpp']},
+            { 'wd': '/home/john.doe/MyProjectB',
+              'file': '/home/john.doe/MyProject/project2.cpp',
+              'line': ['clang++', '-DFEATURE=1', '-o', 'project2-feature.o', '-c',
+                       '/home/john.doe/MyProject/project2.cpp']},
+
+            ]
+        for i in range(len(cmds)):
+            self.assertEqual(cmds[i].directory, expected[i]['wd'])
+            self.assertEqual(cmds[i].filename, expected[i]['file'])
+            for arg, exp in zip(cmds[i].arguments, expected[i]['line']):
+                self.assertEqual(arg, exp)
+
+    def test_1_compilecommand(self):
+        """Check file with single compile command"""
+        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        file = '/home/john.doe/MyProject/project.cpp'
+        cmds = cdb.getCompileCommands(file)
+        self.assertEqual(len(cmds), 1)
+        self.assertEqual(cmds[0].directory, os.path.dirname(file))
+        self.assertEqual(cmds[0].filename, file)
+        expected = [ 'clang++', '-o', 'project.o', '-c',
+                     '/home/john.doe/MyProject/project.cpp']
+        for arg, exp in zip(cmds[0].arguments, expected):
+            self.assertEqual(arg, exp)
+
+    def test_2_compilecommand(self):
+        """Check file with 2 compile commands"""
+        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project2.cpp')
+        self.assertEqual(len(cmds), 2)
+        expected = [
+            { 'wd': '/home/john.doe/MyProjectA',
+              'line': ['clang++', '-o', 'project2.o', '-c',
+                       '/home/john.doe/MyProject/project2.cpp']},
+            { 'wd': '/home/john.doe/MyProjectB',
+              'line': ['clang++', '-DFEATURE=1', '-o', 'project2-feature.o', '-c',
+                       '/home/john.doe/MyProject/project2.cpp']}
+            ]
+        for i in range(len(cmds)):
+            self.assertEqual(cmds[i].directory, expected[i]['wd'])
+            for arg, exp in zip(cmds[i].arguments, expected[i]['line']):
+                self.assertEqual(arg, exp)
+
+    def test_compilecommand_iterator_stops(self):
+        """Check that iterator stops after the correct number of elements"""
+        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        count = 0
+        for cmd in cdb.getCompileCommands('/home/john.doe/MyProject/project2.cpp'):
+            count += 1
+            self.assertLessEqual(count, 2)
+
+    def test_compilationDB_references(self):
+        """Ensure CompilationsCommands are independent of the database"""
+        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project.cpp')
+        del cdb
+        gc.collect()
+        workingdir = cmds[0].directory
+
+    def test_compilationCommands_references(self):
+        """Ensure CompilationsCommand keeps a reference to CompilationCommands"""
+        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project.cpp')
+        del cdb
+        cmd0 = cmds[0]
+        del cmds
+        gc.collect()
+        workingdir = cmd0.directory

external/llvm-project/clang/bindings/python/tests/cindex/test_code_completion.py

@@ -0,0 +1,79 @@
+from clang.cindex import TranslationUnit
+
+import unittest
+
+
+class TestCodeCompletion(unittest.TestCase):
+    def check_completion_results(self, cr, expected):
+        self.assertIsNotNone(cr)
+        self.assertEqual(len(cr.diagnostics), 0)
+
+        completions = [str(c) for c in cr.results]
+
+        for c in expected:
+            self.assertIn(c, completions)
+
+    def test_code_complete(self):
+        files = [('fake.c', """
+/// Aaa.
+int test1;
+
+/// Bbb.
+void test2(void);
+
+void f() {
+
+}
+""")]
+
+        tu = TranslationUnit.from_source('fake.c', ['-std=c99'], unsaved_files=files,
+                options=TranslationUnit.PARSE_INCLUDE_BRIEF_COMMENTS_IN_CODE_COMPLETION)
+
+        cr = tu.codeComplete('fake.c', 9, 1, unsaved_files=files, include_brief_comments=True)
+
+        expected = [
+          "{'int', ResultType} | {'test1', TypedText} || Priority: 50 || Availability: Available || Brief comment: Aaa.",
+          "{'void', ResultType} | {'test2', TypedText} | {'(', LeftParen} | {')', RightParen} || Priority: 50 || Availability: Available || Brief comment: Bbb.",
+          "{'return', TypedText} || Priority: 40 || Availability: Available || Brief comment: None"
+        ]
+        self.check_completion_results(cr, expected)
+
+    def test_code_complete_availability(self):
+        files = [('fake.cpp', """
+class P {
+protected:
+  int member;
+};
+
+class Q : public P {
+public:
+  using P::member;
+};
+
+void f(P x, Q y) {
+  x.; // member is inaccessible
+  y.; // member is accessible
+}
+""")]
+
+        tu = TranslationUnit.from_source('fake.cpp', ['-std=c++98'], unsaved_files=files)
+
+        cr = tu.codeComplete('fake.cpp', 12, 5, unsaved_files=files)
+
+        expected = [
+          "{'const', TypedText} || Priority: 40 || Availability: Available || Brief comment: None",
+          "{'volatile', TypedText} || Priority: 40 || Availability: Available || Brief comment: None",
+          "{'operator', TypedText} || Priority: 40 || Availability: Available || Brief comment: None",
+          "{'P', TypedText} | {'::', Text} || Priority: 75 || Availability: Available || Brief comment: None",
+          "{'Q', TypedText} | {'::', Text} || Priority: 75 || Availability: Available || Brief comment: None"
+        ]
+        self.check_completion_results(cr, expected)
+
+        cr = tu.codeComplete('fake.cpp', 13, 5, unsaved_files=files)
+        expected = [
+            "{'P', TypedText} | {'::', Text} || Priority: 75 || Availability: Available || Brief comment: None",
+            "{'P &', ResultType} | {'operator=', TypedText} | {'(', LeftParen} | {'const P &', Placeholder} | {')', RightParen} || Priority: 79 || Availability: Available || Brief comment: None",
+            "{'int', ResultType} | {'member', TypedText} || Priority: 35 || Availability: NotAccessible || Brief comment: None",
+            "{'void', ResultType} | {'~P', TypedText} | {'(', LeftParen} | {')', RightParen} || Priority: 79 || Availability: Available || Brief comment: None"
+        ]
+        self.check_completion_results(cr, expected)

external/llvm-project/clang/bindings/python/tests/cindex/test_comment.py

@@ -0,0 +1,42 @@
+from clang.cindex import TranslationUnit
+from tests.cindex.util import get_cursor
+
+import unittest
+
+
+class TestComment(unittest.TestCase):
+    def test_comment(self):
+        files = [('fake.c', """
+/// Aaa.
+int test1;
+
+/// Bbb.
+/// x
+void test2(void);
+
+void f() {
+
+}
+""")]
+        # make a comment-aware TU
+        tu = TranslationUnit.from_source('fake.c', ['-std=c99'], unsaved_files=files,
+                options=TranslationUnit.PARSE_INCLUDE_BRIEF_COMMENTS_IN_CODE_COMPLETION)
+        test1 = get_cursor(tu, 'test1')
+        self.assertIsNotNone(test1, "Could not find test1.")
+        self.assertTrue(test1.type.is_pod())
+        raw = test1.raw_comment
+        brief = test1.brief_comment
+        self.assertEqual(raw, """/// Aaa.""")
+        self.assertEqual(brief, """Aaa.""")
+
+        test2 = get_cursor(tu, 'test2')
+        raw = test2.raw_comment
+        brief = test2.brief_comment
+        self.assertEqual(raw, """/// Bbb.\n/// x""")
+        self.assertEqual(brief, """Bbb. x""")
+
+        f = get_cursor(tu, 'f')
+        raw = f.raw_comment
+        brief = f.brief_comment
+        self.assertIsNone(raw)
+        self.assertIsNone(brief)

external/llvm-project/clang/bindings/python/tests/cindex/test_cursor_kind.py

@@ -0,0 +1,53 @@
+from clang.cindex import CursorKind
+
+import unittest
+
+
+class TestCursorKind(unittest.TestCase):
+    def test_name(self):
+        self.assertTrue(CursorKind.UNEXPOSED_DECL.name is 'UNEXPOSED_DECL')
+
+    def test_get_all_kinds(self):
+        kinds = CursorKind.get_all_kinds()
+        self.assertIn(CursorKind.UNEXPOSED_DECL, kinds)
+        self.assertIn(CursorKind.TRANSLATION_UNIT, kinds)
+        self.assertIn(CursorKind.VARIABLE_REF, kinds)
+        self.assertIn(CursorKind.LAMBDA_EXPR, kinds)
+        self.assertIn(CursorKind.OBJ_BOOL_LITERAL_EXPR, kinds)
+        self.assertIn(CursorKind.OBJ_SELF_EXPR, kinds)
+        self.assertIn(CursorKind.MS_ASM_STMT, kinds)
+        self.assertIn(CursorKind.MODULE_IMPORT_DECL, kinds)
+        self.assertIn(CursorKind.TYPE_ALIAS_TEMPLATE_DECL, kinds)
+
+    def test_kind_groups(self):
+        """Check that every kind classifies to exactly one group."""
+
+        self.assertTrue(CursorKind.UNEXPOSED_DECL.is_declaration())
+        self.assertTrue(CursorKind.TYPE_REF.is_reference())
+        self.assertTrue(CursorKind.DECL_REF_EXPR.is_expression())
+        self.assertTrue(CursorKind.UNEXPOSED_STMT.is_statement())
+        self.assertTrue(CursorKind.INVALID_FILE.is_invalid())
+
+        self.assertTrue(CursorKind.TRANSLATION_UNIT.is_translation_unit())
+        self.assertFalse(CursorKind.TYPE_REF.is_translation_unit())
+
+        self.assertTrue(CursorKind.PREPROCESSING_DIRECTIVE.is_preprocessing())
+        self.assertFalse(CursorKind.TYPE_REF.is_preprocessing())
+
+        self.assertTrue(CursorKind.UNEXPOSED_DECL.is_unexposed())
+        self.assertFalse(CursorKind.TYPE_REF.is_unexposed())
+
+        for k in CursorKind.get_all_kinds():
+            group = [n for n in ('is_declaration', 'is_reference', 'is_expression',
+                                 'is_statement', 'is_invalid', 'is_attribute')
+                     if getattr(k, n)()]
+
+            if k in (   CursorKind.TRANSLATION_UNIT,
+                        CursorKind.MACRO_DEFINITION,
+                        CursorKind.MACRO_INSTANTIATION,
+                        CursorKind.INCLUSION_DIRECTIVE,
+                        CursorKind.PREPROCESSING_DIRECTIVE,
+                        CursorKind.OVERLOAD_CANDIDATE):
+                self.assertEqual(len(group), 0)
+            else:
+                self.assertEqual(len(group), 1)

external/llvm-project/clang/bindings/python/tests/cindex/test_diagnostics.py

@@ -0,0 +1,105 @@
+from clang.cindex import *
+from .util import get_tu
+
+import unittest
+
+
+# FIXME: We need support for invalid translation units to test better.
+
+
+class TestDiagnostics(unittest.TestCase):
+    def test_diagnostic_warning(self):
+        tu = get_tu('int f0() {}\n')
+        self.assertEqual(len(tu.diagnostics), 1)
+        self.assertEqual(tu.diagnostics[0].severity, Diagnostic.Warning)
+        self.assertEqual(tu.diagnostics[0].location.line, 1)
+        self.assertEqual(tu.diagnostics[0].location.column, 11)
+        self.assertEqual(tu.diagnostics[0].spelling,
+                'control reaches end of non-void function')
+
+    def test_diagnostic_note(self):
+        # FIXME: We aren't getting notes here for some reason.
+        tu = get_tu('#define A x\nvoid *A = 1;\n')
+        self.assertEqual(len(tu.diagnostics), 1)
+        self.assertEqual(tu.diagnostics[0].severity, Diagnostic.Warning)
+        self.assertEqual(tu.diagnostics[0].location.line, 2)
+        self.assertEqual(tu.diagnostics[0].location.column, 7)
+        self.assertIn('incompatible', tu.diagnostics[0].spelling)
+#       self.assertEqual(tu.diagnostics[1].severity, Diagnostic.Note)
+#       self.assertEqual(tu.diagnostics[1].location.line, 1)
+#       self.assertEqual(tu.diagnostics[1].location.column, 11)
+#       self.assertEqual(tu.diagnostics[1].spelling, 'instantiated from')
+
+    def test_diagnostic_fixit(self):
+        tu = get_tu('struct { int f0; } x = { f0 : 1 };')
+        self.assertEqual(len(tu.diagnostics), 1)
+        self.assertEqual(tu.diagnostics[0].severity, Diagnostic.Warning)
+        self.assertEqual(tu.diagnostics[0].location.line, 1)
+        self.assertEqual(tu.diagnostics[0].location.column, 26)
+        self.assertRegexpMatches(tu.diagnostics[0].spelling,
+            'use of GNU old-style.*')
+        self.assertEqual(len(tu.diagnostics[0].fixits), 1)
+        self.assertEqual(tu.diagnostics[0].fixits[0].range.start.line, 1)
+        self.assertEqual(tu.diagnostics[0].fixits[0].range.start.column, 26)
+        self.assertEqual(tu.diagnostics[0].fixits[0].range.end.line, 1)
+        self.assertEqual(tu.diagnostics[0].fixits[0].range.end.column, 30)
+        self.assertEqual(tu.diagnostics[0].fixits[0].value, '.f0 = ')
+
+    def test_diagnostic_range(self):
+        tu = get_tu('void f() { int i = "a" + 1; }')
+        self.assertEqual(len(tu.diagnostics), 1)
+        self.assertEqual(tu.diagnostics[0].severity, Diagnostic.Warning)
+        self.assertEqual(tu.diagnostics[0].location.line, 1)
+        self.assertEqual(tu.diagnostics[0].location.column, 16)
+        self.assertRegexpMatches(tu.diagnostics[0].spelling,
+            'incompatible pointer to.*')
+        self.assertEqual(len(tu.diagnostics[0].fixits), 0)
+        self.assertEqual(len(tu.diagnostics[0].ranges), 1)
+        self.assertEqual(tu.diagnostics[0].ranges[0].start.line, 1)
+        self.assertEqual(tu.diagnostics[0].ranges[0].start.column, 20)
+        self.assertEqual(tu.diagnostics[0].ranges[0].end.line, 1)
+        self.assertEqual(tu.diagnostics[0].ranges[0].end.column, 27)
+        with self.assertRaises(IndexError):
+            tu.diagnostics[0].ranges[1].start.line
+
+    def test_diagnostic_category(self):
+        """Ensure that category properties work."""
+        tu = get_tu('int f(int i) { return 7; }', all_warnings=True)
+        self.assertEqual(len(tu.diagnostics), 1)
+        d = tu.diagnostics[0]
+
+        self.assertEqual(d.severity, Diagnostic.Warning)
+        self.assertEqual(d.location.line, 1)
+        self.assertEqual(d.location.column, 11)
+
+        self.assertEqual(d.category_number, 2)
+        self.assertEqual(d.category_name, 'Semantic Issue')
+
+    def test_diagnostic_option(self):
+        """Ensure that category option properties work."""
+        tu = get_tu('int f(int i) { return 7; }', all_warnings=True)
+        self.assertEqual(len(tu.diagnostics), 1)
+        d = tu.diagnostics[0]
+
+        self.assertEqual(d.option, '-Wunused-parameter')
+        self.assertEqual(d.disable_option, '-Wno-unused-parameter')
+
+    def test_diagnostic_children(self):
+        tu = get_tu('void f(int x) {} void g() { f(); }')
+        self.assertEqual(len(tu.diagnostics), 1)
+        d = tu.diagnostics[0]
+
+        children = d.children
+        self.assertEqual(len(children), 1)
+        self.assertEqual(children[0].severity, Diagnostic.Note)
+        self.assertRegexpMatches(children[0].spelling,
+                '.*declared here')
+        self.assertEqual(children[0].location.line, 1)
+        self.assertEqual(children[0].location.column, 1)
+
+    def test_diagnostic_string_repr(self):
+        tu = get_tu('struct MissingSemicolon{}')
+        self.assertEqual(len(tu.diagnostics), 1)
+        d = tu.diagnostics[0]
+
+        self.assertEqual(repr(d), '<Diagnostic severity 3, location <SourceLocation file \'t.c\', line 1, column 26>, spelling "expected \';\' after struct">')

external/llvm-project/clang/bindings/python/tests/cindex/test_exception_specification_kind.py

@@ -0,0 +1,30 @@
+import clang.cindex
+from clang.cindex import ExceptionSpecificationKind
+from .util import get_tu
+
+import unittest
+
+
+def find_function_declarations(node, declarations=[]):
+    if node.kind == clang.cindex.CursorKind.FUNCTION_DECL:
+        declarations.append((node.spelling, node.exception_specification_kind))
+    for child in node.get_children():
+        declarations = find_function_declarations(child, declarations)
+    return declarations
+
+
+class TestExceptionSpecificationKind(unittest.TestCase):
+    def test_exception_specification_kind(self):
+        source = """int square1(int x);
+                    int square2(int x) noexcept;
+                    int square3(int x) noexcept(noexcept(x * x));"""
+
+        tu = get_tu(source, lang='cpp', flags=['-std=c++14'])
+
+        declarations = find_function_declarations(tu.cursor)
+        expected = [
+            ('square1', ExceptionSpecificationKind.NONE),
+            ('square2', ExceptionSpecificationKind.BASIC_NOEXCEPT),
+            ('square3', ExceptionSpecificationKind.COMPUTED_NOEXCEPT)
+        ]
+        self.assertListEqual(declarations, expected)

external/llvm-project/clang/bindings/python/tests/cindex/test_file.py

@@ -0,0 +1,13 @@
+from clang.cindex import Index, File
+
+import unittest
+
+
+class TestFile(unittest.TestCase):
+    def test_file(self):
+        index = Index.create()
+        tu = index.parse('t.c', unsaved_files = [('t.c', "")])
+        file = File.from_name(tu, "t.c")
+        self.assertEqual(str(file), "t.c")
+        self.assertEqual(file.name, "t.c")
+        self.assertEqual(repr(file), "<File: t.c>")

external/llvm-project/clang/bindings/python/tests/cindex/test_index.py

@@ -0,0 +1,21 @@
+from clang.cindex import *
+import os
+import unittest
+
+
+kInputsDir = os.path.join(os.path.dirname(__file__), 'INPUTS')
+
+
+class TestIndex(unittest.TestCase):
+    def test_create(self):
+        index = Index.create()
+
+    # FIXME: test Index.read
+
+    def test_parse(self):
+        index = Index.create()
+        self.assertIsInstance(index, Index)
+        tu = index.parse(os.path.join(kInputsDir, 'hello.cpp'))
+        self.assertIsInstance(tu, TranslationUnit)
+        tu = index.parse(None, ['-c', os.path.join(kInputsDir, 'hello.cpp')])
+        self.assertIsInstance(tu, TranslationUnit)

external/llvm-project/clang/bindings/python/tests/cindex/test_linkage.py

@@ -0,0 +1,33 @@
+from clang.cindex import LinkageKind
+from clang.cindex import Cursor
+from clang.cindex import TranslationUnit
+
+from .util import get_cursor
+from .util import get_tu
+
+import unittest
+
+
+class TestLinkage(unittest.TestCase):
+    def test_linkage(self):
+        """Ensure that linkage specifers are available on cursors"""
+
+        tu = get_tu("""
+void foo() { int no_linkage; }
+static int internal;
+namespace { struct unique_external_type {} }
+unique_external_type unique_external;
+extern int external;
+""", lang = 'cpp')
+
+        no_linkage = get_cursor(tu.cursor, 'no_linkage')
+        self.assertEqual(no_linkage.linkage, LinkageKind.NO_LINKAGE)
+
+        internal = get_cursor(tu.cursor, 'internal')
+        self.assertEqual(internal.linkage, LinkageKind.INTERNAL)
+
+        unique_external = get_cursor(tu.cursor, 'unique_external')
+        self.assertEqual(unique_external.linkage, LinkageKind.UNIQUE_EXTERNAL)
+
+        external = get_cursor(tu.cursor, 'external')
+        self.assertEqual(external.linkage, LinkageKind.EXTERNAL)