def test_print_ref__no_link__closure_with_nested_type__custom_start_and_end(
api_mock):
nested_type = TypeRef("lang")
nested_type.name = "Nested1"
arg_type = TypeRef("lang")
arg_type.name = "ArgType"
arg_type.id = "lang-argtype"
arg = Parameter()
arg.type = arg_type
return_type = TypeRef("lang")
return_type.name = "MyType"
return_type.prefix = "const "
return_type.suffix = " &"
return_type.id = "lang-tomtom_1_MyType"
return_type.nested = [nested_type]
ref = TypeRef("lang")
ref.args = [arg]
ref.returns = return_type
class TestHelper(TemplateHelper):
NESTED_START: str = "{"
NESTED_END: str = ";"
ARGS_START: str = "@"
ARGS_END: str = "#"
helper = TestHelper(api_mock)
assert (helper.print_ref(ref,
link=False) == "const MyType{Nested1; &@ArgType#")
def test_parameter__eq__full():
first = Parameter(type=TypeRef(name="type"),
name="name",
description="description",
default_value="default_value",
prefix="prefix")
second = Parameter(type=TypeRef(name="type"),
name="name",
description="description",
default_value="default_value",
prefix="prefix")
assert first == second
assert second == first
for attr_name in ("name", "description", "default_value", "prefix"):
setattr(second, attr_name, "other")
assert first != second
assert second != first
setattr(second, attr_name, getattr(first, attr_name))
second.type.name = "other"
assert first != second
assert second != first
second.type.name = first.type.name
def test_parameter(helper):
ref = TypeRef("lang")
ref.name = "MyType"
ref.id = "lang-tomtom_1_MyType"
param = Parameter()
param.type = ref
param.name = "arg"
param.default_value = "12"
assert (helper.parameter(param, default_value=True) ==
"arg: xref:lang-tomtom_1_MyType[++MyType++] = 12")
def test_type_and_name__no_name(empty_context):
ref = TypeRef("lang")
ref.name = "MyType"
ref.prefix = "const "
ref.suffix = " &"
ref.id = "lang-tomtom_1_MyType"
param = Parameter()
param.type = ref
param.name = ""
assert type_and_name(param, empty_context) == "const xref:lang-tomtom_1_MyType[MyType] &"
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_parameter__no_link(empty_generating_api):
ref = TypeRef("lang")
ref.name = "MyType"
ref.prefix = "const "
ref.suffix = " &"
ref.id = "lang-tomtom_1_MyType"
param = Parameter()
param.type = ref
param.name = "arg"
helper = TemplateHelper(empty_generating_api)
assert helper.parameter(param, link=False) == "const MyType & arg"
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_parameter__no_name(empty_generating_api):
ref = TypeRef("lang")
ref.name = "MyType"
ref.prefix = "const "
ref.suffix = " &"
ref.id = "lang-tomtom_1_MyType"
param = Parameter()
param.type = ref
param.name = ""
helper = TemplateHelper(empty_generating_api)
assert helper.parameter(
param) == "const xref:lang-tomtom_1_MyType[++MyType++] &"
def test_objc_method_signature__one_param(context):
method = Member("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 objc_method_signature(
method, context) == "- (xref:objc-value[Value])setValue:(Type1)arg1"
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_typeref__eq__full():
first = TypeRef(language="lang",
name="name",
id="id",
namespace="namespace",
kind="kind",
prefix="prefix",
suffix="suffix",
nested=[TypeRef(name="nested")],
args=[Parameter(name="parameter")],
returns=TypeRef(name="returns"),
prot="protected")
second = TypeRef(language="lang",
name="name",
id="id",
namespace="namespace",
kind="kind",
prefix="prefix",
suffix="suffix",
nested=[TypeRef(name="nested")],
args=[Parameter(name="parameter")],
returns=TypeRef(name="returns"),
prot="protected")
assert first == second
assert second == first
for attr_name in ("language", "name", "id", "namespace", "kind", "prefix",
"suffix"):
setattr(second, attr_name, "other")
assert first != second
assert second != first
setattr(second, attr_name, getattr(first, attr_name))
second.nested[0].name = "other"
assert first != second
assert second != first
second.nested[0].name = first.nested[0].name
second.args[0].name = "other"
assert first != second
assert second != first
second.args[0].name = first.args[0].name
second.returns.name = "other"
assert first != second
assert second != first
second.returns.name = first.returns.name
def test_print_ref__link__complex_closure(api_mock):
ref = TypeRef("lang")
ref.name = "std::function"
ref.nested = [TypeRef("lang")]
ref.nested[0].returns = TypeRef("lang")
ref.nested[0].returns.name = "void"
ref.nested[0].args = [Parameter()]
ref.nested[0].args[0].type = TypeRef("lang")
ref.nested[0].args[0].type.name = "std::shared_ptr"
ref.nested[0].args[0].type.prefix = "const "
ref.nested[0].args[0].type.suffix = "&"
ref.nested[0].args[0].type.nested = [TypeRef("lang")]
ref.nested[0].args[0].type.nested[0].name = "detail::SuccessDescriptor"
ref.nested[0].args[0].type.nested[0].id = "lang-successdescriptor"
helper = TemplateHelper(api_mock)
assert (
helper.print_ref(ref) ==
"std::function<void(const std::shared_ptr<xref:lang-successdescriptor"
"[++detail::SuccessDescriptor++]>&)>")
api_mock.link_to_element.assert_has_calls([
call(ref.nested[0].args[0].type.nested[0].id,
ref.nested[0].args[0].type.nested[0].name)
])
def test_typeref__init__keywords():
ref = TypeRef(language="lang",
name="name",
id="id",
namespace="namespace",
kind="kind",
prefix="prefix",
suffix="suffix",
nested=[TypeRef(name="nested")],
args=[Parameter(name="parameter")],
returns=TypeRef(name="returns"),
prot="public")
assert ref.id == "id"
assert ref.name == "name"
assert ref.language == "lang"
assert ref.namespace == "namespace"
assert ref.kind == "kind"
assert ref.prefix == "prefix"
assert ref.suffix == "suffix"
assert ref.prot == "public"
assert len(ref.nested) == 1
assert ref.nested[0].name == "nested"
assert len(ref.args) == 1
assert ref.args[0].name == "parameter"
assert ref.returns is not None
assert ref.returns.name == "returns"
def test_parameter__init__default():
param = Parameter()
assert param.type is None
assert param.name == ""
assert param.description == ""
assert param.default_value is None
assert param.prefix is None
def test_parameter__eq__none():
param = Parameter()
assert not param == None # noqa: E711
assert not None == param # noqa: E711
assert param != None # noqa: E711
assert None != param # noqa: E711
def test_parameter__default_value(empty_generating_api):
ref = TypeRef("lang")
ref.name = "MyType"
ref.prefix = "const "
ref.suffix = " &"
ref.id = "lang-tomtom_1_MyType"
param = Parameter()
param.type = ref
param.name = "arg"
param.default_value = "12"
helper = TemplateHelper(empty_generating_api)
assert helper.parameter(
param, default_value=True
) == "const xref:lang-tomtom_1_MyType[++MyType++] & arg = 12"
def test_print_ref__no_link__closure_prefix_suffix(api_mock):
arg1_type = TypeRef("lang")
arg1_type.name = "ArgType1"
arg1_type.id = "lang-argtype1"
arg1 = Parameter()
arg1.type = arg1_type
arg2_type = TypeRef("lang")
arg2_type.name = "ArgType2"
arg2 = Parameter()
arg2.name = "value"
arg2.type = arg2_type
return_type = TypeRef("lang")
return_type.name = "MyType"
return_type.id = "lang-tomtom_1_MyType"
return_type.prefix = "const "
return_type.suffix = "&"
ref = TypeRef("lang")
ref.returns = return_type
ref.args = [arg1, arg2]
ref.prefix = "final "
ref.suffix = "*"
helper = TemplateHelper(api_mock)
assert helper.print_ref(
ref, link=False) == "final (const MyType&(ArgType1, ArgType2 value))*"
def test_print_ref__link__closure(api_mock):
arg1_type = TypeRef("lang")
arg1_type.name = "ArgType1"
arg1_type.id = "lang-argtype1"
arg1 = Parameter()
arg1.type = arg1_type
arg2_type = TypeRef("lang")
arg2_type.name = "ArgType2"
arg2 = Parameter()
arg2.name = "value"
arg2.type = arg2_type
return_type = TypeRef("lang")
return_type.name = "MyType"
return_type.id = "lang-tomtom_1_MyType"
ref = TypeRef("lang")
ref.args = [arg1, arg2]
ref.returns = return_type
helper = TemplateHelper(api_mock)
assert (
helper.print_ref(ref) ==
"xref:lang-tomtom_1_MyType[++MyType++](xref:lang-argtype1[++ArgType1++], ArgType2 "
"value)")
api_mock.link_to_element.assert_has_calls([
call(arg1_type.id, arg1_type.name),
call(return_type.id, return_type.name)
])
def test_minimal_constructed_repr():
assert repr(TypeRef("lang"))
assert repr(Parameter())
assert repr(ReturnValue())
assert repr(ThrowsClause("lang"))
assert repr(EnumValue("lang"))
assert repr(Member("lang"))
assert repr(Compound("lang"))
assert repr(InnerTypeReference("lang"))
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_compound__init__keyword():
compound = Compound(id="id",
name="name",
full_name="full_name",
language="lang",
kind="kind",
members=[Compound(name="member_name")],
params=[Parameter(name="parameter")],
exceptions=[ThrowsClause(description="exception")],
returns=ReturnValue(description="returns"),
include="include",
namespace="namespace",
prot="prot",
definition="definition",
args="args",
initializer=" = 2",
brief="brief",
description="description",
static=True,
const=True,
deleted=True,
default=True,
constexpr=True)
assert compound.id == "id"
assert compound.name == "name"
assert compound.full_name == "full_name"
assert compound.language == "lang"
assert compound.kind == "kind"
assert len(compound.members) == 1
assert compound.members[0].name == "member_name"
assert len(compound.params) == 1
assert compound.params[0].name == "parameter"
assert len(compound.exceptions) == 1
assert compound.exceptions[0].description == "exception"
assert compound.returns is not None
assert compound.returns.description == "returns"
assert compound.include == "include"
assert compound.namespace == "namespace"
assert compound.prot == "prot"
assert compound.definition == "definition"
assert compound.args == "args"
assert compound.initializer == " = 2"
assert compound.brief == "brief"
assert compound.description == "description"
assert compound.static is True
assert compound.const is True
assert compound.deleted is True
assert compound.default is True
assert compound.constexpr is True
def test_params__no_type():
param1 = Parameter()
param1.type = None
param1.name = "arg1"
param2 = Parameter()
param2.type = None
param2.name = "arg2"
member = Member("lang")
member.params = [param1, param2]
assert list(params(member)) == [param1, param2]
def test_argument_list__empty_type(empty_context):
type1 = TypeRef("lang")
type2 = TypeRef("lang")
param1 = Parameter()
param1.type = type1
param1.name = "arg1"
param2 = Parameter()
param2.type = type2
param2.name = "arg2"
assert (argument_list([param1, param2], empty_context) == "(arg1, arg2)")
def make_parameter(*,
name="",
description="Description",
default_value="42",
prefix="out ",
**kwargs):
return Parameter(name=name,
description=description,
default_value=default_value,
prefix=prefix,
**kwargs)
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_parameter__init__keywords():
param = Parameter(type=TypeRef(name="type"),
name="name",
description="description",
default_value="default_value",
prefix="prefix")
assert param.type is not None
assert param.type.name == "type"
assert param.name == "name"
assert param.description == "description"
assert param.default_value == "default_value"
assert param.prefix == "prefix"
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_argument_list__no_type(empty_context):
param1 = Parameter()
param1.name = "arg1"
param2 = Parameter()
param2.name = "arg2"
assert (argument_list([param1, param2], empty_context) == "(arg1, arg2)")
