def test_two_class_hierarchy(generate):
base = cpp.Class(name="A")
assert generate([
schema.Class(name="A", derived={"B"}),
schema.Class(name="B", bases={"A"}),
]) == [
base,
cpp.Class(name="B", bases=[base], final=True, trap_name="Bs"),
]
def test_class_has_first_base_marked():
bases = [
cpp.Class("a"),
cpp.Class("b"),
cpp.Class("c"),
]
expected = [cpp.ClassBase(c) for c in bases]
expected[0].first = True
c = cpp.Class("foo", bases=bases)
assert c.bases == expected
def test_class_with_predicate(generate):
assert generate([
schema.Class(name="MyClass", properties=[schema.PredicateProperty("prop")]),
]) == [
cpp.Class(name="MyClass",
fields=[cpp.Field("prop", "bool", trap_name="MyClassProp", is_predicate=True)],
trap_name="MyClasses",
final=True)
]
def test_class_single_fields():
fields = [
cpp.Field("a", "A"),
cpp.Field("b", "B", is_optional=True),
cpp.Field("c", "C"),
cpp.Field("d", "D", is_repeated=True),
cpp.Field("e", "E"),
]
c = cpp.Class("foo", fields=fields)
assert c.single_fields == fields[::2]
def test_class_with_keyword_field(generate, name):
assert generate([
schema.Class(name="MyClass",
properties=[schema.SingleProperty(name, "bar")]),
]) == [
cpp.Class(name="MyClass",
fields=[cpp.Field(name + "_", "bar")],
trap_name="MyClasses",
final=True)
]
def test_class_with_overridden_underscore_field(generate):
assert generate([
schema.Class(name="MyClass",
properties=[schema.SingleProperty("something_", "bar")]),
]) == [
cpp.Class(name="MyClass",
fields=[cpp.Field("something", "bar")],
trap_name="MyClasses",
final=True)
]
def test_class_with_overridden_unsigned_field(generate, name):
assert generate([
schema.Class(name="MyClass",
properties=[schema.SingleProperty(name, "bar")]),
]) == [
cpp.Class(name="MyClass",
fields=[cpp.Field(name, "unsigned")],
trap_name="MyClasses",
final=True)
]
def test_class_with_field(generate, type, expected, property_cls, optional, repeated, trap_name):
assert generate([
schema.Class(name="MyClass", properties=[property_cls("prop", type)]),
]) == [
cpp.Class(name="MyClass",
fields=[cpp.Field("prop", expected, is_optional=optional,
is_repeated=repeated, trap_name=trap_name)],
trap_name="MyClasses",
final=True)
]
def _get_class(self, name: str) -> cpp.Class:
cls = self._classmap[name]
trap_name = None
if not cls.derived or any(p.is_single for p in cls.properties):
trap_name = inflection.pluralize(cls.name)
return cpp.Class(
name=name,
bases=[self._get_class(b) for b in cls.bases],
fields=[_get_field(cls, p) for p in cls.properties],
final=not cls.derived,
trap_name=trap_name,
)
def test_complex_hierarchy_topologically_ordered(generate):
a = cpp.Class(name="A")
b = cpp.Class(name="B")
c = cpp.Class(name="C", bases=[a])
d = cpp.Class(name="D", bases=[a])
e = cpp.Class(name="E", bases=[b, c, d], final=True, trap_name="Es")
f = cpp.Class(name="F", bases=[c], final=True, trap_name="Fs")
assert generate([
schema.Class(name="F", bases={"C"}),
schema.Class(name="B", derived={"E"}),
schema.Class(name="D", bases={"A"}, derived={"E"}),
schema.Class(name="C", bases={"A"}, derived={"E", "F"}),
schema.Class(name="E", bases={"B", "C", "D"}),
schema.Class(name="A", derived={"C", "D"}),
]) == [a, b, c, d, e, f]
def test_class_has_bases(bases, expected):
t = cpp.Class("name", [cpp.Class(b) for b in bases])
assert t.has_bases is expected
def test_empty_class(generate):
assert generate([
schema.Class(name="MyClass"),
]) == [cpp.Class(name="MyClass", final=True, trap_name="MyClasses")]