def test_duplicate_class_is_ignored(): tu_a = get_named_tu('class A{};', 'a.cpp') model = cppmodel.Model(tu_a) model.extend(tu_a) classes = model.classes assert len(classes) == 1
def test_string_representation(): source = "class A{};" tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) c = model.classes[0] assert str(c) == "class A"
def test_function_with_different_args_is_added(): tu_f = get_named_tu('void f(int);', 'f.cpp') tu_g = get_named_tu('void f(double);', 'g.cpp') model = cppmodel.Model(tu_f) model.extend(tu_g) assert len(model.functions) == 2
def test_new_function_is_added(): tu_f = get_named_tu('void f(int);', 'f.cpp') tu_g = get_named_tu('void g(int);', 'g.cpp') model = cppmodel.Model(tu_f) model.extend(tu_g) assert len(model.functions) == 2
def test_duplicate_function_is_ignored(): tu_f = get_named_tu('void f(int);', 'f.cpp') tu_f_too = get_named_tu('void f(int);', 'f_too.cpp') model = cppmodel.Model(tu_f) model.extend(tu_f_too) assert len(model.functions) == 1
def test_class_name(): source = 'class A{};' tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) classes = model.classes assert len(classes) == 1 assert classes[0].name == 'A'
def test_new_class_is_added(): tu_a = get_named_tu('class A{};', 'a.cpp') tu_b = get_named_tu('class B{};', 'b.cpp') model = cppmodel.Model(tu_a) model.extend(tu_b) classes = model.classes assert len(classes) == 2
def test_pointer_to_record_type(): source = "class A{}; A* pA();" tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) f = model.functions[0] assert f.return_type.kind == TypeKind.POINTER assert f.return_type.is_pointer assert f.return_type.pointee.kind == TypeKind.RECORD
def test_pointer_type(): source = "double* pd();" tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) f = model.functions[0] assert f.return_type.kind == TypeKind.POINTER assert not f.return_type.is_const assert f.return_type.pointee.kind == TypeKind.DOUBLE assert not f.return_type.pointee.is_const
def test_reference_to_record_type(): source = "class A{}; A& pA();" tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) f = model.functions[0] assert f.return_type.kind == TypeKind.LVALUEREFERENCE assert not f.return_type.is_pointer assert f.return_type.is_reference assert f.return_type.pointee.kind == TypeKind.RECORD
def test_function_name(): source = """ void foo(); void bar(); """ tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) functions = model.functions assert len(functions) == 2 assert functions[0].name == 'foo' assert functions[1].name == 'bar'
def test_class_method_return_types(): source = """ class B{ void foo(); int bar(); };""" tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) classes = model.classes assert classes[0].methods[0].return_type.kind == TypeKind.VOID assert classes[0].methods[1].return_type.kind == TypeKind.INT
def test_string_representation(): source = """ double foo(int, char); double bar(int x, char y); """ tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) functions = model.functions assert str(functions[0]) == 'double foo(int, char)' assert str(functions[1]) == 'double bar(int x, char y)'
def test_class_method_const_qualifiers(): source = """ class A { int foo() const; int bar(); };""" tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) classes = model.classes methods = classes[0].methods assert methods[0].is_const assert not methods[1].is_const
def test_class_methods(): source = """ class A{}; class B{ void foo(); int bar(); };""" tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) classes = model.classes assert len(classes[0].methods) == 0 assert len(classes[1].methods) == 2
def test_access_specifiers(): source = """ class A { int foo(); }; struct B { int foo(); }; class C { public: int foo(); }; """ tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) classes = model.classes assert not classes[0].methods[0].is_public assert classes[1].methods[0].is_public assert classes[2].methods[0].is_public
def test_class_method_argument_types(): source = """ class A { int foo(int i, const char* p); };""" tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) classes = model.classes args = classes[0].methods[0].arguments assert args[0].type.kind == TypeKind.INT assert args[0].name == "i" assert args[1].type.kind == TypeKind.POINTER assert args[1].name == "p"
def build_model_from_source(path_to_source, module_name): """ Input: - full path to source file - module_name taken from args Returns: - model built from a clang.cindex TranslationUnit with a name from args """ tu = clang.cindex.TranslationUnit.from_source( path_to_source, '-x c++ -std=c++14 -stdlib=libc++'.split()) model = cppmodel.Model(tu) model.module_name = module_name return model
def test_function_return_type(): source = """ int foo(); double* bar(); """ tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) functions = model.functions assert functions[0].return_type.kind == TypeKind.INT assert functions[1].return_type.kind == TypeKind.POINTER assert functions[1].return_type.is_pointer assert functions[1].return_type.pointee.kind == TypeKind.DOUBLE assert not functions[1].return_type.pointee.is_const
def test_function_arguments(): source = """ int foo(); double bar(int x, char y); """ tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) functions = model.functions assert len(functions[0].arguments) == 0 assert len(functions[1].arguments) == 2 assert functions[1].arguments[0].type.kind == TypeKind.INT assert functions[1].arguments[0].name == 'x' assert functions[1].arguments[1].type.kind == TypeKind.CHAR_S assert functions[1].arguments[1].name == 'y'
def test_class_methods_are_virtual(): source = """ class A { virtual int foo(); int bar(); virtual int foobar() = 0; };""" tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) classes = model.classes methods = classes[0].methods assert methods[0].is_virtual assert not methods[0].is_pure_virtual assert not methods[1].is_virtual assert methods[2].is_pure_virtual
def test_string_representation(): source = """ class A { virtual int foo(); int bar(); virtual int foobar() = 0; virtual int cfoobar(int x) const = 0; };""" tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) classes = model.classes methods = classes[0].methods assert str(methods[0]) == 'virtual int foo()' assert str(methods[1]) == 'int bar()' assert str(methods[2]) == 'virtual int foobar() = 0' assert str(methods[3]) == 'virtual int cfoobar(int x) const = 0'
def test_namespaces(): source = """ class A{}; namespace outer { class B{}; namespace inner { class C{}; } // end inner class D{}; } // end outer class E{};""" tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) classes = model.classes assert classes[0].namespace == "" assert classes[1].namespace == "outer" assert classes[2].namespace == "outer::inner" assert classes[3].namespace == "outer" assert classes[4].namespace == ""
def test_class_member_data(): source = """ class A {}; class B { int x_; B b_; }; """ tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) c = model.classes[1] assert c.members[0].type.kind == TypeKind.INT assert c.members[0].type.name == "int" assert c.members[0].name == "x_" assert c.members[1].type.kind == TypeKind.RECORD assert c.members[1].type.name == "B" assert c.members[1].name == "b_"
def test_function_equality(): source = """ int foo(); int foo(int); int foo(double); int foo(int,int); namespace x { int foo(); } """ tu = get_tu(source, 'cpp') model = cppmodel.Model(tu) for i, f in enumerate(model.functions): for j, g in enumerate(model.functions): if i == j: assert f == g else: assert not f == g
def test_multiply_defined_class_is_an_error(): tu_a = get_named_tu('class A{};', 'a.cpp') tu_a_too = get_named_tu('class A{};', 'a_too.cpp') model = cppmodel.Model(tu_a) model.extend(tu_a_too)