def cpp_class():
compound = Compound("cpp")
compound.name = "MyClass"
def generate_member(kind: str, prot: str) -> Member:
member = Member("cpp")
member.kind = kind
member.name = prot.capitalize() + kind.capitalize()
member.prot = prot
return member
def generate_member_function(prot: str,
name: str,
has_return_value: bool = True,
is_static: bool = False) -> Member:
member = Member("cpp")
member.kind = "function"
member.name = name
member.prot = prot
if has_return_value:
member.returns = ReturnValue()
if is_static:
member.static = True
return member
# fill class with typical members
for visibility in ("public", "protected", "private"):
for member_type in ("variable", "enum", "class", "typedef", "struct", "trash"):
compound.members.append(generate_member(kind=member_type, prot=visibility))
# adds constructors
compound.members.append(
generate_member_function(prot=visibility, name="MyClass", has_return_value=False))
# add some operator
compound.members.append(generate_member_function(prot=visibility, name="operator++"))
# add some method
compound.members.append(
generate_member_function(prot=visibility, name=visibility.capitalize() + "Method"))
# add static method
compound.members.append(
generate_member_function(prot=visibility,
name=visibility.capitalize() + "StaticMethod",
is_static=True))
# insert nested type
nested_class = Compound("cpp")
nested_class.name = "NestedClass"
inner_class_reference = InnerTypeReference(language="cpp")
inner_class_reference.name = nested_class.name
inner_class_reference.referred_object = nested_class
compound.inner_classes.append(inner_class_reference)
return compound
def test_objc_method_signature__multiple_params_linked_return(helper):
method = Compound("objc")
method.name = "setValue:withUnit:andALongerParam:"
method.returns = ReturnValue()
method.returns.type = TypeRef("objc", name="Value")
method.returns.type.id = "objc-value"
param1 = Parameter()
param1.name = "arg1"
param1.type = TypeRef("objc", "Type1")
param2 = Parameter()
param2.name = "arg2"
param2.type = TypeRef("objc", "Type2")
param2.type.id = "objc-type2"
param3 = Parameter()
param3.name = "arg3"
param3.type = TypeRef("objc", "Type3")
method.params = [param1, param2, param3]
assert (helper.method_signature(method) == """\
- (xref:objc-value[++Value++])setValue:(Type1)arg1
withUnit:(xref:objc-type2[++Type2++])arg2
andALongerParam:(Type3)arg3""")
def test_objc_method_signature__class_method(helper):
method = Compound("objc")
method.name = "start"
method.static = True
method.returns = ReturnValue()
method.returns.type = TypeRef("objc", name="void")
assert helper.method_signature(method) == "+ (void)start"
def generate_inner_class(name: str) -> InnerTypeReference:
nested_class = Compound("python")
nested_class.name = name
inner_class_reference = InnerTypeReference(language="python")
inner_class_reference.name = nested_class.name
inner_class_reference.referred_object = nested_class
return inner_class_reference
def test_method_signature__no_params_simple_return__throws(helper):
method = Compound("swift")
method.name = "start"
method.returns = ReturnValue()
method.returns.type = TypeRef("swift", name="Int")
method.exceptions = [ThrowsClause("swift")]
assert helper.method_signature(method) == "func start() throws -> Int"
def objc_class():
compound = Compound("objc")
compound.name = "MyClass"
def generate_member(kind: str, prot: str) -> Member:
member = Member("objc")
member.kind = kind
member.name = prot.capitalize() + kind.capitalize()
member.prot = prot
return member
def generate_member_function(prot: str,
name: str,
has_return_value: bool = True,
is_static: bool = False) -> Member:
member = Member("objc")
member.kind = "function"
member.name = name
member.prot = prot
if has_return_value:
member.returns = ReturnValue()
if is_static:
member.static = True
return member
def generate_property(prot: str) -> Member:
property = generate_member_function(prot=prot,
name=prot.capitalize() +
"Property")
property.kind = "property"
return property
# fill class with typical members
for visibility in ("public", "protected", "private"):
for member_type in ("enum", "class", "protocol", "trash"):
compound.members.append(
generate_member(kind=member_type, prot=visibility))
# add property
compound.members.append(generate_property(prot=visibility))
# add some method
compound.members.append(
generate_member_function(prot=visibility,
name=visibility.capitalize() + "Method"))
# add static method
compound.members.append(
generate_member_function(prot=visibility,
name=visibility.capitalize() +
"StaticMethod",
is_static=True))
# forbidden method
member = Member("objc")
member.kind = "function"
member.name = "NS_UNAVAILABLE"
member.prot = "public"
member.returns = ReturnValue()
compound.members.append(member)
return compound
def test_method_signature__no_params_link_return(helper):
method = Compound("swift")
method.name = "retrieveValue"
method.returns = ReturnValue()
method.returns.type = TypeRef("swift", name="Value")
method.returns.type.id = "swift-value"
assert (helper.method_signature(method) ==
"func retrieveValue() -> xref:swift-value[++Value++]")
def test_method_signature(helper):
method = Compound("cpp")
method.name = "ShortMethod"
method.returns = ReturnValue()
method.returns.type = TypeRef("cpp", "void")
assert helper.method_signature(method) == "void ShortMethod()"
def test_method_signature__no_params_link_return(helper):
method = Compound("kotlin")
method.name = "retrieveValue"
method.returns = ReturnValue()
method.returns.type = TypeRef("kotlin", name="Value")
method.returns.type.id = "kotlin-value"
assert helper.method_signature(
method) == "fun retrieveValue(): xref:kotlin-value[++Value++]"
def test_objc_method_signature__no_params_link_return(helper):
method = Compound("objc")
method.name = "retrieveValue"
method.returns = ReturnValue()
method.returns.type = TypeRef("objc", name="Value")
method.returns.type.id = "objc-value"
assert helper.method_signature(
method) == "- (xref:objc-value[++Value++])retrieveValue"
def test_method_signature__no_params(helper):
method = Compound("python")
method.name = "ShortMethod"
method.returns = ReturnValue()
method.returns.type = TypeRef("python", "None")
assert helper.method_signature(method) == "def ShortMethod() -> None"
def test_closure_definition__no_params__void_return(helper):
closure = Compound("swift")
closure.name = "SuccessClosure"
closure.returns = ReturnValue()
closure.returns.type = TypeRef("swift", name="Void")
closure.returns.type.args = []
assert helper.closure_definition(
closure) == "typealias SuccessClosure = () -> Void"
def test_method_signature__no_params_link_return__throws(helper):
method = Compound("swift")
method.name = "retrieveValue"
method.returns = ReturnValue()
method.returns.type = TypeRef("swift", name="Value")
method.returns.type.id = "swift-value"
method.exceptions = [ThrowsClause("swift")]
assert (helper.method_signature(method) ==
"func retrieveValue() throws -> xref:swift-value[++Value++]")
def test_method_signature__no_params(empty_generating_api):
method = Compound("lang")
method.name = "ShortMethod"
method.returns = ReturnValue()
method.returns.type = TypeRef("lang", "void")
helper = TemplateHelper(empty_generating_api)
assert helper.method_signature(method) == "void ShortMethod()"
def test_closure_definition__no_params__return_type(helper):
closure = Compound("swift")
closure.name = "SuccessClosure"
closure.returns = ReturnValue()
closure.returns.type = TypeRef("swift", name="Data")
closure.returns.type.id = "swift-data"
closure.returns.type.args = []
assert (helper.closure_definition(closure) ==
"typealias SuccessClosure = () -> xref:swift-data[++Data++]")
def python_class():
compound = Compound("python")
compound.name = "MyClass"
def generate_member_function(name: str,
has_return_value: bool = True,
is_static: bool = False) -> Member:
member = Member("python")
member.kind = "function"
member.name = name
member.prot = "public"
if has_return_value:
member.returns = ReturnValue()
if is_static:
member.static = True
return member
def generate_member_variable(name: str) -> Member:
member_variable = Member("python")
member_variable.kind = "variable"
member_variable.name = name
member_variable.returns = ReturnValue()
member_variable.returns.type = TypeRef("python")
return member_variable
def generate_inner_class(name: str) -> InnerTypeReference:
nested_class = Compound("python")
nested_class.name = name
inner_class_reference = InnerTypeReference(language="python")
inner_class_reference.name = nested_class.name
inner_class_reference.referred_object = nested_class
return inner_class_reference
compound.members = [
generate_member_function("__init__", has_return_value=False, is_static=False),
generate_member_function("public_static_method", is_static=True),
generate_member_function("_private_static_method", is_static=True),
generate_member_function("__mangled_private_static_method", is_static=True),
generate_member_function("public_method"),
generate_member_function("_private_method"),
generate_member_function("__mangled_private_method"),
generate_member_function("__add__"),
generate_member_variable("public_variable"),
generate_member_variable("_private_variable"),
generate_member_variable("__mangled_private_variable"),
]
compound.inner_classes = [
generate_inner_class("NestedClass"),
generate_inner_class("_PrivateNestedClass"),
generate_inner_class("__MangledPrivateNestedClass"),
]
return compound
def test_method_signature__single_param(empty_generating_api):
method = Compound("lang")
method.name = "ShortMethod"
method.returns = ReturnValue()
method.returns.type = TypeRef("lang", "void")
method.params = [Parameter()]
method.params[0].name = "value"
method.params[0].type = TypeRef("lang", "int")
helper = TemplateHelper(empty_generating_api)
assert helper.method_signature(method) == "void ShortMethod(int value)"
def test_method_signature__single_param(helper):
method = Compound("python")
method.name = "ShortMethod"
method.returns = ReturnValue()
method.returns.type = TypeRef("python", "int")
method.params = [Parameter()]
method.params[0].name = "value"
method.params[0].type = TypeRef("python", "int")
assert helper.method_signature(
method) == "def ShortMethod(value: int) -> int"
def test_method_signature__one_param(helper):
method = Compound("swift")
method.name = "setValue"
method.returns = ReturnValue()
method.returns.type = TypeRef("swift", name="Value")
param1 = Parameter()
param1.name = "arg1"
param1.type = TypeRef("objc", "Type1")
method.params = [param1]
assert helper.method_signature(
method) == "func setValue(arg1: Type1) -> Value"
def test_closure_definition__multiple_params_type_only__void_return(helper):
closure = Compound("swift")
closure.name = "SuccessClosure"
closure.returns = ReturnValue()
closure.returns.type = TypeRef("swift", name="Void")
closure.returns.type.args = [Parameter(), Parameter()]
closure.returns.type.args[0].type = TypeRef("swift", "int")
closure.returns.type.args[1].type = TypeRef("swift", "Data")
closure.returns.type.args[1].type.id = "swift-data"
assert (
helper.closure_definition(closure) ==
"typealias SuccessClosure = (int, xref:swift-data[++Data++]) -> Void")
def test_method_signature__ignore_param_type_xref_length(helper):
method = Compound("python")
method.name = "ShortMethod"
method.returns = ReturnValue()
method.returns.type = TypeRef("python", "None")
method.params = [Parameter()]
method.params[0].name = "value"
method.params[0].type = TypeRef("python", "int")
method.params[0].type.id = "ab" * 80
assert (helper.method_signature(method) ==
f"def ShortMethod(value: xref:{'ab' * 80}[++int++]) -> None")
def test_objc_method_signature__one_param(helper):
method = Compound("objc")
method.name = "setValue:"
method.returns = ReturnValue()
method.returns.type = TypeRef("objc", name="Value")
method.returns.type.id = "objc-value"
param1 = Parameter()
param1.name = "arg1"
param1.type = TypeRef("objc", "Type1")
method.params = [param1]
assert helper.method_signature(
method) == "- (xref:objc-value[++Value++])setValue:(Type1)arg1"
def test_method_signature__single_param__too_wide(helper):
method = Compound("python")
method.name = "ShortMethod"
method.returns = ReturnValue()
method.returns.type = TypeRef("python", "str")
method.params = [Parameter()]
method.params[0].name = "value"
method.params[0].type = TypeRef("python", "int")
assert (helper.method_signature(method, max_width=20) == """\
def ShortMethod(
value: int) -> str""")
def test_method_signature__ignore_param_type_xref_length(empty_generating_api):
method = Compound("lang")
method.name = "ShortMethod"
method.returns = ReturnValue()
method.returns.type = TypeRef("lang", "void")
method.params = [Parameter()]
method.params[0].name = "value"
method.params[0].type = TypeRef("lang", "int")
method.params[0].type.id = "ab" * 80
helper = TemplateHelper(empty_generating_api)
assert (helper.method_signature(method) ==
f"void ShortMethod(xref:{'ab' * 80}[++int++] "
"value)")
def test_method_signature__multiple_params(helper):
method = Compound("python")
method.name = "ShortMethod"
method.returns = ReturnValue()
method.returns.type = TypeRef("python", "None")
method.params = [Parameter(), Parameter(), Parameter()]
method.params[0].name = "value"
method.params[0].type = TypeRef("python", "int")
method.params[1].name = "other_value"
method.params[1].type = TypeRef("python", "float")
method.params[2].name = "text"
method.params[2].type = TypeRef("python", "str")
assert (helper.method_signature(method) == """\
def ShortMethod(value: int,
other_value: float,
text: str) -> None""")
def test_method_signature__multiple_params(empty_generating_api):
method = Compound("lang")
method.name = "ShortMethod"
method.returns = ReturnValue()
method.returns.type = TypeRef("lang", "void")
method.params = [Parameter(), Parameter(), Parameter()]
method.params[0].name = "value"
method.params[0].type = TypeRef("lang", "int")
method.params[1].name = "other_value"
method.params[1].type = TypeRef("lang", "double")
method.params[2].name = "text"
method.params[2].type = TypeRef("lang", "std::string")
helper = TemplateHelper(empty_generating_api)
assert (helper.method_signature(method) == """\
void ShortMethod(int value,
double other_value,
std::string text)""")
def test_method_signature__multiple_params__last_param_too_wide(helper):
method = Compound("python")
method.name = "ShortMethod"
method.returns = ReturnValue()
method.returns.type = TypeRef("python", "Type")
method.params = [Parameter(), Parameter(), Parameter()]
method.params[0].name = "value"
method.params[0].type = TypeRef("python", "int")
method.params[1].name = "other_value"
method.params[1].type = TypeRef("python", "float")
method.params[2].name = "text" * 10
method.params[2].type = TypeRef("python", "str")
assert (helper.method_signature(method, max_width=40) == f"""\
def ShortMethod(
value: int,
other_value: float,
{"text" * 10}: str) -> Type""")
def test_method_signature__no_params_simple_return(helper):
method = Compound("swift")
method.name = "start"
method.returns = ReturnValue()
method.returns.type = TypeRef("swift", name="Int")
assert helper.method_signature(method) == "func start() -> Int"
def test_method_signature__no_params_no_return__throws(helper):
method = Compound("swift")
method.name = "start"
method.exceptions = [ThrowsClause("swift")]
assert helper.method_signature(method) == "func start() throws"
def test_objc_method_signature__no_params_simple_return(helper):
method = Compound("objc")
method.name = "start"
method.returns = ReturnValue()
method.returns.type = TypeRef("objc", name="void")
assert helper.method_signature(method) == "- (void)start"
