diff options
Diffstat (limited to 'tools/InterfaceGenerator/test/generator/parsers')
7 files changed, 1665 insertions, 0 deletions
diff --git a/tools/InterfaceGenerator/test/generator/parsers/__init__.py b/tools/InterfaceGenerator/test/generator/parsers/__init__.py new file mode 100755 index 0000000000..e69de29bb2 --- /dev/null +++ b/tools/InterfaceGenerator/test/generator/parsers/__init__.py diff --git a/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py b/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py new file mode 100755 index 0000000000..f2fecdb901 --- /dev/null +++ b/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py @@ -0,0 +1,595 @@ +"""JSONRPC XML parser unit test.""" +import os +import unittest + +import generator.Model +import generator.parsers.JSONRPC + + +class TestJSONRPCVParser(unittest.TestCase): + + """Test for JSONRPC xml parser.""" + + class _Issue: + def __init__(self, creator, value): + self.creator = creator + self.value = value + + def __eq__(self, other): + return self.creator == other.creator and self.value == other.value + + def setUp(self): + """Test initialization.""" + self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \ + "/valid_JSONRPC.xml" + self.parser = generator.parsers.JSONRPC.Parser() + + def test_valid_xml(self): + """Test parsing of valid xml.""" + interface = self.parser.parse(self.valid_xml_name) + + self.assertEqual(9, len(interface.params)) + self.assertDictEqual({"attr1": "v1", + "attr2": "v2", + "interface1_attribute1": "value1", + "interface1_attribute2": "value2", + "interface1_issues": "Issue1\nIssue2", + "interface1_design_description": "dd", + "interface2_attribute": "value", + "interface2_description": + "Description of interface2", + "interface2_todos": "i2 todo"}, + interface.params) + + # Enumerations + + self.assertEqual(5, len(interface.enums)) + + # Enumeration "FunctionID" + + self.assertIn("FunctionID", interface.enums) + enum = interface.enums["FunctionID"] + self.verify_base_item(item=enum, + name="FunctionID") + self.assertIsNone(enum.internal_scope) + + self.assertEqual(3, len(enum.elements)) + + self.assertIn("interface1.Function1", enum.elements) + element = enum.elements["interface1.Function1"] + self.verify_base_item( + item=element, + name="interface1.Function1") + self.assertEqual("interface1_Function1", element.internal_name) + self.assertIsNone(element.value) + + self.assertIn("interface1.Function2", enum.elements) + element = enum.elements["interface1.Function2"] + self.verify_base_item( + item=element, + name="interface1.Function2") + self.assertEqual("interface1_Function2", element.internal_name) + self.assertIsNone(element.value) + + self.assertIn("interface2.Function1", enum.elements) + element = enum.elements["interface2.Function1"] + self.verify_base_item( + item=element, + name="interface2.Function1") + self.assertEqual("interface2_Function1", element.internal_name) + self.assertIsNone(element.value) + + # Enumeration "messageType" + + self.assertIn("messageType", interface.enums) + enum = interface.enums["messageType"] + self.verify_base_item( + item=enum, + name="messageType") + self.assertIsNone(enum.internal_scope) + + self.assertEqual(3, len(enum.elements)) + + self.assertIn("request", enum.elements) + element = enum.elements["request"] + self.verify_base_item(item=element, + name="request") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + self.assertIn("response", enum.elements) + element = enum.elements["response"] + self.verify_base_item(item=element, name="response") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + self.assertIn("notification", enum.elements) + element = enum.elements["notification"] + self.verify_base_item(item=element, name="notification") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + # Enumeration "interface1_enum1" + + self.assertIn("interface1_enum1", interface.enums) + enum = interface.enums["interface1_enum1"] + self.verify_base_item(item=enum, name="interface1_enum1", + platform="enum1 platform") + self.assertEqual("scope", enum.internal_scope) + + self.assertEqual(3, len(enum.elements)) + + self.assertIn("element1", enum.elements) + element = enum.elements["element1"] + self.verify_base_item(item=element, name="element1") + self.assertIsNone(element.internal_name) + self.assertEqual(10, element.value) + + self.assertIn("element2", enum.elements) + element = enum.elements["element2"] + self.verify_base_item(item=element, name="element2") + self.assertEqual("element2_internal", element.internal_name) + self.assertEqual(11, element.value) + + self.assertIn("element3", enum.elements) + element = enum.elements["element3"] + self.verify_base_item( + item=element, + name="element3", + design_description=["Element design description"], + platform="element3 platform") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + # Enumeration "interface2_enum1" + + self.assertIn("interface2_enum1", interface.enums) + enum = interface.enums["interface2_enum1"] + self.verify_base_item(item=enum, name="interface2_enum1", + description=["Interface2 enum1 description"]) + self.assertIsNone(enum.internal_scope) + + self.assertEqual(2, len(enum.elements)) + + self.assertIn("e1", enum.elements) + element = enum.elements["e1"] + self.verify_base_item(item=element, name="e1") + self.assertEqual("int_e1", element.internal_name) + self.assertEqual(0, element.value) + + self.assertIn("e2", enum.elements) + element = enum.elements["e2"] + self.verify_base_item(item=element, name="e2") + self.assertEqual("int_e2", element.internal_name) + self.assertEqual(10, element.value) + + # Enumeration "interface2_enum2" + + self.assertIn("interface2_enum2", interface.enums) + enum = interface.enums["interface2_enum2"] + self.verify_base_item(item=enum, name="interface2_enum2", + platform="e2 platform") + self.assertEqual("e2 scope", enum.internal_scope) + + self.assertEqual(3, len(enum.elements)) + + self.assertIn("element1", enum.elements) + element = enum.elements["element1"] + self.verify_base_item(item=element, name="element1") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + self.assertIn("element2", enum.elements) + element = enum.elements["element2"] + self.verify_base_item(item=element, name="element2") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + self.assertIn("element3", enum.elements) + element = enum.elements["element3"] + self.verify_base_item(item=element, name="element3") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + # Structures + + self.assertEqual(3, len(interface.structs)) + + # Structure "interface1_struct1" + + self.assertIn("interface1_struct1", interface.structs) + struct = interface.structs["interface1_struct1"] + self.verify_base_item( + item=struct, + name="interface1_struct1", + description=["Struct description"], + issues=[TestJSONRPCVParser._Issue(creator="creator1", + value="Issue1"), + TestJSONRPCVParser._Issue(creator="creator2", + value="Issue2")]) + + self.assertEqual(4, len(struct.members)) + + self.assertIn("member1", struct.members) + member = struct.members["member1"] + self.verify_base_item( + item=member, + name="member1", + description=["Param1 description"]) + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Integer) + self.assertIsNone(member.param_type.min_value) + self.assertIsNone(member.param_type.max_value) + + self.assertIn("member2", struct.members) + member = struct.members["member2"] + self.verify_base_item(item=member, name="member2", + platform="member2 platform") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Boolean) + + self.assertIn("member3", struct.members) + member = struct.members["member3"] + self.verify_base_item(item=member, name="member3") + self.assertEqual(False, member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Double) + self.assertIsNone(member.param_type.min_value) + self.assertAlmostEqual(20.5, member.param_type.max_value) + + self.assertIn("member4", struct.members) + member = struct.members["member4"] + self.verify_base_item(item=member, name="member4") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Array) + self.assertIsNone(member.param_type.min_size) + self.assertIsNone(member.param_type.max_size) + self.assertIsInstance(member.param_type.element_type, + generator.Model.Integer) + self.assertEqual(11, member.param_type.element_type.min_value) + self.assertEqual(100, member.param_type.element_type.max_value) + + # Structure "interface1_struct2" + + self.assertIn("interface1_struct2", interface.structs) + struct = interface.structs["interface1_struct2"] + self.verify_base_item(item=struct, + name="interface1_struct2", + description=["Description of struct2"], + platform="struct2 platform") + + self.assertEqual(4, len(struct.members)) + + self.assertIn("m1", struct.members) + member = struct.members["m1"] + self.verify_base_item(item=member, name="m1") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.String) + self.assertIsNone(member.param_type.max_length) + + self.assertIn("m2", struct.members) + member = struct.members["m2"] + self.verify_base_item(item=member, name="m2") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Array) + self.assertEqual(1, member.param_type.min_size) + self.assertEqual(50, member.param_type.max_size) + self.assertIsInstance(member.param_type.element_type, + generator.Model.String) + self.assertEqual(100, member.param_type.element_type.max_length) + + self.assertIn("m3", struct.members) + member = struct.members["m3"] + self.verify_base_item(item=member, name="m3") + self.assertTrue(member.is_mandatory) + self.assertIs(member.param_type, interface.enums["interface1_enum1"]) + + self.assertIn("m4", struct.members) + member = struct.members["m4"] + self.verify_base_item(item=member, name="m4") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Array) + self.assertIsNone(member.param_type.min_size) + self.assertEqual(10, member.param_type.max_size) + self.assertIs(member.param_type.element_type, + interface.structs["interface1_struct1"]) + + # Structure "interface2_struct1" + + self.assertIn("interface2_struct1", interface.structs) + struct = interface.structs["interface2_struct1"] + self.verify_base_item(item=struct, name="interface2_struct1") + + self.assertEqual(3, len(struct.members)) + + self.assertIn("m_1", struct.members) + member = struct.members["m_1"] + self.verify_base_item(item=member, name="m_1") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Array) + self.assertEqual(1, member.param_type.min_size) + self.assertEqual(10, member.param_type.max_size) + self.assertIs(member.param_type.element_type, + interface.enums["interface2_enum1"]) + + self.assertIn("m_2", struct.members) + member = struct.members["m_2"] + self.verify_base_item(item=member, name="m_2") + self.assertTrue(member.is_mandatory) + self.assertIs(member.param_type, interface.enums["interface2_enum2"]) + + self.assertIn("m_3", struct.members) + member = struct.members["m_3"] + self.verify_base_item(item=member, name="m_3") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.String) + self.assertEqual(20, member.param_type.max_length) + + # Functions + + self.assertEqual(5, len(interface.functions)) + + # Function request "interface1_Function1" + + self.assertIn( + (interface.enums["FunctionID"].elements["interface1.Function1"], + interface.enums["messageType"].elements["request"]), + interface.functions) + function = interface.functions[ + (interface.enums["FunctionID"].elements["interface1.Function1"], + interface.enums["messageType"].elements["request"])] + self.verify_base_item( + item=function, + name="interface1_Function1", + description=["Description of request Function1"], + todos=["Function1 request todo"]) + self.assertIs( + function.function_id, + interface.enums["FunctionID"].elements["interface1.Function1"]) + self.assertIs(function.message_type, + interface.enums["messageType"].elements["request"]) + + self.assertEqual(3, len(function.params)) + + self.assertIn("param1", function.params) + param = function.params["param1"] + self.verify_base_item( + item=param, + name="param1", + issues=[TestJSONRPCVParser._Issue(creator="", value="")]) + self.assertEqual(False, param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.String) + self.assertIsNone(param.param_type.max_length) + self.assertEqual("String default value", param.default_value) + + self.assertIn("param2", function.params) + param = function.params["param2"] + self.verify_base_item( + item=param, + name="param2", + description=["Param2 description", ""], + todos=["Param2 todo"], + platform="param2 platform") + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.Integer) + self.assertIsNone(param.param_type.min_value) + self.assertIsNone(param.param_type.max_value) + self.assertIsNone(param.default_value) + + self.assertIn("param3", function.params) + param = function.params["param3"] + self.verify_base_item(item=param, name="param3") + self.assertEqual(False, param.is_mandatory) + self.assertIs(param.param_type, + interface.structs["interface1_struct1"]) + self.assertIsNone(param.default_value) + + # Function response "interface1_Function1" + + self.assertIn( + (interface.enums["FunctionID"].elements["interface1.Function1"], + interface.enums["messageType"].elements["response"]), + interface.functions) + function = interface.functions[ + (interface.enums["FunctionID"].elements["interface1.Function1"], + interface.enums["messageType"].elements["response"])] + self.verify_base_item( + item=function, + name="interface1_Function1", + issues=[TestJSONRPCVParser._Issue(creator="c1", value=""), + TestJSONRPCVParser._Issue(creator="c2", value="")], + platform="") + self.assertIs( + function.function_id, + interface.enums["FunctionID"].elements["interface1.Function1"]) + self.assertIs(function.message_type, + interface.enums["messageType"].elements["response"]) + + self.assertEqual(3, len(function.params)) + + self.assertIn("p1", function.params) + param = function.params["p1"] + self.verify_base_item(item=param, name="p1") + self.assertTrue(param.is_mandatory) + self.assertIs(param.param_type, interface.enums["interface1_enum1"]) + self.assertIsNone(param.default_value) + + self.assertIn("p2", function.params) + param = function.params["p2"] + self.verify_base_item(item=param, name="p2") + self.assertTrue(param.is_mandatory) + self.assertIs(param.param_type, interface.enums["interface1_enum1"]) + self.assertIs( + param.default_value, + interface.enums["interface1_enum1"].elements["element2"]) + + self.assertIn("p3", function.params) + param = function.params["p3"] + self.verify_base_item(item=param, name="p3", design_description=[""]) + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.Boolean) + self.assertEqual(False, param.default_value) + + # Function notification "interface1_Function2" + + self.assertIn( + (interface.enums["FunctionID"].elements["interface1.Function2"], + interface.enums["messageType"].elements["notification"]), + interface.functions) + function = interface.functions[ + (interface.enums["FunctionID"].elements["interface1.Function2"], + interface.enums["messageType"].elements["notification"])] + self.verify_base_item(item=function, + name="interface1_Function2", + description=["Function2 description"], + platform="function2 platform") + self.assertIs( + function.function_id, + interface.enums["FunctionID"].elements["interface1.Function2"]) + self.assertIs(function.message_type, + interface.enums["messageType"].elements["notification"]) + + self.assertEqual(3, len(function.params)) + + self.assertIn("n1", function.params) + param = function.params["n1"] + self.verify_base_item(item=param, name="n1", todos=["n1 todo"]) + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.EnumSubset) + self.assertIs(param.param_type.enum, + interface.enums["interface1_enum1"]) + self.assertDictEqual( + {"element2": + interface.enums["interface1_enum1"].elements["element2"], + "element3": + interface.enums["interface1_enum1"].elements["element3"]}, + param.param_type.allowed_elements) + self.assertIsNone(param.default_value) + + self.assertIn("n2", function.params) + param = function.params["n2"] + self.verify_base_item(item=param, name="n2", todos=["n2 todo"]) + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.Array) + self.assertEqual(1, param.param_type.min_size) + self.assertEqual(100, param.param_type.max_size) + self.assertIsInstance(param.param_type.element_type, + generator.Model.EnumSubset) + self.assertIs(param.param_type.element_type.enum, + interface.enums["interface1_enum1"]) + self.assertDictEqual( + {"element1": + interface.enums["interface1_enum1"].elements["element1"], + "element3": + interface.enums["interface1_enum1"].elements["element3"]}, + param.param_type.element_type.allowed_elements) + self.assertIsNone(param.default_value) + + self.assertIn("n3", function.params) + param = function.params["n3"] + self.verify_base_item(item=param, name="n3") + self.assertEqual(False, param.is_mandatory) + self.assertIs(param.param_type, + interface.structs["interface1_struct2"]) + self.assertIsNone(param.default_value) + + # Function request "interface2_Function1" + + self.assertIn( + (interface.enums["FunctionID"].elements["interface2.Function1"], + interface.enums["messageType"].elements["request"]), + interface.functions) + function = interface.functions[ + (interface.enums["FunctionID"].elements["interface2.Function1"], + interface.enums["messageType"].elements["request"])] + self.verify_base_item(item=function, name="interface2_Function1") + self.assertIs( + function.function_id, + interface.enums["FunctionID"].elements["interface2.Function1"]) + self.assertIs(function.message_type, + interface.enums["messageType"].elements["request"]) + + self.assertEqual(2, len(function.params)) + + self.assertIn("param1", function.params) + param = function.params["param1"] + self.verify_base_item(item=param, name="param1") + self.assertEqual(False, param.is_mandatory) + self.assertIs(param.param_type, interface.enums["interface2_enum1"]) + self.assertIsNone(param.default_value) + + self.assertIn("param2", function.params) + param = function.params["param2"] + self.verify_base_item(item=param, name="param2") + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.Array) + self.assertEqual(5, param.param_type.min_size) + self.assertEqual(25, param.param_type.max_size) + self.assertIs(param.param_type.element_type, + interface.structs["interface2_struct1"]) + self.assertIsNone(param.default_value) + + # Function notification "interface2_Function1" + + self.assertIn( + (interface.enums["FunctionID"].elements["interface2.Function1"], + interface.enums["messageType"].elements["notification"]), + interface.functions) + function = interface.functions[ + (interface.enums["FunctionID"].elements["interface2.Function1"], + interface.enums["messageType"].elements["notification"])] + self.verify_base_item( + item=function, + name="interface2_Function1", + issues=[ + TestJSONRPCVParser._Issue(creator="c", value="Issue text")], + platform="platform") + self.assertIs( + function.function_id, + interface.enums["FunctionID"].elements["interface2.Function1"]) + self.assertIs(function.message_type, + interface.enums["messageType"].elements["notification"]) + + self.assertEqual(2, len(function.params)) + + self.assertIn("param", function.params) + param = function.params["param"] + self.verify_base_item(item=param, name="param") + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.EnumSubset) + self.assertIs(param.param_type.enum, + interface.enums["interface2_enum2"]) + self.assertDictEqual( + {"element2": + interface.enums["interface2_enum2"].elements["element2"], + "element3": + interface.enums["interface2_enum2"].elements["element3"]}, + param.param_type.allowed_elements) + self.assertIsNone(param.default_value) + + self.assertIn("i1", function.params) + param = function.params["i1"] + self.verify_base_item(item=param, name="i1") + self.assertTrue(param.is_mandatory) + self.assertIs(param.param_type, + interface.structs["interface1_struct2"]) + self.assertIsNone(param.default_value) + + def verify_base_item(self, item, name, description=None, + design_description=None, issues=None, todos=None, + platform=None): + """Verify base interface item variables.""" + self.assertEqual(name, item.name) + self.assertSequenceEqual(self.get_list(description), item.description) + self.assertSequenceEqual(self.get_list(design_description), + item.design_description) + self.assertSequenceEqual(self.get_list(issues), item.issues) + self.assertSequenceEqual(self.get_list(todos), item.todos) + self.assertEqual(platform, item.platform) + + @staticmethod + def get_list(list=None): + """Return provided list or empty list if None is provided.""" + return list if list is not None else [] + +if __name__ == "__main__": + unittest.main() diff --git a/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV1.py b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV1.py new file mode 100755 index 0000000000..1464658ff4 --- /dev/null +++ b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV1.py @@ -0,0 +1,404 @@ +"""SDLRPCV1 XML parser unit test.""" +import os +import unittest + +import generator.Model +import generator.parsers.SDLRPCV1 + + +class TestSDLRPCV1Parser(unittest.TestCase): + + """Test for SDLRPCV1 xml parser.""" + + class _Issue: + def __init__(self, creator, value): + self.creator = creator + self.value = value + + def __eq__(self, other): + return self.creator == other.creator and self.value == other.value + + def setUp(self): + """Test initialization.""" + self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \ + "/valid_SDLRPCV1.xml" + self.parser = generator.parsers.SDLRPCV1.Parser() + + def test_valid_xml(self): + """Test parsing of valid xml.""" + interface = self.parser.parse(self.valid_xml_name) + + self.assertEqual(2, len(interface.params)) + self.assertDictEqual({"attribute1": "value1", "attribute2": "value2"}, + interface.params) + + # Enumerations + + self.assertEqual(3, len(interface.enums)) + + # Enumeration "FunctionID" + + self.assertIn("FunctionID", interface.enums) + enum = interface.enums["FunctionID"] + self.verify_base_item(item=enum, + name="FunctionID") + self.assertIsNone(enum.internal_scope) + + self.assertEqual(2, len(enum.elements)) + + self.assertIn("Function1", enum.elements) + element = enum.elements["Function1"] + self.verify_base_item( + item=element, + name="Function1") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + self.assertIn("Function2", enum.elements) + element = enum.elements["Function2"] + self.verify_base_item( + item=element, + name="Function2") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + # Enumeration "messageType" + + self.assertIn("messageType", interface.enums) + enum = interface.enums["messageType"] + self.verify_base_item( + item=enum, + name="messageType") + self.assertIsNone(enum.internal_scope) + + self.assertEqual(3, len(enum.elements)) + + self.assertIn("request", enum.elements) + element = enum.elements["request"] + self.verify_base_item(item=element, + name="request") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + self.assertIn("response", enum.elements) + element = enum.elements["response"] + self.verify_base_item(item=element, name="response") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + self.assertIn("notification", enum.elements) + element = enum.elements["notification"] + self.verify_base_item(item=element, name="notification") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + # Enumeration "enum1" + + self.assertIn("enum1", interface.enums) + enum = interface.enums["enum1"] + self.verify_base_item(item=enum, name="enum1", + platform="enum1 platform") + self.assertEqual("scope", enum.internal_scope) + + self.assertEqual(3, len(enum.elements)) + + self.assertIn("element1", enum.elements) + element = enum.elements["element1"] + self.verify_base_item(item=element, name="element1") + self.assertIsNone(element.internal_name) + self.assertEqual(10, element.value) + + self.assertIn("element2", enum.elements) + element = enum.elements["element2"] + self.verify_base_item(item=element, name="element2") + self.assertEqual("element2_internal", element.internal_name) + self.assertEqual(11, element.value) + + self.assertIn("element3", enum.elements) + element = enum.elements["element3"] + self.verify_base_item( + item=element, + name="element3", + design_description=["Element design description"], + platform="element3 platform") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + # Structures + + self.assertEqual(2, len(interface.structs)) + + # Structure "struct1" + + self.assertIn("struct1", interface.structs) + struct = interface.structs["struct1"] + self.verify_base_item( + item=struct, + name="struct1", + description=["Struct description"], + issues=[TestSDLRPCV1Parser._Issue(creator="creator1", + value="Issue1"), + TestSDLRPCV1Parser._Issue(creator="creator2", + value="Issue2")]) + + self.assertEqual(4, len(struct.members)) + + self.assertIn("member1", struct.members) + member = struct.members["member1"] + self.verify_base_item( + item=member, + name="member1", + description=["Param1 description"]) + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Integer) + self.assertIsNone(member.param_type.min_value) + self.assertIsNone(member.param_type.max_value) + + self.assertIn("member2", struct.members) + member = struct.members["member2"] + self.verify_base_item(item=member, name="member2", + platform="member2 platform") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Boolean) + + self.assertIn("member3", struct.members) + member = struct.members["member3"] + self.verify_base_item(item=member, name="member3") + self.assertEqual(False, member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Double) + self.assertIsNone(member.param_type.min_value) + self.assertAlmostEqual(20.5, member.param_type.max_value) + + self.assertIn("member4", struct.members) + member = struct.members["member4"] + self.verify_base_item(item=member, name="member4") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Array) + self.assertIsNone(member.param_type.min_size) + self.assertIsNone(member.param_type.max_size) + self.assertIsInstance(member.param_type.element_type, + generator.Model.Integer) + self.assertEqual(11, member.param_type.element_type.min_value) + self.assertEqual(100, member.param_type.element_type.max_value) + + # Structure "struct2" + + self.assertIn("struct2", interface.structs) + struct = interface.structs["struct2"] + self.verify_base_item(item=struct, + name="struct2", + description=["Description of struct2"], + platform="struct2 platform") + + self.assertEqual(4, len(struct.members)) + + self.assertIn("m1", struct.members) + member = struct.members["m1"] + self.verify_base_item(item=member, name="m1") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.String) + self.assertIsNone(member.param_type.max_length) + + self.assertIn("m2", struct.members) + member = struct.members["m2"] + self.verify_base_item(item=member, name="m2") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Array) + self.assertEqual(1, member.param_type.min_size) + self.assertEqual(50, member.param_type.max_size) + self.assertIsInstance(member.param_type.element_type, + generator.Model.String) + self.assertEqual(100, member.param_type.element_type.max_length) + + self.assertIn("m3", struct.members) + member = struct.members["m3"] + self.verify_base_item(item=member, name="m3") + self.assertTrue(member.is_mandatory) + self.assertIs(member.param_type, interface.enums["enum1"]) + + self.assertIn("m4", struct.members) + member = struct.members["m4"] + self.verify_base_item(item=member, name="m4") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Array) + self.assertIsNone(member.param_type.min_size) + self.assertEqual(10, member.param_type.max_size) + self.assertIs(member.param_type.element_type, + interface.structs["struct1"]) + + # Functions + + self.assertEqual(3, len(interface.functions)) + + # Function request "Function1" + + self.assertIn( + (interface.enums["FunctionID"].elements["Function1"], + interface.enums["messageType"].elements["request"]), + interface.functions) + function = interface.functions[ + (interface.enums["FunctionID"].elements["Function1"], + interface.enums["messageType"].elements["request"])] + self.verify_base_item( + item=function, + name="Function1", + description=["Description of request Function1"], + todos=["Function1 request todo"]) + self.assertIs(function.function_id, + interface.enums["FunctionID"].elements["Function1"]) + self.assertIs(function.message_type, + interface.enums["messageType"].elements["request"]) + + self.assertEqual(3, len(function.params)) + + self.assertIn("param1", function.params) + param = function.params["param1"] + self.verify_base_item( + item=param, + name="param1", + issues=[TestSDLRPCV1Parser._Issue(creator="", value="")]) + self.assertEqual(False, param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.String) + self.assertIsNone(param.param_type.max_length) + self.assertEqual("String default value", param.default_value) + + self.assertIn("param2", function.params) + param = function.params["param2"] + self.verify_base_item( + item=param, + name="param2", + description=["Param2 description", ""], + todos=["Param2 todo"], + platform="param2 platform") + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.Integer) + self.assertIsNone(param.param_type.min_value) + self.assertIsNone(param.param_type.max_value) + self.assertIsNone(param.default_value) + + self.assertIn("param3", function.params) + param = function.params["param3"] + self.verify_base_item(item=param, name="param3") + self.assertEqual(False, param.is_mandatory) + self.assertIs(param.param_type, interface.structs["struct1"]) + self.assertIsNone(param.default_value) + + # Function response "Function1" + + self.assertIn( + (interface.enums["FunctionID"].elements["Function1"], + interface.enums["messageType"].elements["response"]), + interface.functions) + function = interface.functions[ + (interface.enums["FunctionID"].elements["Function1"], + interface.enums["messageType"].elements["response"])] + self.verify_base_item( + item=function, + name="Function1", + issues=[TestSDLRPCV1Parser._Issue(creator="c1", value=""), + TestSDLRPCV1Parser._Issue(creator="c2", value="")], + platform="") + self.assertIs(function.function_id, + interface.enums["FunctionID"].elements["Function1"]) + self.assertIs(function.message_type, + interface.enums["messageType"].elements["response"]) + + self.assertEqual(3, len(function.params)) + + self.assertIn("p1", function.params) + param = function.params["p1"] + self.verify_base_item(item=param, name="p1") + self.assertTrue(param.is_mandatory) + self.assertIs(param.param_type, interface.enums["enum1"]) + self.assertIsNone(param.default_value) + + self.assertIn("p2", function.params) + param = function.params["p2"] + self.verify_base_item(item=param, name="p2") + self.assertTrue(param.is_mandatory) + self.assertIs(param.param_type, interface.enums["enum1"]) + self.assertIs(param.default_value, + interface.enums["enum1"].elements["element2"]) + + self.assertIn("p3", function.params) + param = function.params["p3"] + self.verify_base_item(item=param, name="p3", design_description=[""]) + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.Boolean) + self.assertEqual(False, param.default_value) + + # Function notification "Function2" + + self.assertIn( + (interface.enums["FunctionID"].elements["Function2"], + interface.enums["messageType"].elements["notification"]), + interface.functions) + function = interface.functions[ + (interface.enums["FunctionID"].elements["Function2"], + interface.enums["messageType"].elements["notification"])] + self.verify_base_item(item=function, + name="Function2", + description=["Function2 description"], + platform="function2 platform") + self.assertIs(function.function_id, + interface.enums["FunctionID"].elements["Function2"]) + self.assertIs(function.message_type, + interface.enums["messageType"].elements["notification"]) + + self.assertEqual(3, len(function.params)) + + self.assertIn("n1", function.params) + param = function.params["n1"] + self.verify_base_item(item=param, name="n1", todos=["n1 todo"]) + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.EnumSubset) + self.assertIs(param.param_type.enum, interface.enums["enum1"]) + self.assertDictEqual( + {"element2": interface.enums["enum1"].elements["element2"], + "element3": interface.enums["enum1"].elements["element3"]}, + param.param_type.allowed_elements) + self.assertIsNone(param.default_value) + + self.assertIn("n2", function.params) + param = function.params["n2"] + self.verify_base_item(item=param, name="n2", todos=["n2 todo"]) + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.Array) + self.assertEqual(1, param.param_type.min_size) + self.assertEqual(100, param.param_type.max_size) + self.assertIsInstance(param.param_type.element_type, + generator.Model.EnumSubset) + self.assertIs(param.param_type.element_type.enum, + interface.enums["enum1"]) + self.assertDictEqual( + {"element1": interface.enums["enum1"].elements["element1"], + "element3": interface.enums["enum1"].elements["element3"]}, + param.param_type.element_type.allowed_elements) + self.assertIsNone(param.default_value) + + self.assertIn("n3", function.params) + param = function.params["n3"] + self.verify_base_item(item=param, name="n3") + self.assertEqual(False, param.is_mandatory) + self.assertIs(param.param_type, interface.structs["struct2"]) + self.assertIsNone(param.default_value) + + def verify_base_item(self, item, name, description=None, + design_description=None, issues=None, todos=None, + platform=None): + """Verify base interface item variables.""" + self.assertEqual(name, item.name) + self.assertSequenceEqual(self.get_list(description), item.description) + self.assertSequenceEqual(self.get_list(design_description), + item.design_description) + self.assertSequenceEqual(self.get_list(issues), item.issues) + self.assertSequenceEqual(self.get_list(todos), item.todos) + self.assertEqual(platform, item.platform) + + @staticmethod + def get_list(list=None): + """Return provided list or empty list if None is provided.""" + return list if list is not None else [] + +if __name__ == "__main__": + unittest.main() diff --git a/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV2.py b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV2.py new file mode 100755 index 0000000000..c37962cfe6 --- /dev/null +++ b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV2.py @@ -0,0 +1,417 @@ +"""SDLRPCV2 XML parser unit test.""" +import os +import unittest + +import generator.Model +import generator.parsers.SDLRPCV2 + + +class TestSDLRPCV2Parser(unittest.TestCase): + + """Test for SDLRPCV2 xml parser.""" + + class _Issue: + def __init__(self, creator, value): + self.creator = creator + self.value = value + + def __eq__(self, other): + return self.creator == other.creator and self.value == other.value + + def setUp(self): + """Test initialization.""" + self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \ + "/valid_SDLRPCV2.xml" + self.parser = generator.parsers.SDLRPCV2.Parser() + + def test_valid_xml(self): + """Test parsing of valid xml.""" + interface = self.parser.parse(self.valid_xml_name) + + self.assertEqual(2, len(interface.params)) + self.assertDictEqual({"attribute1": "value1", "attribute2": "value2"}, + interface.params) + + # Enumerations + + self.assertEqual(3, len(interface.enums)) + + # Enumeration "FunctionID" + + self.assertIn("FunctionID", interface.enums) + enum = interface.enums["FunctionID"] + self.verify_base_item(item=enum, + name="FunctionID", + description=["Description string 1", + "Description string 2"], + todos=['Function id todo']) + self.assertIsNone(enum.internal_scope) + + self.assertEqual(2, len(enum.elements)) + + self.assertIn("Function1_id", enum.elements) + element = enum.elements["Function1_id"] + self.verify_base_item( + item=element, + name="Function1_id", + design_description=["Function1 element design description"]) + self.assertIsNone(element.internal_name) + self.assertEqual(10, element.value) + + self.assertIn("Function2_id", enum.elements) + element = enum.elements["Function2_id"] + self.verify_base_item( + item=element, + name="Function2_id") + self.assertEqual("Function2_internal", element.internal_name) + self.assertIsNone(element.value) + + # Enumeration "messageType" + + self.assertIn("messageType", interface.enums) + enum = interface.enums["messageType"] + self.verify_base_item( + item=enum, + name="messageType", + design_description=["messageType design description", + "messageType design description 2"], + issues=[TestSDLRPCV2Parser._Issue( + creator="messageType issue creator", + value="Issue text")]) + self.assertIsNone(enum.internal_scope) + + self.assertEqual(3, len(enum.elements)) + + self.assertIn("request", enum.elements) + element = enum.elements["request"] + self.verify_base_item(item=element, + name="request", + todos=["request todo 1", "request todo 2"], + issues=[TestSDLRPCV2Parser._Issue( + creator="issue creator", + value="request issue")]) + self.assertIsNone(element.internal_name) + self.assertEqual(0, element.value) + + self.assertIn("response", enum.elements) + element = enum.elements["response"] + self.verify_base_item(item=element, name="response") + self.assertIsNone(element.internal_name) + self.assertEqual(1, element.value) + + self.assertIn("notification", enum.elements) + element = enum.elements["notification"] + self.verify_base_item(item=element, name="notification") + self.assertIsNone(element.internal_name) + self.assertEqual(2, element.value) + + # Enumeration "enum1" + + self.assertIn("enum1", interface.enums) + enum = interface.enums["enum1"] + self.verify_base_item(item=enum, name="enum1", + platform="enum1 platform") + self.assertEqual("scope", enum.internal_scope) + + self.assertEqual(3, len(enum.elements)) + + self.assertIn("element1", enum.elements) + element = enum.elements["element1"] + self.verify_base_item(item=element, name="element1") + self.assertIsNone(element.internal_name) + self.assertEqual(10, element.value) + + self.assertIn("element2", enum.elements) + element = enum.elements["element2"] + self.verify_base_item(item=element, name="element2") + self.assertEqual("element2_internal", element.internal_name) + self.assertEqual(11, element.value) + + self.assertIn("element3", enum.elements) + element = enum.elements["element3"] + self.verify_base_item( + item=element, + name="element3", + design_description=["Element design description"], + platform="element3 platform") + self.assertIsNone(element.internal_name) + self.assertIsNone(element.value) + + # Structures + + self.assertEqual(2, len(interface.structs)) + + # Structure "struct1" + + self.assertIn("struct1", interface.structs) + struct = interface.structs["struct1"] + self.verify_base_item( + item=struct, + name="struct1", + description=["Struct description"], + issues=[TestSDLRPCV2Parser._Issue(creator="creator1", + value="Issue1"), + TestSDLRPCV2Parser._Issue(creator="creator2", + value="Issue2")]) + + self.assertEqual(4, len(struct.members)) + + self.assertIn("member1", struct.members) + member = struct.members["member1"] + self.verify_base_item( + item=member, + name="member1", + description=["Param1 description"]) + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Integer) + self.assertIsNone(member.param_type.min_value) + self.assertIsNone(member.param_type.max_value) + + self.assertIn("member2", struct.members) + member = struct.members["member2"] + self.verify_base_item(item=member, name="member2", + platform="member2 platform") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Boolean) + + self.assertIn("member3", struct.members) + member = struct.members["member3"] + self.verify_base_item(item=member, name="member3") + self.assertEqual(False, member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Double) + self.assertIsNone(member.param_type.min_value) + self.assertAlmostEqual(20.5, member.param_type.max_value) + + self.assertIn("member4", struct.members) + member = struct.members["member4"] + self.verify_base_item(item=member, name="member4") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Array) + self.assertIsNone(member.param_type.min_size) + self.assertIsNone(member.param_type.max_size) + self.assertIsInstance(member.param_type.element_type, + generator.Model.Integer) + self.assertEqual(11, member.param_type.element_type.min_value) + self.assertEqual(100, member.param_type.element_type.max_value) + + # Structure "struct2" + + self.assertIn("struct2", interface.structs) + struct = interface.structs["struct2"] + self.verify_base_item(item=struct, + name="struct2", + description=["Description of struct2"], + platform="struct2 platform") + + self.assertEqual(4, len(struct.members)) + + self.assertIn("m1", struct.members) + member = struct.members["m1"] + self.verify_base_item(item=member, name="m1") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.String) + self.assertIsNone(member.param_type.max_length) + + self.assertIn("m2", struct.members) + member = struct.members["m2"] + self.verify_base_item(item=member, name="m2") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Array) + self.assertEqual(1, member.param_type.min_size) + self.assertEqual(50, member.param_type.max_size) + self.assertIsInstance(member.param_type.element_type, + generator.Model.String) + self.assertEqual(100, member.param_type.element_type.max_length) + + self.assertIn("m3", struct.members) + member = struct.members["m3"] + self.verify_base_item(item=member, name="m3") + self.assertTrue(member.is_mandatory) + self.assertIs(member.param_type, interface.enums["enum1"]) + + self.assertIn("m4", struct.members) + member = struct.members["m4"] + self.verify_base_item(item=member, name="m4") + self.assertTrue(member.is_mandatory) + self.assertIsInstance(member.param_type, generator.Model.Array) + self.assertIsNone(member.param_type.min_size) + self.assertEqual(10, member.param_type.max_size) + self.assertIs(member.param_type.element_type, + interface.structs["struct1"]) + + # Functions + + self.assertEqual(3, len(interface.functions)) + + # Function request "Function1" + + self.assertIn( + (interface.enums["FunctionID"].elements["Function1_id"], + interface.enums["messageType"].elements["request"]), + interface.functions) + function = interface.functions[ + (interface.enums["FunctionID"].elements["Function1_id"], + interface.enums["messageType"].elements["request"])] + self.verify_base_item( + item=function, + name="Function1", + description=["Description of request Function1"], + todos=["Function1 request todo"]) + self.assertIs(function.function_id, + interface.enums["FunctionID"].elements["Function1_id"]) + self.assertIs(function.message_type, + interface.enums["messageType"].elements["request"]) + + self.assertEqual(3, len(function.params)) + + self.assertIn("param1", function.params) + param = function.params["param1"] + self.verify_base_item( + item=param, + name="param1", + issues=[TestSDLRPCV2Parser._Issue(creator="", value="")]) + self.assertEqual(False, param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.String) + self.assertIsNone(param.param_type.max_length) + self.assertEqual("String default value", param.default_value) + + self.assertIn("param2", function.params) + param = function.params["param2"] + self.verify_base_item( + item=param, + name="param2", + description=["Param2 description", ""], + todos=["Param2 todo"], + platform="param2 platform") + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.Integer) + self.assertIsNone(param.param_type.min_value) + self.assertIsNone(param.param_type.max_value) + self.assertIsNone(param.default_value) + + self.assertIn("param3", function.params) + param = function.params["param3"] + self.verify_base_item(item=param, name="param3") + self.assertEqual(False, param.is_mandatory) + self.assertIs(param.param_type, interface.structs["struct1"]) + self.assertIsNone(param.default_value) + + # Function response "Function1" + + self.assertIn( + (interface.enums["FunctionID"].elements["Function1_id"], + interface.enums["messageType"].elements["response"]), + interface.functions) + function = interface.functions[ + (interface.enums["FunctionID"].elements["Function1_id"], + interface.enums["messageType"].elements["response"])] + self.verify_base_item( + item=function, + name="Function1", + issues=[TestSDLRPCV2Parser._Issue(creator="c1", value=""), + TestSDLRPCV2Parser._Issue(creator="c2", value="")], + platform="") + self.assertIs(function.function_id, + interface.enums["FunctionID"].elements["Function1_id"]) + self.assertIs(function.message_type, + interface.enums["messageType"].elements["response"]) + + self.assertEqual(3, len(function.params)) + + self.assertIn("p1", function.params) + param = function.params["p1"] + self.verify_base_item(item=param, name="p1") + self.assertTrue(param.is_mandatory) + self.assertIs(param.param_type, interface.enums["enum1"]) + self.assertIsNone(param.default_value) + + self.assertIn("p2", function.params) + param = function.params["p2"] + self.verify_base_item(item=param, name="p2") + self.assertTrue(param.is_mandatory) + self.assertIs(param.param_type, interface.enums["enum1"]) + self.assertIs(param.default_value, + interface.enums["enum1"].elements["element2"]) + + self.assertIn("p3", function.params) + param = function.params["p3"] + self.verify_base_item(item=param, name="p3", design_description=[""]) + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.Boolean) + self.assertEqual(False, param.default_value) + + # Function notification "Function2" + + self.assertIn( + (interface.enums["FunctionID"].elements["Function2_id"], + interface.enums["messageType"].elements["notification"]), + interface.functions) + function = interface.functions[ + (interface.enums["FunctionID"].elements["Function2_id"], + interface.enums["messageType"].elements["notification"])] + self.verify_base_item(item=function, + name="Function2", + description=["Function2 description"], + platform="function2 platform") + self.assertIs(function.function_id, + interface.enums["FunctionID"].elements["Function2_id"]) + self.assertIs(function.message_type, + interface.enums["messageType"].elements["notification"]) + + self.assertEqual(3, len(function.params)) + + self.assertIn("n1", function.params) + param = function.params["n1"] + self.verify_base_item(item=param, name="n1", todos=["n1 todo"]) + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.EnumSubset) + self.assertIs(param.param_type.enum, interface.enums["enum1"]) + self.assertDictEqual( + {"element2": interface.enums["enum1"].elements["element2"], + "element3": interface.enums["enum1"].elements["element3"]}, + param.param_type.allowed_elements) + self.assertIsNone(param.default_value) + + self.assertIn("n2", function.params) + param = function.params["n2"] + self.verify_base_item(item=param, name="n2", todos=["n2 todo"]) + self.assertTrue(param.is_mandatory) + self.assertIsInstance(param.param_type, generator.Model.Array) + self.assertEqual(1, param.param_type.min_size) + self.assertEqual(100, param.param_type.max_size) + self.assertIsInstance(param.param_type.element_type, + generator.Model.EnumSubset) + self.assertIs(param.param_type.element_type.enum, + interface.enums["enum1"]) + self.assertDictEqual( + {"element1": interface.enums["enum1"].elements["element1"], + "element3": interface.enums["enum1"].elements["element3"]}, + param.param_type.element_type.allowed_elements) + self.assertIsNone(param.default_value) + + self.assertIn("n3", function.params) + param = function.params["n3"] + self.verify_base_item(item=param, name="n3") + self.assertEqual(False, param.is_mandatory) + self.assertIs(param.param_type, interface.structs["struct2"]) + self.assertIsNone(param.default_value) + + def verify_base_item(self, item, name, description=None, + design_description=None, issues=None, todos=None, + platform=None): + """Verify base interface item variables.""" + self.assertEqual(name, item.name) + self.assertSequenceEqual(self.get_list(description), item.description) + self.assertSequenceEqual(self.get_list(design_description), + item.design_description) + self.assertSequenceEqual(self.get_list(issues), item.issues) + self.assertSequenceEqual(self.get_list(todos), item.todos) + self.assertEqual(platform, item.platform) + + @staticmethod + def get_list(list=None): + """Return provided list or empty list if None is provided.""" + return list if list is not None else [] + +if __name__ == "__main__": + unittest.main() diff --git a/tools/InterfaceGenerator/test/generator/parsers/valid_JSONRPC.xml b/tools/InterfaceGenerator/test/generator/parsers/valid_JSONRPC.xml new file mode 100644 index 0000000000..a754e5714e --- /dev/null +++ b/tools/InterfaceGenerator/test/generator/parsers/valid_JSONRPC.xml @@ -0,0 +1,100 @@ +<?xml version="1.0"?> +<interfaces attr1="v1" attr2="v2"> + <interface name="interface1" attribute1="value1" attribute2="value2"> + <struct name="struct1"> + <param name="member1" type="Integer"> + <description>Param1 description</description> + </param> + <issue creator="creator1">Issue1</issue> + <param name="member2" type="Boolean" mandatory="true" platform="member2 platform"/> + <param name="member3" type="Float" maxvalue="20.5" mandatory="false"/> + <description>Struct description</description> + <issue creator="creator2">Issue2</issue> + <param name="member4" type="Integer" minvalue="11" maxvalue="100" array="true"/> + </struct> + <issue creator="c">Issue1</issue> + <function name="Function1" messagetype="request"> + <description>Description of request Function1</description> + <param name="param1" type="String" mandatory="false" defvalue="String default value"> + <issue creator=""/> + </param> + <param name="param2" type="Integer" platform="param2 platform"> + <description>Param2 description</description> + <todo>Param2 todo</todo> + <description/> + </param> + <todo>Function1 request todo</todo> + <param name="param3" type="struct1" mandatory="false"/> + </function> + <enum name="enum1" internal_scope="scope" platform="enum1 platform"> + <element name="element1" value="10"/> + <element name="element2" internal_name="element2_internal" value="11"/> + <element name="element3" platform="element3 platform"> + <designdescription>Element design description</designdescription> + </element> + </enum> + <designdescription>dd</designdescription> + <issue creator="c">Issue2</issue> + <function name="Function1" messagetype="response" platform=""> + <param name="p1" type="enum1"/> + <issue creator="c1"/> + <issue creator="c2"></issue> + <param name="p2" type="enum1" defvalue="element2"/> + <param name="p3" type="Boolean" defvalue="false"> + <designdescription/> + </param> + </function> + <struct name="struct2" platform="struct2 platform"> + <description>Description of struct2</description> + <param name="m1" type="String"/> + <param name="m2" type="String" maxlength="100" array="true" minsize="1" maxsize="50"/> + <param name="m3" type="enum1"/> + <param name="m4" type="struct1" array="true" maxsize="10"/> + </struct> + <function name="Function2" messagetype="notification" platform="function2 platform"> + <description>Function2 description</description> + <param name="n1" type="enum1"> + <element name="element2"/> + <element name="element3"/> + <todo>n1 todo</todo> + </param> + <param name="n2" type="enum1" array="true" minsize="1" maxsize="100"> + <element name="element3"/> + <todo>n2 todo</todo> + <element name="element1"/> + </param> + <param name="n3" type="struct2" mandatory="false"/> + </function> + </interface> + <interface name="interface2" attribute="value"> + <description>Description of interface2</description> + <enum name="enum1"> + <description>Interface2 enum1 description</description> + <element name="e1" internal_name="int_e1" value="0"/> + <element name="e2" internal_name="int_e2" value="10"/> + </enum> + <enum name="enum2" internal_scope="e2 scope" platform="e2 platform"> + <element name="element1"/> + <element name="element2"/> + <element name="element3"/> + </enum> + <struct name="struct1"> + <param name="m_1" type="enum1" minsize="1" maxsize="10" array="true"/> + <param name="m_2" type="enum2"/> + <param name="m_3" type="String" maxlength="20"/> + </struct> + <function name="Function1" messagetype="request"> + <param name="param1" type="enum1" mandatory="false"/> + <param name="param2" type="struct1" array="true" minsize="5" maxsize="25"/> + </function> + <todo>i2 todo</todo> + <function name="Function1" messagetype="notification" platform="platform"> + <issue creator="c">Issue text</issue> + <param name="param" type="enum2"> + <element name="element2"/> + <element name="element3"/> + </param> + <param name="i1" type="interface1.struct2"/> + </function> + </interface> +</interfaces>
\ No newline at end of file diff --git a/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV1.xml b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV1.xml new file mode 100644 index 0000000000..37ebf39d3a --- /dev/null +++ b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV1.xml @@ -0,0 +1,64 @@ +<?xml version="1.0"?> +<interface name="test_interface" attribute1="value1" attribute2="value2"> + <struct name="struct1"> + <param name="member1" type="Integer"> + <description>Param1 description</description> + </param> + <issue creator="creator1">Issue1</issue> + <param name="member2" type="Boolean" mandatory="true" platform="member2 platform"/> + <param name="member3" type="Float" maxvalue="20.5" mandatory="false"/> + <description>Struct description</description> + <issue creator="creator2">Issue2</issue> + <param name="member4" type="Integer" minvalue="11" maxvalue="100" array="true"/> + </struct> + <function name="Function1" messagetype="request"> + <description>Description of request Function1</description> + <param name="param1" type="String" mandatory="false" defvalue="String default value"> + <issue creator=""/> + </param> + <param name="param2" type="Integer" platform="param2 platform"> + <description>Param2 description</description> + <todo>Param2 todo</todo> + <description/> + </param> + <todo>Function1 request todo</todo> + <param name="param3" type="struct1" mandatory="false"/> + </function> + <enum name="enum1" internal_scope="scope" platform="enum1 platform"> + <element name="element1" value="10"/> + <element name="element2" internal_name="element2_internal" value="11"/> + <element name="element3" platform="element3 platform"> + <designdescription>Element design description</designdescription> + </element> + </enum> + <function name="Function1" messagetype="response" platform=""> + <param name="p1" type="enum1"/> + <issue creator="c1"/> + <issue creator="c2"></issue> + <param name="p2" type="enum1" defvalue="element2"/> + <param name="p3" type="Boolean" defvalue="false"> + <designdescription/> + </param> + </function> + <struct name="struct2" platform="struct2 platform"> + <description>Description of struct2</description> + <param name="m1" type="String"/> + <param name="m2" type="String" maxlength="100" array="true" minsize="1" maxsize="50"/> + <param name="m3" type="enum1"/> + <param name="m4" type="struct1" array="true" maxsize="10"/> + </struct> + <function name="Function2" messagetype="notification" platform="function2 platform"> + <description>Function2 description</description> + <param name="n1" type="enum1"> + <element name="element2"/> + <element name="element3"/> + <todo>n1 todo</todo> + </param> + <param name="n2" type="enum1" array="true" minsize="1" maxsize="100"> + <element name="element3"/> + <todo>n2 todo</todo> + <element name="element1"/> + </param> + <param name="n3" type="struct2" mandatory="false"/> + </function> +</interface> diff --git a/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml new file mode 100644 index 0000000000..cdc5f1ae85 --- /dev/null +++ b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml @@ -0,0 +1,85 @@ +<?xml version="1.0"?> +<interface name="test_interface" attribute1="value1" attribute2="value2"> + <enum name="FunctionID"> + <description>Description string 1</description> + <element name="Function1_id" value="10"> + <designdescription>Function1 element design description</designdescription> + </element> + <description>Description string 2</description> + <todo>Function id todo</todo> + <element name="Function2_id" internal_name="Function2_internal"/> + </enum> + <enum name="messageType"> + <element name="request" value="0"> + <todo>request todo 1</todo> + <issue creator="issue creator">request issue</issue> + <todo>request todo 2</todo> + </element> + <designdescription>messageType design description</designdescription> + <issue creator="messageType issue creator">Issue text</issue> + <element name="response" value="1"/> + <element name="notification" value="2"/> + <designdescription>messageType design description 2</designdescription> + </enum> + <struct name="struct1"> + <param name="member1" type="Integer"> + <description>Param1 description</description> + </param> + <issue creator="creator1">Issue1</issue> + <param name="member2" type="Boolean" mandatory="true" platform="member2 platform"/> + <param name="member3" type="Float" maxvalue="20.5" mandatory="false"/> + <description>Struct description</description> + <issue creator="creator2">Issue2</issue> + <param name="member4" type="Integer" minvalue="11" maxvalue="100" array="true"/> + </struct> + <function name="Function1" functionID="Function1_id" messagetype="request"> + <description>Description of request Function1</description> + <param name="param1" type="String" mandatory="false" defvalue="String default value"> + <issue creator=""/> + </param> + <param name="param2" type="Integer" platform="param2 platform"> + <description>Param2 description</description> + <todo>Param2 todo</todo> + <description/> + </param> + <todo>Function1 request todo</todo> + <param name="param3" type="struct1" mandatory="false"/> + </function> + <enum name="enum1" internal_scope="scope" platform="enum1 platform"> + <element name="element1" value="10"/> + <element name="element2" internal_name="element2_internal" value="11"/> + <element name="element3" platform="element3 platform"> + <designdescription>Element design description</designdescription> + </element> + </enum> + <function name="Function1" functionID="Function1_id" messagetype="response" platform=""> + <param name="p1" type="enum1"/> + <issue creator="c1"/> + <issue creator="c2"></issue> + <param name="p2" type="enum1" defvalue="element2"/> + <param name="p3" type="Boolean" defvalue="false"> + <designdescription/> + </param> + </function> + <struct name="struct2" platform="struct2 platform"> + <description>Description of struct2</description> + <param name="m1" type="String"/> + <param name="m2" type="String" maxlength="100" array="true" minsize="1" maxsize="50"/> + <param name="m3" type="enum1"/> + <param name="m4" type="struct1" array="true" maxsize="10"/> + </struct> + <function name="Function2" functionID="Function2_id" messagetype="notification" platform="function2 platform"> + <description>Function2 description</description> + <param name="n1" type="enum1"> + <element name="element2"/> + <element name="element3"/> + <todo>n1 todo</todo> + </param> + <param name="n2" type="enum1" array="true" minsize="1" maxsize="100"> + <element name="element3"/> + <todo>n2 todo</todo> + <element name="element1"/> + </param> + <param name="n3" type="struct2" mandatory="false"/> + </function> +</interface> |