diff options
Diffstat (limited to 'gnu/llvm/tools/clang/bindings/python/tests')
28 files changed, 0 insertions, 2438 deletions
diff --git a/gnu/llvm/tools/clang/bindings/python/tests/CMakeLists.txt b/gnu/llvm/tools/clang/bindings/python/tests/CMakeLists.txt deleted file mode 100644 index 7af6503f158..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/CMakeLists.txt +++ /dev/null @@ -1,46 +0,0 @@ -# Test target to run Python test suite from main build. - -add_custom_target(check-clang-python - COMMAND ${CMAKE_COMMAND} -E env - CLANG_LIBRARY_PATH=$<TARGET_FILE_DIR:libclang> - ${PYTHON_EXECUTABLE} -m unittest discover - DEPENDS libclang - WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/..) - -set(RUN_PYTHON_TESTS TRUE) -set_target_properties(check-clang-python PROPERTIES FOLDER "Clang tests") - -# Tests require libclang.so which is only built with LLVM_ENABLE_PIC=ON -if(NOT LLVM_ENABLE_PIC) - set(RUN_PYTHON_TESTS FALSE) -endif() - -# Do not try to run if libclang was built with ASan because -# the sanitizer library will likely be loaded too late to perform -# interception and will then fail. -# We could use LD_PRELOAD/DYLD_INSERT_LIBRARIES but this isn't -# portable so its easier just to not run the tests when building -# with ASan. -list(FIND LLVM_USE_SANITIZER "Address" LLVM_USE_ASAN_INDEX) -if(NOT LLVM_USE_ASAN_INDEX EQUAL -1) - set(RUN_PYTHON_TESTS FALSE) -endif() - -# Tests fail on Windows, and need someone knowledgeable to fix. -# It's not clear whether it's a test or a valid binding problem. -if(WIN32) - set(RUN_PYTHON_TESTS FALSE) -endif() - -# AArch64 and Hexagon have known test failures that need to be -# addressed. -# SystemZ has broken Python/FFI interface: -# https://reviews.llvm.org/D52840#1265716 -if(${LLVM_NATIVE_ARCH} MATCHES "^(AArch64|Hexagon|SystemZ)$") - set(RUN_PYTHON_TESTS FALSE) -endif() - -if(RUN_PYTHON_TESTS) - set_property(GLOBAL APPEND PROPERTY - LLVM_ADDITIONAL_TEST_TARGETS check-clang-python) -endif() diff --git a/gnu/llvm/tools/clang/bindings/python/tests/__init__.py b/gnu/llvm/tools/clang/bindings/python/tests/__init__.py deleted file mode 100644 index e69de29bb2d..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/__init__.py +++ /dev/null diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/compile_commands.json b/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/compile_commands.json deleted file mode 100644 index 944150bf7ba..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/compile_commands.json +++ /dev/null @@ -1,17 +0,0 @@ -[ -{ - "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" -} -] diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/header1.h b/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/header1.h deleted file mode 100644 index b4eacbee375..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/header1.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef HEADER1 -#define HEADER1 - -#include "header3.h" - -#endif diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/header2.h b/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/header2.h deleted file mode 100644 index c4eddc0c562..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/header2.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef HEADER2 -#define HEADER2 - -#include "header3.h" - -#endif diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/header3.h b/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/header3.h deleted file mode 100644 index 6dca764860e..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/header3.h +++ /dev/null @@ -1,3 +0,0 @@ -// Not a guarded header! - -void f(); diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/hello.cpp b/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/hello.cpp deleted file mode 100644 index 7ef086e56b2..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/hello.cpp +++ /dev/null @@ -1,6 +0,0 @@ -#include "stdio.h" - -int main(int argc, char* argv[]) { - printf("hello world\n"); - return 0; -} diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/include.cpp b/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/include.cpp deleted file mode 100644 index 60cfdaae4d0..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/include.cpp +++ /dev/null @@ -1,5 +0,0 @@ -#include "header1.h" -#include "header2.h" -#include "header1.h" - -int main() { } diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/parse_arguments.c b/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/parse_arguments.c deleted file mode 100644 index 7196486c78a..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/INPUTS/parse_arguments.c +++ /dev/null @@ -1,2 +0,0 @@ -int DECL_ONE = 1; -int DECL_TWO = 2; diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/__init__.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/__init__.py deleted file mode 100644 index e69de29bb2d..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/__init__.py +++ /dev/null diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_access_specifiers.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_access_specifiers.py deleted file mode 100644 index e36424f240a..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_access_specifiers.py +++ /dev/null @@ -1,41 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -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) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_cdb.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_cdb.py deleted file mode 100644 index 589fc72856b..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_cdb.py +++ /dev/null @@ -1,130 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -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 -import sys -from .util import skip_if_no_fspath -from .util import str_to_path - - -kInputsDir = os.path.join(os.path.dirname(__file__), 'INPUTS') - - -@unittest.skipIf(sys.platform == 'win32', "TODO: Fix these tests on Windows") -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_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) - - @skip_if_no_fspath - def test_lookup_succeed_pathlike(self): - """Same as test_lookup_succeed, but with PathLikes""" - cdb = CompilationDatabase.fromDirectory(str_to_path(kInputsDir)) - cmds = cdb.getCompileCommands(str_to_path('/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 diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_code_completion.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_code_completion.py deleted file mode 100644 index e0b41577aeb..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_code_completion.py +++ /dev/null @@ -1,112 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -from clang.cindex import TranslationUnit - -import unittest -from .util import skip_if_no_fspath -from .util import str_to_path - - -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) - - @skip_if_no_fspath - def test_code_complete_pathlike(self): - files = [(str_to_path('fake.c'), """ -/// Aaa. -int test1; - -/// Bbb. -void test2(void); - -void f() { - -} -""")] - - tu = TranslationUnit.from_source(str_to_path('fake.c'), ['-std=c99'], unsaved_files=files, - options=TranslationUnit.PARSE_INCLUDE_BRIEF_COMMENTS_IN_CODE_COMPLETION) - - cr = tu.codeComplete(str_to_path('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: 50 || Availability: Available || Brief comment: None", - "{'volatile', TypedText} || Priority: 50 || Availability: Available || Brief comment: None", - "{'operator', TypedText} || Priority: 40 || Availability: Available || Brief comment: None", - "{'P', TypedText} || Priority: 50 || Availability: Available || Brief comment: None", - "{'Q', TypedText} || Priority: 50 || 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) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_comment.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_comment.py deleted file mode 100644 index 73fb617ae16..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_comment.py +++ /dev/null @@ -1,47 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -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) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_cursor.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_cursor.py deleted file mode 100644 index ef875e97247..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_cursor.py +++ /dev/null @@ -1,569 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -import ctypes -import gc -import unittest - -from clang.cindex import AvailabilityKind -from clang.cindex import CursorKind -from clang.cindex import TemplateArgumentKind -from clang.cindex import TranslationUnit -from clang.cindex import TypeKind -from .util import get_cursor -from .util import get_cursors -from .util import get_tu - - -kInput = """\ -struct s0 { - int a; - int b; -}; - -struct s1; - -void f0(int a0, int a1) { - int l0, l1; - - if (a0) - return; - - for (;;) { - break; - } -} -""" - -kParentTest = """\ - class C { - void f(); - } - - void C::f() { } - """ - -kTemplateArgTest = """\ - template <int kInt, typename T, bool kBool> - void foo(); - - template<> - void foo<-7, float, true>(); - """ - -class TestCursor(unittest.TestCase): - def test_get_children(self): - tu = get_tu(kInput) - - it = tu.cursor.get_children() - tu_nodes = list(it) - - self.assertEqual(len(tu_nodes), 3) - for cursor in tu_nodes: - self.assertIsNotNone(cursor.translation_unit) - - self.assertNotEqual(tu_nodes[0], tu_nodes[1]) - self.assertEqual(tu_nodes[0].kind, CursorKind.STRUCT_DECL) - self.assertEqual(tu_nodes[0].spelling, 's0') - self.assertEqual(tu_nodes[0].is_definition(), True) - self.assertEqual(tu_nodes[0].location.file.name, 't.c') - self.assertEqual(tu_nodes[0].location.line, 1) - self.assertEqual(tu_nodes[0].location.column, 8) - self.assertGreater(tu_nodes[0].hash, 0) - self.assertIsNotNone(tu_nodes[0].translation_unit) - - s0_nodes = list(tu_nodes[0].get_children()) - self.assertEqual(len(s0_nodes), 2) - self.assertEqual(s0_nodes[0].kind, CursorKind.FIELD_DECL) - self.assertEqual(s0_nodes[0].spelling, 'a') - self.assertEqual(s0_nodes[0].type.kind, TypeKind.INT) - self.assertEqual(s0_nodes[1].kind, CursorKind.FIELD_DECL) - self.assertEqual(s0_nodes[1].spelling, 'b') - self.assertEqual(s0_nodes[1].type.kind, TypeKind.INT) - - self.assertEqual(tu_nodes[1].kind, CursorKind.STRUCT_DECL) - self.assertEqual(tu_nodes[1].spelling, 's1') - self.assertEqual(tu_nodes[1].displayname, 's1') - self.assertEqual(tu_nodes[1].is_definition(), False) - - self.assertEqual(tu_nodes[2].kind, CursorKind.FUNCTION_DECL) - self.assertEqual(tu_nodes[2].spelling, 'f0') - self.assertEqual(tu_nodes[2].displayname, 'f0(int, int)') - self.assertEqual(tu_nodes[2].is_definition(), True) - - def test_references(self): - """Ensure that references to TranslationUnit are kept.""" - tu = get_tu('int x;') - cursors = list(tu.cursor.get_children()) - self.assertGreater(len(cursors), 0) - - cursor = cursors[0] - self.assertIsInstance(cursor.translation_unit, TranslationUnit) - - # Delete reference to TU and perform a full GC. - del tu - gc.collect() - self.assertIsInstance(cursor.translation_unit, TranslationUnit) - - # If the TU was destroyed, this should cause a segfault. - parent = cursor.semantic_parent - - def test_canonical(self): - source = 'struct X; struct X; struct X { int member; };' - tu = get_tu(source) - - cursors = [] - for cursor in tu.cursor.get_children(): - if cursor.spelling == 'X': - cursors.append(cursor) - - self.assertEqual(len(cursors), 3) - self.assertEqual(cursors[1].canonical, cursors[2].canonical) - - def test_is_const_method(self): - """Ensure Cursor.is_const_method works.""" - source = 'class X { void foo() const; void bar(); };' - tu = get_tu(source, lang='cpp') - - cls = get_cursor(tu, 'X') - foo = get_cursor(tu, 'foo') - bar = get_cursor(tu, 'bar') - self.assertIsNotNone(cls) - self.assertIsNotNone(foo) - self.assertIsNotNone(bar) - - self.assertTrue(foo.is_const_method()) - self.assertFalse(bar.is_const_method()) - - def test_is_converting_constructor(self): - """Ensure Cursor.is_converting_constructor works.""" - source = 'class X { explicit X(int); X(double); X(); };' - tu = get_tu(source, lang='cpp') - - xs = get_cursors(tu, 'X') - - self.assertEqual(len(xs), 4) - self.assertEqual(xs[0].kind, CursorKind.CLASS_DECL) - cs = xs[1:] - self.assertEqual(cs[0].kind, CursorKind.CONSTRUCTOR) - self.assertEqual(cs[1].kind, CursorKind.CONSTRUCTOR) - self.assertEqual(cs[2].kind, CursorKind.CONSTRUCTOR) - - self.assertFalse(cs[0].is_converting_constructor()) - self.assertTrue(cs[1].is_converting_constructor()) - self.assertFalse(cs[2].is_converting_constructor()) - - - def test_is_copy_constructor(self): - """Ensure Cursor.is_copy_constructor works.""" - source = 'class X { X(); X(const X&); X(X&&); };' - tu = get_tu(source, lang='cpp') - - xs = get_cursors(tu, 'X') - self.assertEqual(xs[0].kind, CursorKind.CLASS_DECL) - cs = xs[1:] - self.assertEqual(cs[0].kind, CursorKind.CONSTRUCTOR) - self.assertEqual(cs[1].kind, CursorKind.CONSTRUCTOR) - self.assertEqual(cs[2].kind, CursorKind.CONSTRUCTOR) - - self.assertFalse(cs[0].is_copy_constructor()) - self.assertTrue(cs[1].is_copy_constructor()) - self.assertFalse(cs[2].is_copy_constructor()) - - def test_is_default_constructor(self): - """Ensure Cursor.is_default_constructor works.""" - source = 'class X { X(); X(int); };' - tu = get_tu(source, lang='cpp') - - xs = get_cursors(tu, 'X') - self.assertEqual(xs[0].kind, CursorKind.CLASS_DECL) - cs = xs[1:] - self.assertEqual(cs[0].kind, CursorKind.CONSTRUCTOR) - self.assertEqual(cs[1].kind, CursorKind.CONSTRUCTOR) - - self.assertTrue(cs[0].is_default_constructor()) - self.assertFalse(cs[1].is_default_constructor()) - - def test_is_move_constructor(self): - """Ensure Cursor.is_move_constructor works.""" - source = 'class X { X(); X(const X&); X(X&&); };' - tu = get_tu(source, lang='cpp') - - xs = get_cursors(tu, 'X') - self.assertEqual(xs[0].kind, CursorKind.CLASS_DECL) - cs = xs[1:] - self.assertEqual(cs[0].kind, CursorKind.CONSTRUCTOR) - self.assertEqual(cs[1].kind, CursorKind.CONSTRUCTOR) - self.assertEqual(cs[2].kind, CursorKind.CONSTRUCTOR) - - self.assertFalse(cs[0].is_move_constructor()) - self.assertFalse(cs[1].is_move_constructor()) - self.assertTrue(cs[2].is_move_constructor()) - - def test_is_default_method(self): - """Ensure Cursor.is_default_method works.""" - source = 'class X { X() = default; }; class Y { Y(); };' - tu = get_tu(source, lang='cpp') - - xs = get_cursors(tu, 'X') - ys = get_cursors(tu, 'Y') - - self.assertEqual(len(xs), 2) - self.assertEqual(len(ys), 2) - - xc = xs[1] - yc = ys[1] - - self.assertTrue(xc.is_default_method()) - self.assertFalse(yc.is_default_method()) - - def test_is_mutable_field(self): - """Ensure Cursor.is_mutable_field works.""" - source = 'class X { int x_; mutable int y_; };' - tu = get_tu(source, lang='cpp') - - cls = get_cursor(tu, 'X') - x_ = get_cursor(tu, 'x_') - y_ = get_cursor(tu, 'y_') - self.assertIsNotNone(cls) - self.assertIsNotNone(x_) - self.assertIsNotNone(y_) - - self.assertFalse(x_.is_mutable_field()) - self.assertTrue(y_.is_mutable_field()) - - def test_is_static_method(self): - """Ensure Cursor.is_static_method works.""" - - source = 'class X { static void foo(); void bar(); };' - tu = get_tu(source, lang='cpp') - - cls = get_cursor(tu, 'X') - foo = get_cursor(tu, 'foo') - bar = get_cursor(tu, 'bar') - self.assertIsNotNone(cls) - self.assertIsNotNone(foo) - self.assertIsNotNone(bar) - - self.assertTrue(foo.is_static_method()) - self.assertFalse(bar.is_static_method()) - - def test_is_pure_virtual_method(self): - """Ensure Cursor.is_pure_virtual_method works.""" - source = 'class X { virtual void foo() = 0; virtual void bar(); };' - tu = get_tu(source, lang='cpp') - - cls = get_cursor(tu, 'X') - foo = get_cursor(tu, 'foo') - bar = get_cursor(tu, 'bar') - self.assertIsNotNone(cls) - self.assertIsNotNone(foo) - self.assertIsNotNone(bar) - - self.assertTrue(foo.is_pure_virtual_method()) - self.assertFalse(bar.is_pure_virtual_method()) - - def test_is_virtual_method(self): - """Ensure Cursor.is_virtual_method works.""" - source = 'class X { virtual void foo(); void bar(); };' - tu = get_tu(source, lang='cpp') - - cls = get_cursor(tu, 'X') - foo = get_cursor(tu, 'foo') - bar = get_cursor(tu, 'bar') - self.assertIsNotNone(cls) - self.assertIsNotNone(foo) - self.assertIsNotNone(bar) - - self.assertTrue(foo.is_virtual_method()) - self.assertFalse(bar.is_virtual_method()) - - def test_is_abstract_record(self): - """Ensure Cursor.is_abstract_record works.""" - source = 'struct X { virtual void x() = 0; }; struct Y : X { void x(); };' - tu = get_tu(source, lang='cpp') - - cls = get_cursor(tu, 'X') - self.assertTrue(cls.is_abstract_record()) - - cls = get_cursor(tu, 'Y') - self.assertFalse(cls.is_abstract_record()) - - def test_is_scoped_enum(self): - """Ensure Cursor.is_scoped_enum works.""" - source = 'class X {}; enum RegularEnum {}; enum class ScopedEnum {};' - tu = get_tu(source, lang='cpp') - - cls = get_cursor(tu, 'X') - regular_enum = get_cursor(tu, 'RegularEnum') - scoped_enum = get_cursor(tu, 'ScopedEnum') - self.assertIsNotNone(cls) - self.assertIsNotNone(regular_enum) - self.assertIsNotNone(scoped_enum) - - self.assertFalse(cls.is_scoped_enum()) - self.assertFalse(regular_enum.is_scoped_enum()) - self.assertTrue(scoped_enum.is_scoped_enum()) - - def test_underlying_type(self): - tu = get_tu('typedef int foo;') - typedef = get_cursor(tu, 'foo') - self.assertIsNotNone(typedef) - - self.assertTrue(typedef.kind.is_declaration()) - underlying = typedef.underlying_typedef_type - self.assertEqual(underlying.kind, TypeKind.INT) - - def test_semantic_parent(self): - tu = get_tu(kParentTest, 'cpp') - curs = get_cursors(tu, 'f') - decl = get_cursor(tu, 'C') - self.assertEqual(len(curs), 2) - self.assertEqual(curs[0].semantic_parent, curs[1].semantic_parent) - self.assertEqual(curs[0].semantic_parent, decl) - - def test_lexical_parent(self): - tu = get_tu(kParentTest, 'cpp') - curs = get_cursors(tu, 'f') - decl = get_cursor(tu, 'C') - self.assertEqual(len(curs), 2) - self.assertNotEqual(curs[0].lexical_parent, curs[1].lexical_parent) - self.assertEqual(curs[0].lexical_parent, decl) - self.assertEqual(curs[1].lexical_parent, tu.cursor) - - def test_enum_type(self): - tu = get_tu('enum TEST { FOO=1, BAR=2 };') - enum = get_cursor(tu, 'TEST') - self.assertIsNotNone(enum) - - self.assertEqual(enum.kind, CursorKind.ENUM_DECL) - enum_type = enum.enum_type - self.assertIn(enum_type.kind, (TypeKind.UINT, TypeKind.INT)) - - def test_enum_type_cpp(self): - tu = get_tu('enum TEST : long long { FOO=1, BAR=2 };', lang="cpp") - enum = get_cursor(tu, 'TEST') - self.assertIsNotNone(enum) - - self.assertEqual(enum.kind, CursorKind.ENUM_DECL) - self.assertEqual(enum.enum_type.kind, TypeKind.LONGLONG) - - def test_objc_type_encoding(self): - tu = get_tu('int i;', lang='objc') - i = get_cursor(tu, 'i') - - self.assertIsNotNone(i) - self.assertEqual(i.objc_type_encoding, 'i') - - def test_enum_values(self): - tu = get_tu('enum TEST { SPAM=1, EGG, HAM = EGG * 20};') - enum = get_cursor(tu, 'TEST') - self.assertIsNotNone(enum) - - self.assertEqual(enum.kind, CursorKind.ENUM_DECL) - - enum_constants = list(enum.get_children()) - self.assertEqual(len(enum_constants), 3) - - spam, egg, ham = enum_constants - - self.assertEqual(spam.kind, CursorKind.ENUM_CONSTANT_DECL) - self.assertEqual(spam.enum_value, 1) - self.assertEqual(egg.kind, CursorKind.ENUM_CONSTANT_DECL) - self.assertEqual(egg.enum_value, 2) - self.assertEqual(ham.kind, CursorKind.ENUM_CONSTANT_DECL) - self.assertEqual(ham.enum_value, 40) - - def test_enum_values_cpp(self): - tu = get_tu('enum TEST : long long { SPAM = -1, HAM = 0x10000000000};', lang="cpp") - enum = get_cursor(tu, 'TEST') - self.assertIsNotNone(enum) - - self.assertEqual(enum.kind, CursorKind.ENUM_DECL) - - enum_constants = list(enum.get_children()) - self.assertEqual(len(enum_constants), 2) - - spam, ham = enum_constants - - self.assertEqual(spam.kind, CursorKind.ENUM_CONSTANT_DECL) - self.assertEqual(spam.enum_value, -1) - self.assertEqual(ham.kind, CursorKind.ENUM_CONSTANT_DECL) - self.assertEqual(ham.enum_value, 0x10000000000) - - def test_annotation_attribute(self): - tu = get_tu('int foo (void) __attribute__ ((annotate("here be annotation attribute")));') - - foo = get_cursor(tu, 'foo') - self.assertIsNotNone(foo) - - for c in foo.get_children(): - if c.kind == CursorKind.ANNOTATE_ATTR: - self.assertEqual(c.displayname, "here be annotation attribute") - break - else: - self.fail("Couldn't find annotation") - - def test_annotation_template(self): - annotation = '__attribute__ ((annotate("annotation")))' - for source, kind in [ - ('int foo (T value) %s;', CursorKind.FUNCTION_TEMPLATE), - ('class %s foo {};', CursorKind.CLASS_TEMPLATE), - ]: - source = 'template<typename T> ' + (source % annotation) - tu = get_tu(source, lang="cpp") - - foo = get_cursor(tu, 'foo') - self.assertIsNotNone(foo) - self.assertEqual(foo.kind, kind) - - for c in foo.get_children(): - if c.kind == CursorKind.ANNOTATE_ATTR: - self.assertEqual(c.displayname, "annotation") - break - else: - self.fail("Couldn't find annotation for {}".format(kind)) - - def test_result_type(self): - tu = get_tu('int foo();') - foo = get_cursor(tu, 'foo') - - self.assertIsNotNone(foo) - t = foo.result_type - self.assertEqual(t.kind, TypeKind.INT) - - def test_result_type_objc_method_decl(self): - code = """\ - @interface Interface : NSObject - -(void)voidMethod; - @end - """ - tu = get_tu(code, lang='objc') - cursor = get_cursor(tu, 'voidMethod') - result_type = cursor.result_type - self.assertEqual(cursor.kind, CursorKind.OBJC_INSTANCE_METHOD_DECL) - self.assertEqual(result_type.kind, TypeKind.VOID) - - def test_availability(self): - tu = get_tu('class A { A(A const&) = delete; };', lang='cpp') - - # AvailabilityKind.AVAILABLE - cursor = get_cursor(tu, 'A') - self.assertEqual(cursor.kind, CursorKind.CLASS_DECL) - self.assertEqual(cursor.availability, AvailabilityKind.AVAILABLE) - - # AvailabilityKind.NOT_AVAILABLE - cursors = get_cursors(tu, 'A') - for c in cursors: - if c.kind == CursorKind.CONSTRUCTOR: - self.assertEqual(c.availability, AvailabilityKind.NOT_AVAILABLE) - break - else: - self.fail("Could not find cursor for deleted constructor") - - # AvailabilityKind.DEPRECATED - tu = get_tu('void test() __attribute__((deprecated));', lang='cpp') - cursor = get_cursor(tu, 'test') - self.assertEqual(cursor.availability, AvailabilityKind.DEPRECATED) - - # AvailabilityKind.NOT_ACCESSIBLE is only used in the code completion results - - def test_get_tokens(self): - """Ensure we can map cursors back to tokens.""" - tu = get_tu('int foo(int i);') - foo = get_cursor(tu, 'foo') - - tokens = list(foo.get_tokens()) - self.assertEqual(len(tokens), 6) - self.assertEqual(tokens[0].spelling, 'int') - self.assertEqual(tokens[1].spelling, 'foo') - - def test_get_token_cursor(self): - """Ensure we can map tokens to cursors.""" - tu = get_tu('class A {}; int foo(A var = A());', lang='cpp') - foo = get_cursor(tu, 'foo') - - for cursor in foo.walk_preorder(): - if cursor.kind.is_expression() and not cursor.kind.is_statement(): - break - else: - self.fail("Could not find default value expression") - - tokens = list(cursor.get_tokens()) - self.assertEqual(len(tokens), 4, [t.spelling for t in tokens]) - self.assertEqual(tokens[0].spelling, '=') - self.assertEqual(tokens[1].spelling, 'A') - self.assertEqual(tokens[2].spelling, '(') - self.assertEqual(tokens[3].spelling, ')') - t_cursor = tokens[1].cursor - self.assertEqual(t_cursor.kind, CursorKind.TYPE_REF) - r_cursor = t_cursor.referenced # should not raise an exception - self.assertEqual(r_cursor.kind, CursorKind.CLASS_DECL) - - def test_get_arguments(self): - tu = get_tu('void foo(int i, int j);') - foo = get_cursor(tu, 'foo') - arguments = list(foo.get_arguments()) - - self.assertEqual(len(arguments), 2) - self.assertEqual(arguments[0].spelling, "i") - self.assertEqual(arguments[1].spelling, "j") - - def test_get_num_template_arguments(self): - tu = get_tu(kTemplateArgTest, lang='cpp') - foos = get_cursors(tu, 'foo') - - self.assertEqual(foos[1].get_num_template_arguments(), 3) - - def test_get_template_argument_kind(self): - tu = get_tu(kTemplateArgTest, lang='cpp') - foos = get_cursors(tu, 'foo') - - self.assertEqual(foos[1].get_template_argument_kind(0), TemplateArgumentKind.INTEGRAL) - self.assertEqual(foos[1].get_template_argument_kind(1), TemplateArgumentKind.TYPE) - self.assertEqual(foos[1].get_template_argument_kind(2), TemplateArgumentKind.INTEGRAL) - - def test_get_template_argument_type(self): - tu = get_tu(kTemplateArgTest, lang='cpp') - foos = get_cursors(tu, 'foo') - - self.assertEqual(foos[1].get_template_argument_type(1).kind, TypeKind.FLOAT) - - def test_get_template_argument_value(self): - tu = get_tu(kTemplateArgTest, lang='cpp') - foos = get_cursors(tu, 'foo') - - self.assertEqual(foos[1].get_template_argument_value(0), -7) - self.assertEqual(foos[1].get_template_argument_value(2), True) - - def test_get_template_argument_unsigned_value(self): - tu = get_tu(kTemplateArgTest, lang='cpp') - foos = get_cursors(tu, 'foo') - - self.assertEqual(foos[1].get_template_argument_unsigned_value(0), 2 ** 32 - 7) - self.assertEqual(foos[1].get_template_argument_unsigned_value(2), True) - - def test_referenced(self): - tu = get_tu('void foo(); void bar() { foo(); }') - foo = get_cursor(tu, 'foo') - bar = get_cursor(tu, 'bar') - for c in bar.get_children(): - if c.kind == CursorKind.CALL_EXPR: - self.assertEqual(c.referenced.spelling, foo.spelling) - break - - def test_mangled_name(self): - kInputForMangling = """\ - int foo(int, int); - """ - tu = get_tu(kInputForMangling, lang='cpp') - foo = get_cursor(tu, 'foo') - - # Since libclang does not link in targets, we cannot pass a triple to it - # and force the target. To enable this test to pass on all platforms, accept - # all valid manglings. - # [c-index-test handles this by running the source through clang, emitting - # an AST file and running libclang on that AST file] - self.assertIn(foo.mangled_name, ('_Z3fooii', '__Z3fooii', '?foo@@YAHHH', '?foo@@YAHHH@Z')) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_cursor_kind.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_cursor_kind.py deleted file mode 100644 index e6b9558b3cc..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_cursor_kind.py +++ /dev/null @@ -1,58 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -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) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_diagnostics.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_diagnostics.py deleted file mode 100644 index c17d5b28efe..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_diagnostics.py +++ /dev/null @@ -1,110 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -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"; }') - 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, 23) - 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">') diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_exception_specification_kind.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_exception_specification_kind.py deleted file mode 100644 index 6c13f70fb25..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_exception_specification_kind.py +++ /dev/null @@ -1,35 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -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) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_file.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_file.py deleted file mode 100644 index a146fe5c923..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_file.py +++ /dev/null @@ -1,18 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -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>") diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_index.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_index.py deleted file mode 100644 index 46aafcf222e..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_index.py +++ /dev/null @@ -1,26 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -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) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_linkage.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_linkage.py deleted file mode 100644 index cdd97fc2df0..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_linkage.py +++ /dev/null @@ -1,38 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -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) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_location.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_location.py deleted file mode 100644 index fbe9770d7eb..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_location.py +++ /dev/null @@ -1,105 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -from clang.cindex import Cursor -from clang.cindex import File -from clang.cindex import SourceLocation -from clang.cindex import SourceRange -from .util import get_cursor -from .util import get_tu - -import unittest - - -baseInput="int one;\nint two;\n" - - -class TestLocation(unittest.TestCase): - def assert_location(self, loc, line, column, offset): - self.assertEqual(loc.line, line) - self.assertEqual(loc.column, column) - self.assertEqual(loc.offset, offset) - - def test_location(self): - tu = get_tu(baseInput) - one = get_cursor(tu, 'one') - two = get_cursor(tu, 'two') - - self.assertIsNotNone(one) - self.assertIsNotNone(two) - - self.assert_location(one.location,line=1,column=5,offset=4) - self.assert_location(two.location,line=2,column=5,offset=13) - - # adding a linebreak at top should keep columns same - tu = get_tu('\n' + baseInput) - one = get_cursor(tu, 'one') - two = get_cursor(tu, 'two') - - self.assertIsNotNone(one) - self.assertIsNotNone(two) - - self.assert_location(one.location,line=2,column=5,offset=5) - self.assert_location(two.location,line=3,column=5,offset=14) - - # adding a space should affect column on first line only - tu = get_tu(' ' + baseInput) - one = get_cursor(tu, 'one') - two = get_cursor(tu, 'two') - - self.assert_location(one.location,line=1,column=6,offset=5) - self.assert_location(two.location,line=2,column=5,offset=14) - - # define the expected location ourselves and see if it matches - # the returned location - tu = get_tu(baseInput) - - file = File.from_name(tu, 't.c') - location = SourceLocation.from_position(tu, file, 1, 5) - cursor = Cursor.from_location(tu, location) - - one = get_cursor(tu, 'one') - self.assertIsNotNone(one) - self.assertEqual(one, cursor) - - # Ensure locations referring to the same entity are equivalent. - location2 = SourceLocation.from_position(tu, file, 1, 5) - self.assertEqual(location, location2) - location3 = SourceLocation.from_position(tu, file, 1, 4) - self.assertNotEqual(location2, location3) - - offset_location = SourceLocation.from_offset(tu, file, 5) - cursor = Cursor.from_location(tu, offset_location) - verified = False - for n in [n for n in tu.cursor.get_children() if n.spelling == 'one']: - self.assertEqual(n, cursor) - verified = True - - self.assertTrue(verified) - - def test_extent(self): - tu = get_tu(baseInput) - one = get_cursor(tu, 'one') - two = get_cursor(tu, 'two') - - self.assert_location(one.extent.start,line=1,column=1,offset=0) - self.assert_location(one.extent.end,line=1,column=8,offset=7) - self.assertEqual(baseInput[one.extent.start.offset:one.extent.end.offset], "int one") - - self.assert_location(two.extent.start,line=2,column=1,offset=9) - self.assert_location(two.extent.end,line=2,column=8,offset=16) - self.assertEqual(baseInput[two.extent.start.offset:two.extent.end.offset], "int two") - - file = File.from_name(tu, 't.c') - location1 = SourceLocation.from_position(tu, file, 1, 1) - location2 = SourceLocation.from_position(tu, file, 1, 8) - - range1 = SourceRange.from_locations(location1, location2) - range2 = SourceRange.from_locations(location1, location2) - self.assertEqual(range1, range2) - - location3 = SourceLocation.from_position(tu, file, 1, 6) - range3 = SourceRange.from_locations(location1, location3) - self.assertNotEqual(range1, range3) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_tls_kind.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_tls_kind.py deleted file mode 100644 index c828ac83a46..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_tls_kind.py +++ /dev/null @@ -1,54 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -from clang.cindex import TLSKind -from clang.cindex import Cursor -from clang.cindex import TranslationUnit - -from .util import get_cursor -from .util import get_tu - -import unittest - - -class TestTLSKind(unittest.TestCase): - def test_tls_kind(self): - """Ensure that thread-local storage kinds are available on cursors.""" - - tu = get_tu(""" -int tls_none; -thread_local int tls_dynamic; -_Thread_local int tls_static; -""", lang = 'cpp') - - tls_none = get_cursor(tu.cursor, 'tls_none') - self.assertEqual(tls_none.tls_kind, TLSKind.NONE) - - tls_dynamic = get_cursor(tu.cursor, 'tls_dynamic') - self.assertEqual(tls_dynamic.tls_kind, TLSKind.DYNAMIC) - - tls_static = get_cursor(tu.cursor, 'tls_static') - self.assertEqual(tls_static.tls_kind, TLSKind.STATIC) - - # The following case tests '__declspec(thread)'. Since it is a Microsoft - # specific extension, specific flags are required for the parser to pick - # these up. - flags = ['-fms-extensions', '-target', 'x86_64-unknown-windows-win32', - '-fms-compatibility-version=18'] - tu = get_tu(""" -__declspec(thread) int tls_declspec_msvc18; -""", lang = 'cpp', flags=flags) - - tls_declspec_msvc18 = get_cursor(tu.cursor, 'tls_declspec_msvc18') - self.assertEqual(tls_declspec_msvc18.tls_kind, TLSKind.STATIC) - - flags = ['-fms-extensions', '-target', 'x86_64-unknown-windows-win32', - '-fms-compatibility-version=19'] - tu = get_tu(""" -__declspec(thread) int tls_declspec_msvc19; -""", lang = 'cpp', flags=flags) - - tls_declspec_msvc19 = get_cursor(tu.cursor, 'tls_declspec_msvc19') - self.assertEqual(tls_declspec_msvc19.tls_kind, TLSKind.DYNAMIC) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_token_kind.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_token_kind.py deleted file mode 100644 index 904e007cafc..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_token_kind.py +++ /dev/null @@ -1,49 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -from clang.cindex import TokenKind - -import unittest - - -class TestTokenKind(unittest.TestCase): - def test_constructor(self): - """Ensure TokenKind constructor works as expected.""" - - t = TokenKind(5, 'foo') - - self.assertEqual(t.value, 5) - self.assertEqual(t.name, 'foo') - - def test_bad_register(self): - """Ensure a duplicate value is rejected for registration.""" - - with self.assertRaises(ValueError): - TokenKind.register(2, 'foo') - - def test_unknown_value(self): - """Ensure trying to fetch an unknown value raises.""" - - with self.assertRaises(ValueError): - TokenKind.from_value(-1) - - def test_registration(self): - """Ensure that items registered appear as class attributes.""" - self.assertTrue(hasattr(TokenKind, 'LITERAL')) - literal = TokenKind.LITERAL - - self.assertIsInstance(literal, TokenKind) - - def test_from_value(self): - """Ensure registered values can be obtained from from_value().""" - t = TokenKind.from_value(3) - self.assertIsInstance(t, TokenKind) - self.assertEqual(t, TokenKind.LITERAL) - - def test_repr(self): - """Ensure repr() works.""" - - r = repr(TokenKind.LITERAL) - self.assertEqual(r, 'TokenKind.LITERAL') diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_tokens.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_tokens.py deleted file mode 100644 index dd6d3a3259e..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_tokens.py +++ /dev/null @@ -1,59 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -from clang.cindex import CursorKind -from clang.cindex import Index -from clang.cindex import SourceLocation -from clang.cindex import SourceRange -from clang.cindex import TokenKind - -from .util import get_tu - -import unittest - - -class TestTokens(unittest.TestCase): - def test_token_to_cursor(self): - """Ensure we can obtain a Cursor from a Token instance.""" - tu = get_tu('int i = 5;') - r = tu.get_extent('t.c', (0, 9)) - tokens = list(tu.get_tokens(extent=r)) - - self.assertEqual(len(tokens), 4) - self.assertEqual(tokens[1].spelling, 'i') - self.assertEqual(tokens[1].kind, TokenKind.IDENTIFIER) - - cursor = tokens[1].cursor - self.assertEqual(cursor.kind, CursorKind.VAR_DECL) - self.assertEqual(tokens[1].cursor, tokens[2].cursor) - - def test_token_location(self): - """Ensure Token.location works.""" - - tu = get_tu('int foo = 10;') - r = tu.get_extent('t.c', (0, 11)) - - tokens = list(tu.get_tokens(extent=r)) - self.assertEqual(len(tokens), 4) - - loc = tokens[1].location - self.assertIsInstance(loc, SourceLocation) - self.assertEqual(loc.line, 1) - self.assertEqual(loc.column, 5) - self.assertEqual(loc.offset, 4) - - def test_token_extent(self): - """Ensure Token.extent works.""" - tu = get_tu('int foo = 10;') - r = tu.get_extent('t.c', (0, 11)) - - tokens = list(tu.get_tokens(extent=r)) - self.assertEqual(len(tokens), 4) - - extent = tokens[1].extent - self.assertIsInstance(extent, SourceRange) - - self.assertEqual(extent.start.offset, 4) - self.assertEqual(extent.end.offset, 7) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_translation_unit.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_translation_unit.py deleted file mode 100644 index f3e770a9361..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_translation_unit.py +++ /dev/null @@ -1,338 +0,0 @@ -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) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_type.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_type.py deleted file mode 100644 index bcdbeff9d99..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/test_type.py +++ /dev/null @@ -1,468 +0,0 @@ -import os -from clang.cindex import Config -if 'CLANG_LIBRARY_PATH' in os.environ: - Config.set_library_path(os.environ['CLANG_LIBRARY_PATH']) - -import gc -import unittest - -from clang.cindex import CursorKind -from clang.cindex import TranslationUnit -from clang.cindex import TypeKind -from .util import get_cursor -from .util import get_tu - - -kInput = """\ - -typedef int I; - -struct teststruct { - int a; - I b; - long c; - unsigned long d; - signed long e; - const int f; - int *g; - int ***h; -}; - -""" - - -constarrayInput=""" -struct teststruct { - void *A[2]; -}; -""" - - -class TestType(unittest.TestCase): - def test_a_struct(self): - tu = get_tu(kInput) - - teststruct = get_cursor(tu, 'teststruct') - self.assertIsNotNone(teststruct, "Could not find teststruct.") - fields = list(teststruct.get_children()) - - self.assertEqual(fields[0].kind, CursorKind.FIELD_DECL) - self.assertIsNotNone(fields[0].translation_unit) - self.assertEqual(fields[0].spelling, 'a') - self.assertFalse(fields[0].type.is_const_qualified()) - self.assertEqual(fields[0].type.kind, TypeKind.INT) - self.assertEqual(fields[0].type.get_canonical().kind, TypeKind.INT) - self.assertEqual(fields[0].type.get_typedef_name(), '') - - self.assertEqual(fields[1].kind, CursorKind.FIELD_DECL) - self.assertIsNotNone(fields[1].translation_unit) - self.assertEqual(fields[1].spelling, 'b') - self.assertFalse(fields[1].type.is_const_qualified()) - self.assertEqual(fields[1].type.kind, TypeKind.TYPEDEF) - self.assertEqual(fields[1].type.get_canonical().kind, TypeKind.INT) - self.assertEqual(fields[1].type.get_declaration().spelling, 'I') - self.assertEqual(fields[1].type.get_typedef_name(), 'I') - - self.assertEqual(fields[2].kind, CursorKind.FIELD_DECL) - self.assertIsNotNone(fields[2].translation_unit) - self.assertEqual(fields[2].spelling, 'c') - self.assertFalse(fields[2].type.is_const_qualified()) - self.assertEqual(fields[2].type.kind, TypeKind.LONG) - self.assertEqual(fields[2].type.get_canonical().kind, TypeKind.LONG) - self.assertEqual(fields[2].type.get_typedef_name(), '') - - self.assertEqual(fields[3].kind, CursorKind.FIELD_DECL) - self.assertIsNotNone(fields[3].translation_unit) - self.assertEqual(fields[3].spelling, 'd') - self.assertFalse(fields[3].type.is_const_qualified()) - self.assertEqual(fields[3].type.kind, TypeKind.ULONG) - self.assertEqual(fields[3].type.get_canonical().kind, TypeKind.ULONG) - self.assertEqual(fields[3].type.get_typedef_name(), '') - - self.assertEqual(fields[4].kind, CursorKind.FIELD_DECL) - self.assertIsNotNone(fields[4].translation_unit) - self.assertEqual(fields[4].spelling, 'e') - self.assertFalse(fields[4].type.is_const_qualified()) - self.assertEqual(fields[4].type.kind, TypeKind.LONG) - self.assertEqual(fields[4].type.get_canonical().kind, TypeKind.LONG) - self.assertEqual(fields[4].type.get_typedef_name(), '') - - self.assertEqual(fields[5].kind, CursorKind.FIELD_DECL) - self.assertIsNotNone(fields[5].translation_unit) - self.assertEqual(fields[5].spelling, 'f') - self.assertTrue(fields[5].type.is_const_qualified()) - self.assertEqual(fields[5].type.kind, TypeKind.INT) - self.assertEqual(fields[5].type.get_canonical().kind, TypeKind.INT) - self.assertEqual(fields[5].type.get_typedef_name(), '') - - self.assertEqual(fields[6].kind, CursorKind.FIELD_DECL) - self.assertIsNotNone(fields[6].translation_unit) - self.assertEqual(fields[6].spelling, 'g') - self.assertFalse(fields[6].type.is_const_qualified()) - self.assertEqual(fields[6].type.kind, TypeKind.POINTER) - self.assertEqual(fields[6].type.get_pointee().kind, TypeKind.INT) - self.assertEqual(fields[6].type.get_typedef_name(), '') - - self.assertEqual(fields[7].kind, CursorKind.FIELD_DECL) - self.assertIsNotNone(fields[7].translation_unit) - self.assertEqual(fields[7].spelling, 'h') - self.assertFalse(fields[7].type.is_const_qualified()) - self.assertEqual(fields[7].type.kind, TypeKind.POINTER) - self.assertEqual(fields[7].type.get_pointee().kind, TypeKind.POINTER) - self.assertEqual(fields[7].type.get_pointee().get_pointee().kind, TypeKind.POINTER) - self.assertEqual(fields[7].type.get_pointee().get_pointee().get_pointee().kind, TypeKind.INT) - self.assertEqual(fields[7].type.get_typedef_name(), '') - - def test_references(self): - """Ensure that a Type maintains a reference to a TranslationUnit.""" - - tu = get_tu('int x;') - children = list(tu.cursor.get_children()) - self.assertGreater(len(children), 0) - - cursor = children[0] - t = cursor.type - - self.assertIsInstance(t.translation_unit, TranslationUnit) - - # Delete main TranslationUnit reference and force a GC. - del tu - gc.collect() - self.assertIsInstance(t.translation_unit, TranslationUnit) - - # If the TU was destroyed, this should cause a segfault. - decl = t.get_declaration() - - def testConstantArray(self): - tu = get_tu(constarrayInput) - - teststruct = get_cursor(tu, 'teststruct') - self.assertIsNotNone(teststruct, "Didn't find teststruct??") - fields = list(teststruct.get_children()) - self.assertEqual(fields[0].spelling, 'A') - self.assertEqual(fields[0].type.kind, TypeKind.CONSTANTARRAY) - self.assertIsNotNone(fields[0].type.get_array_element_type()) - self.assertEqual(fields[0].type.get_array_element_type().kind, TypeKind.POINTER) - self.assertEqual(fields[0].type.get_array_size(), 2) - - def test_equal(self): - """Ensure equivalence operators work on Type.""" - source = 'int a; int b; void *v;' - tu = get_tu(source) - - a = get_cursor(tu, 'a') - b = get_cursor(tu, 'b') - v = get_cursor(tu, 'v') - - self.assertIsNotNone(a) - self.assertIsNotNone(b) - self.assertIsNotNone(v) - - self.assertEqual(a.type, b.type) - self.assertNotEqual(a.type, v.type) - - self.assertNotEqual(a.type, None) - self.assertNotEqual(a.type, 'foo') - - def test_type_spelling(self): - """Ensure Type.spelling works.""" - tu = get_tu('int c[5]; void f(int i[]); int x; int v[x];') - c = get_cursor(tu, 'c') - i = get_cursor(tu, 'i') - x = get_cursor(tu, 'x') - v = get_cursor(tu, 'v') - self.assertIsNotNone(c) - self.assertIsNotNone(i) - self.assertIsNotNone(x) - self.assertIsNotNone(v) - self.assertEqual(c.type.spelling, "int [5]") - self.assertEqual(i.type.spelling, "int []") - self.assertEqual(x.type.spelling, "int") - self.assertEqual(v.type.spelling, "int [x]") - - def test_typekind_spelling(self): - """Ensure TypeKind.spelling works.""" - tu = get_tu('int a;') - a = get_cursor(tu, 'a') - - self.assertIsNotNone(a) - self.assertEqual(a.type.kind.spelling, 'Int') - - def test_function_argument_types(self): - """Ensure that Type.argument_types() works as expected.""" - tu = get_tu('void f(int, int);') - f = get_cursor(tu, 'f') - self.assertIsNotNone(f) - - args = f.type.argument_types() - self.assertIsNotNone(args) - self.assertEqual(len(args), 2) - - t0 = args[0] - self.assertIsNotNone(t0) - self.assertEqual(t0.kind, TypeKind.INT) - - t1 = args[1] - self.assertIsNotNone(t1) - self.assertEqual(t1.kind, TypeKind.INT) - - args2 = list(args) - self.assertEqual(len(args2), 2) - self.assertEqual(t0, args2[0]) - self.assertEqual(t1, args2[1]) - - def test_argument_types_string_key(self): - """Ensure that non-int keys raise a TypeError.""" - tu = get_tu('void f(int, int);') - f = get_cursor(tu, 'f') - self.assertIsNotNone(f) - - args = f.type.argument_types() - self.assertEqual(len(args), 2) - - with self.assertRaises(TypeError): - args['foo'] - - def test_argument_types_negative_index(self): - """Ensure that negative indexes on argument_types Raises an IndexError.""" - tu = get_tu('void f(int, int);') - f = get_cursor(tu, 'f') - args = f.type.argument_types() - - with self.assertRaises(IndexError): - args[-1] - - def test_argument_types_overflow_index(self): - """Ensure that indexes beyond the length of Type.argument_types() raise.""" - tu = get_tu('void f(int, int);') - f = get_cursor(tu, 'f') - args = f.type.argument_types() - - with self.assertRaises(IndexError): - args[2] - - def test_argument_types_invalid_type(self): - """Ensure that obtaining argument_types on a Type without them raises.""" - tu = get_tu('int i;') - i = get_cursor(tu, 'i') - self.assertIsNotNone(i) - - with self.assertRaises(Exception): - i.type.argument_types() - - def test_is_pod(self): - """Ensure Type.is_pod() works.""" - tu = get_tu('int i; void f();') - i = get_cursor(tu, 'i') - f = get_cursor(tu, 'f') - - self.assertIsNotNone(i) - self.assertIsNotNone(f) - - self.assertTrue(i.type.is_pod()) - self.assertFalse(f.type.is_pod()) - - def test_function_variadic(self): - """Ensure Type.is_function_variadic works.""" - - source =""" -#include <stdarg.h> - - void foo(int a, ...); - void bar(int a, int b); - """ - - tu = get_tu(source) - foo = get_cursor(tu, 'foo') - bar = get_cursor(tu, 'bar') - - self.assertIsNotNone(foo) - self.assertIsNotNone(bar) - - self.assertIsInstance(foo.type.is_function_variadic(), bool) - self.assertTrue(foo.type.is_function_variadic()) - self.assertFalse(bar.type.is_function_variadic()) - - def test_element_type(self): - """Ensure Type.element_type works.""" - tu = get_tu('int c[5]; void f(int i[]); int x; int v[x];') - c = get_cursor(tu, 'c') - i = get_cursor(tu, 'i') - v = get_cursor(tu, 'v') - self.assertIsNotNone(c) - self.assertIsNotNone(i) - self.assertIsNotNone(v) - - self.assertEqual(c.type.kind, TypeKind.CONSTANTARRAY) - self.assertEqual(c.type.element_type.kind, TypeKind.INT) - self.assertEqual(i.type.kind, TypeKind.INCOMPLETEARRAY) - self.assertEqual(i.type.element_type.kind, TypeKind.INT) - self.assertEqual(v.type.kind, TypeKind.VARIABLEARRAY) - self.assertEqual(v.type.element_type.kind, TypeKind.INT) - - def test_invalid_element_type(self): - """Ensure Type.element_type raises if type doesn't have elements.""" - tu = get_tu('int i;') - i = get_cursor(tu, 'i') - self.assertIsNotNone(i) - with self.assertRaises(Exception): - i.element_type - - def test_element_count(self): - """Ensure Type.element_count works.""" - tu = get_tu('int i[5]; int j;') - i = get_cursor(tu, 'i') - j = get_cursor(tu, 'j') - - self.assertIsNotNone(i) - self.assertIsNotNone(j) - - self.assertEqual(i.type.element_count, 5) - - with self.assertRaises(Exception): - j.type.element_count - - def test_is_volatile_qualified(self): - """Ensure Type.is_volatile_qualified works.""" - - tu = get_tu('volatile int i = 4; int j = 2;') - - i = get_cursor(tu, 'i') - j = get_cursor(tu, 'j') - - self.assertIsNotNone(i) - self.assertIsNotNone(j) - - self.assertIsInstance(i.type.is_volatile_qualified(), bool) - self.assertTrue(i.type.is_volatile_qualified()) - self.assertFalse(j.type.is_volatile_qualified()) - - def test_is_restrict_qualified(self): - """Ensure Type.is_restrict_qualified works.""" - - tu = get_tu('struct s { void * restrict i; void * j; };') - - i = get_cursor(tu, 'i') - j = get_cursor(tu, 'j') - - self.assertIsNotNone(i) - self.assertIsNotNone(j) - - self.assertIsInstance(i.type.is_restrict_qualified(), bool) - self.assertTrue(i.type.is_restrict_qualified()) - self.assertFalse(j.type.is_restrict_qualified()) - - def test_record_layout(self): - """Ensure Cursor.type.get_size, Cursor.type.get_align and - Cursor.type.get_offset works.""" - - source =""" - struct a { - long a1; - long a2:3; - long a3:4; - long long a4; - }; - """ - tries=[(['-target','i386-linux-gnu'],(4,16,0,32,35,64)), - (['-target','nvptx64-unknown-unknown'],(8,24,0,64,67,128)), - (['-target','i386-pc-win32'],(8,16,0,32,35,64)), - (['-target','msp430-none-none'],(2,14,0,32,35,48))] - for flags, values in tries: - align,total,a1,a2,a3,a4 = values - - tu = get_tu(source, flags=flags) - teststruct = get_cursor(tu, 'a') - fields = list(teststruct.get_children()) - - self.assertEqual(teststruct.type.get_align(), align) - self.assertEqual(teststruct.type.get_size(), total) - self.assertEqual(teststruct.type.get_offset(fields[0].spelling), a1) - self.assertEqual(teststruct.type.get_offset(fields[1].spelling), a2) - self.assertEqual(teststruct.type.get_offset(fields[2].spelling), a3) - self.assertEqual(teststruct.type.get_offset(fields[3].spelling), a4) - self.assertEqual(fields[0].is_bitfield(), False) - self.assertEqual(fields[1].is_bitfield(), True) - self.assertEqual(fields[1].get_bitfield_width(), 3) - self.assertEqual(fields[2].is_bitfield(), True) - self.assertEqual(fields[2].get_bitfield_width(), 4) - self.assertEqual(fields[3].is_bitfield(), False) - - def test_offset(self): - """Ensure Cursor.get_record_field_offset works in anonymous records""" - source=""" - struct Test { - struct {int a;} typeanon; - struct { - int bariton; - union { - int foo; - }; - }; - int bar; - };""" - tries=[(['-target','i386-linux-gnu'],(4,16,0,32,64,96)), - (['-target','nvptx64-unknown-unknown'],(8,24,0,32,64,96)), - (['-target','i386-pc-win32'],(8,16,0,32,64,96)), - (['-target','msp430-none-none'],(2,14,0,32,64,96))] - for flags, values in tries: - align,total,f1,bariton,foo,bar = values - tu = get_tu(source) - teststruct = get_cursor(tu, 'Test') - children = list(teststruct.get_children()) - fields = list(teststruct.type.get_fields()) - self.assertEqual(children[0].kind, CursorKind.STRUCT_DECL) - self.assertNotEqual(children[0].spelling, "typeanon") - self.assertEqual(children[1].spelling, "typeanon") - self.assertEqual(fields[0].kind, CursorKind.FIELD_DECL) - self.assertEqual(fields[1].kind, CursorKind.FIELD_DECL) - self.assertTrue(fields[1].is_anonymous()) - self.assertEqual(teststruct.type.get_offset("typeanon"), f1) - self.assertEqual(teststruct.type.get_offset("bariton"), bariton) - self.assertEqual(teststruct.type.get_offset("foo"), foo) - self.assertEqual(teststruct.type.get_offset("bar"), bar) - - def test_decay(self): - """Ensure decayed types are handled as the original type""" - - tu = get_tu("void foo(int a[]);") - foo = get_cursor(tu, 'foo') - a = foo.type.argument_types()[0] - - self.assertEqual(a.kind, TypeKind.INCOMPLETEARRAY) - self.assertEqual(a.element_type.kind, TypeKind.INT) - self.assertEqual(a.get_canonical().kind, TypeKind.INCOMPLETEARRAY) - - def test_addrspace(self): - """Ensure the address space can be queried""" - tu = get_tu('__attribute__((address_space(2))) int testInteger = 3;', 'c') - - testInteger = get_cursor(tu, 'testInteger') - - self.assertIsNotNone(testInteger, "Could not find testInteger.") - self.assertEqual(testInteger.type.get_address_space(), 2) - - def test_template_arguments(self): - source = """ - class Foo { - }; - template <typename T> - class Template { - }; - Template<Foo> instance; - int bar; - """ - tu = get_tu(source, lang='cpp') - - # Varible with a template argument. - cursor = get_cursor(tu, 'instance') - cursor_type = cursor.type - self.assertEqual(cursor.kind, CursorKind.VAR_DECL) - self.assertEqual(cursor_type.spelling, 'Template<Foo>') - self.assertEqual(cursor_type.get_num_template_arguments(), 1) - template_type = cursor_type.get_template_argument_type(0) - self.assertEqual(template_type.spelling, 'Foo') - - # Variable without a template argument. - cursor = get_cursor(tu, 'bar') - self.assertEqual(cursor.get_num_template_arguments(), -1) diff --git a/gnu/llvm/tools/clang/bindings/python/tests/cindex/util.py b/gnu/llvm/tools/clang/bindings/python/tests/cindex/util.py deleted file mode 100644 index 57e17941c55..00000000000 --- a/gnu/llvm/tools/clang/bindings/python/tests/cindex/util.py +++ /dev/null @@ -1,90 +0,0 @@ -# This file provides common utility functions for the test suite. - -import os -HAS_FSPATH = hasattr(os, 'fspath') - -if HAS_FSPATH: - from pathlib import Path as str_to_path -else: - str_to_path = None - -import unittest - -from clang.cindex import Cursor -from clang.cindex import TranslationUnit - -def get_tu(source, lang='c', all_warnings=False, flags=[]): - """Obtain a translation unit from source and language. - - By default, the translation unit is created from source file "t.<ext>" - where <ext> is the default file extension for the specified language. By - default it is C, so "t.c" is the default file name. - - Supported languages are {c, cpp, objc}. - - all_warnings is a convenience argument to enable all compiler warnings. - """ - args = list(flags) - name = 't.c' - if lang == 'cpp': - name = 't.cpp' - args.append('-std=c++11') - elif lang == 'objc': - name = 't.m' - elif lang != 'c': - raise Exception('Unknown language: %s' % lang) - - if all_warnings: - args += ['-Wall', '-Wextra'] - - return TranslationUnit.from_source(name, args, unsaved_files=[(name, - source)]) - -def get_cursor(source, spelling): - """Obtain a cursor from a source object. - - This provides a convenient search mechanism to find a cursor with specific - spelling within a source. The first argument can be either a - TranslationUnit or Cursor instance. - - If the cursor is not found, None is returned. - """ - # Convenience for calling on a TU. - root_cursor = source if isinstance(source, Cursor) else source.cursor - - for cursor in root_cursor.walk_preorder(): - if cursor.spelling == spelling: - return cursor - - return None - -def get_cursors(source, spelling): - """Obtain all cursors from a source object with a specific spelling. - - This provides a convenient search mechanism to find all cursors with - specific spelling within a source. The first argument can be either a - TranslationUnit or Cursor instance. - - If no cursors are found, an empty list is returned. - """ - # Convenience for calling on a TU. - root_cursor = source if isinstance(source, Cursor) else source.cursor - - cursors = [] - for cursor in root_cursor.walk_preorder(): - if cursor.spelling == spelling: - cursors.append(cursor) - - return cursors - - -skip_if_no_fspath = unittest.skipUnless(HAS_FSPATH, - "Requires file system path protocol / Python 3.6+") - -__all__ = [ - 'get_cursor', - 'get_cursors', - 'get_tu', - 'skip_if_no_fspath', - 'str_to_path', -] |