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)")