| import os |
| from clang.cindex import Config |
| if 'CLANG_LIBRARY_PATH' in os.environ: |
| Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) |
| |
| from contextlib import contextmanager |
| import gc |
| import os |
| import sys |
| import tempfile |
| import unittest |
| |
| from clang.cindex import CursorKind |
| from clang.cindex import Cursor |
| from clang.cindex import File |
| from clang.cindex import Index |
| from clang.cindex import SourceLocation |
| from clang.cindex import SourceRange |
| from clang.cindex import TranslationUnitSaveError |
| from clang.cindex import TranslationUnitLoadError |
| from clang.cindex import TranslationUnit |
| from .util import get_cursor |
| from .util import get_tu |
| from .util import skip_if_no_fspath |
| from .util import str_to_path |
| |
| |
| kInputsDir = os.path.join(os.path.dirname(__file__), 'INPUTS') |
| |
| |
| @contextmanager |
| def save_tu(tu): |
| """Convenience API to save a TranslationUnit to a file. |
| |
| Returns the filename it was saved to. |
| """ |
| with tempfile.NamedTemporaryFile() as t: |
| tu.save(t.name) |
| yield t.name |
| |
| |
| @contextmanager |
| def save_tu_pathlike(tu): |
| """Convenience API to save a TranslationUnit to a file. |
| |
| Returns the filename it was saved to. |
| """ |
| with tempfile.NamedTemporaryFile() as t: |
| tu.save(str_to_path(t.name)) |
| yield t.name |
| |
| |
| class TestTranslationUnit(unittest.TestCase): |
| def test_spelling(self): |
| path = os.path.join(kInputsDir, 'hello.cpp') |
| tu = TranslationUnit.from_source(path) |
| self.assertEqual(tu.spelling, path) |
| |
| def test_cursor(self): |
| path = os.path.join(kInputsDir, 'hello.cpp') |
| tu = get_tu(path) |
| c = tu.cursor |
| self.assertIsInstance(c, Cursor) |
| self.assertIs(c.kind, CursorKind.TRANSLATION_UNIT) |
| |
| def test_parse_arguments(self): |
| path = os.path.join(kInputsDir, 'parse_arguments.c') |
| tu = TranslationUnit.from_source(path, ['-DDECL_ONE=hello', '-DDECL_TWO=hi']) |
| spellings = [c.spelling for c in tu.cursor.get_children()] |
| self.assertEqual(spellings[-2], 'hello') |
| self.assertEqual(spellings[-1], 'hi') |
| |
| def test_reparse_arguments(self): |
| path = os.path.join(kInputsDir, 'parse_arguments.c') |
| tu = TranslationUnit.from_source(path, ['-DDECL_ONE=hello', '-DDECL_TWO=hi']) |
| tu.reparse() |
| spellings = [c.spelling for c in tu.cursor.get_children()] |
| self.assertEqual(spellings[-2], 'hello') |
| self.assertEqual(spellings[-1], 'hi') |
| |
| def test_unsaved_files(self): |
| tu = TranslationUnit.from_source('fake.c', ['-I./'], unsaved_files = [ |
| ('fake.c', """ |
| #include "fake.h" |
| int x; |
| int SOME_DEFINE; |
| """), |
| ('./fake.h', """ |
| #define SOME_DEFINE y |
| """) |
| ]) |
| spellings = [c.spelling for c in tu.cursor.get_children()] |
| self.assertEqual(spellings[-2], 'x') |
| self.assertEqual(spellings[-1], 'y') |
| |
| def test_unsaved_files_2(self): |
| if sys.version_info.major >= 3: |
| from io import StringIO |
| else: |
| from io import BytesIO as StringIO |
| tu = TranslationUnit.from_source('fake.c', unsaved_files = [ |
| ('fake.c', StringIO('int x;'))]) |
| spellings = [c.spelling for c in tu.cursor.get_children()] |
| self.assertEqual(spellings[-1], 'x') |
| |
| @skip_if_no_fspath |
| def test_from_source_accepts_pathlike(self): |
| tu = TranslationUnit.from_source(str_to_path('fake.c'), ['-Iincludes'], unsaved_files = [ |
| (str_to_path('fake.c'), """ |
| #include "fake.h" |
| int x; |
| int SOME_DEFINE; |
| """), |
| (str_to_path('includes/fake.h'), """ |
| #define SOME_DEFINE y |
| """) |
| ]) |
| spellings = [c.spelling for c in tu.cursor.get_children()] |
| self.assertEqual(spellings[-2], 'x') |
| self.assertEqual(spellings[-1], 'y') |
| |
| def assert_normpaths_equal(self, path1, path2): |
| """ Compares two paths for equality after normalizing them with |
| os.path.normpath |
| """ |
| self.assertEqual(os.path.normpath(path1), |
| os.path.normpath(path2)) |
| |
| def test_includes(self): |
| def eq(expected, actual): |
| if not actual.is_input_file: |
| self.assert_normpaths_equal(expected[0], actual.source.name) |
| self.assert_normpaths_equal(expected[1], actual.include.name) |
| else: |
| self.assert_normpaths_equal(expected[1], actual.include.name) |
| |
| src = os.path.join(kInputsDir, 'include.cpp') |
| h1 = os.path.join(kInputsDir, "header1.h") |
| h2 = os.path.join(kInputsDir, "header2.h") |
| h3 = os.path.join(kInputsDir, "header3.h") |
| inc = [(src, h1), (h1, h3), (src, h2), (h2, h3)] |
| |
| tu = TranslationUnit.from_source(src) |
| for i in zip(inc, tu.get_includes()): |
| eq(i[0], i[1]) |
| |
| def test_inclusion_directive(self): |
| src = os.path.join(kInputsDir, 'include.cpp') |
| h1 = os.path.join(kInputsDir, "header1.h") |
| h2 = os.path.join(kInputsDir, "header2.h") |
| h3 = os.path.join(kInputsDir, "header3.h") |
| inc = [h1, h3, h2, h3, h1] |
| |
| tu = TranslationUnit.from_source(src, options=TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD) |
| inclusion_directive_files = [c.get_included_file().name for c in tu.cursor.get_children() if c.kind == CursorKind.INCLUSION_DIRECTIVE] |
| for i in zip(inc, inclusion_directive_files): |
| self.assert_normpaths_equal(i[0], i[1]) |
| |
| def test_save(self): |
| """Ensure TranslationUnit.save() works.""" |
| |
| tu = get_tu('int foo();') |
| |
| with save_tu(tu) as path: |
| self.assertTrue(os.path.exists(path)) |
| self.assertGreater(os.path.getsize(path), 0) |
| |
| @skip_if_no_fspath |
| def test_save_pathlike(self): |
| """Ensure TranslationUnit.save() works with PathLike filename.""" |
| |
| tu = get_tu('int foo();') |
| |
| with save_tu_pathlike(tu) as path: |
| self.assertTrue(os.path.exists(path)) |
| self.assertGreater(os.path.getsize(path), 0) |
| |
| def test_save_translation_errors(self): |
| """Ensure that saving to an invalid directory raises.""" |
| |
| tu = get_tu('int foo();') |
| |
| path = '/does/not/exist/llvm-test.ast' |
| self.assertFalse(os.path.exists(os.path.dirname(path))) |
| |
| with self.assertRaises(TranslationUnitSaveError) as cm: |
| tu.save(path) |
| ex = cm.exception |
| expected = TranslationUnitSaveError.ERROR_UNKNOWN |
| self.assertEqual(ex.save_error, expected) |
| |
| def test_load(self): |
| """Ensure TranslationUnits can be constructed from saved files.""" |
| |
| tu = get_tu('int foo();') |
| self.assertEqual(len(tu.diagnostics), 0) |
| with save_tu(tu) as path: |
| self.assertTrue(os.path.exists(path)) |
| self.assertGreater(os.path.getsize(path), 0) |
| |
| tu2 = TranslationUnit.from_ast_file(filename=path) |
| self.assertEqual(len(tu2.diagnostics), 0) |
| |
| foo = get_cursor(tu2, 'foo') |
| self.assertIsNotNone(foo) |
| |
| # Just in case there is an open file descriptor somewhere. |
| del tu2 |
| |
| @skip_if_no_fspath |
| def test_load_pathlike(self): |
| """Ensure TranslationUnits can be constructed from saved files - |
| PathLike variant.""" |
| tu = get_tu('int foo();') |
| self.assertEqual(len(tu.diagnostics), 0) |
| with save_tu(tu) as path: |
| tu2 = TranslationUnit.from_ast_file(filename=str_to_path(path)) |
| self.assertEqual(len(tu2.diagnostics), 0) |
| |
| foo = get_cursor(tu2, 'foo') |
| self.assertIsNotNone(foo) |
| |
| # Just in case there is an open file descriptor somewhere. |
| del tu2 |
| |
| def test_index_parse(self): |
| path = os.path.join(kInputsDir, 'hello.cpp') |
| index = Index.create() |
| tu = index.parse(path) |
| self.assertIsInstance(tu, TranslationUnit) |
| |
| def test_get_file(self): |
| """Ensure tu.get_file() works appropriately.""" |
| |
| tu = get_tu('int foo();') |
| |
| f = tu.get_file('t.c') |
| self.assertIsInstance(f, File) |
| self.assertEqual(f.name, 't.c') |
| |
| with self.assertRaises(Exception): |
| f = tu.get_file('foobar.cpp') |
| |
| @skip_if_no_fspath |
| def test_get_file_pathlike(self): |
| """Ensure tu.get_file() works appropriately with PathLike filenames.""" |
| |
| tu = get_tu('int foo();') |
| |
| f = tu.get_file(str_to_path('t.c')) |
| self.assertIsInstance(f, File) |
| self.assertEqual(f.name, 't.c') |
| |
| with self.assertRaises(Exception): |
| f = tu.get_file(str_to_path('foobar.cpp')) |
| |
| def test_get_source_location(self): |
| """Ensure tu.get_source_location() works.""" |
| |
| tu = get_tu('int foo();') |
| |
| location = tu.get_location('t.c', 2) |
| self.assertIsInstance(location, SourceLocation) |
| self.assertEqual(location.offset, 2) |
| self.assertEqual(location.file.name, 't.c') |
| |
| location = tu.get_location('t.c', (1, 3)) |
| self.assertIsInstance(location, SourceLocation) |
| self.assertEqual(location.line, 1) |
| self.assertEqual(location.column, 3) |
| self.assertEqual(location.file.name, 't.c') |
| |
| def test_get_source_range(self): |
| """Ensure tu.get_source_range() works.""" |
| |
| tu = get_tu('int foo();') |
| |
| r = tu.get_extent('t.c', (1,4)) |
| self.assertIsInstance(r, SourceRange) |
| self.assertEqual(r.start.offset, 1) |
| self.assertEqual(r.end.offset, 4) |
| self.assertEqual(r.start.file.name, 't.c') |
| self.assertEqual(r.end.file.name, 't.c') |
| |
| r = tu.get_extent('t.c', ((1,2), (1,3))) |
| self.assertIsInstance(r, SourceRange) |
| self.assertEqual(r.start.line, 1) |
| self.assertEqual(r.start.column, 2) |
| self.assertEqual(r.end.line, 1) |
| self.assertEqual(r.end.column, 3) |
| self.assertEqual(r.start.file.name, 't.c') |
| self.assertEqual(r.end.file.name, 't.c') |
| |
| start = tu.get_location('t.c', 0) |
| end = tu.get_location('t.c', 5) |
| |
| r = tu.get_extent('t.c', (start, end)) |
| self.assertIsInstance(r, SourceRange) |
| self.assertEqual(r.start.offset, 0) |
| self.assertEqual(r.end.offset, 5) |
| self.assertEqual(r.start.file.name, 't.c') |
| self.assertEqual(r.end.file.name, 't.c') |
| |
| def test_get_tokens_gc(self): |
| """Ensures get_tokens() works properly with garbage collection.""" |
| |
| tu = get_tu('int foo();') |
| r = tu.get_extent('t.c', (0, 10)) |
| tokens = list(tu.get_tokens(extent=r)) |
| |
| self.assertEqual(tokens[0].spelling, 'int') |
| gc.collect() |
| self.assertEqual(tokens[0].spelling, 'int') |
| |
| del tokens[1] |
| gc.collect() |
| self.assertEqual(tokens[0].spelling, 'int') |
| |
| # May trigger segfault if we don't do our job properly. |
| del tokens |
| gc.collect() |
| gc.collect() # Just in case. |
| |
| def test_fail_from_source(self): |
| path = os.path.join(kInputsDir, 'non-existent.cpp') |
| try: |
| tu = TranslationUnit.from_source(path) |
| except TranslationUnitLoadError: |
| tu = None |
| self.assertEqual(tu, None) |
| |
| def test_fail_from_ast_file(self): |
| path = os.path.join(kInputsDir, 'non-existent.ast') |
| try: |
| tu = TranslationUnit.from_ast_file(path) |
| except TranslationUnitLoadError: |
| tu = None |
| self.assertEqual(tu, None) |
