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)
