diff options
Diffstat (limited to 'tools/InterfaceGenerator/test')
12 files changed, 498 insertions, 955 deletions
diff --git a/tools/InterfaceGenerator/test/CodeFormatAndQuality.py b/tools/InterfaceGenerator/test/CodeFormatAndQuality.py new file mode 100755 index 0000000000..d403c821ab --- /dev/null +++ b/tools/InterfaceGenerator/test/CodeFormatAndQuality.py @@ -0,0 +1,39 @@ +# pylint: disable=C0103, C0301, C0115, C0116 +"""Interface model unit test + +""" + +import unittest +from os import walk +from os.path import join +from pathlib import Path + +from pylint.lint import Run + + +class TestCodeFormatAndQuality(unittest.TestCase): + MINIMUM_SCORE = 3.7 + + def setUp(self): + """Searching for all python files to be checked + + """ + self.list_of_files = [] + root = Path(__file__).absolute().parents[1] + for (directory, _, filenames) in walk(root.as_posix()): + self.list_of_files += [join(directory, file) for file in filenames + if file.endswith('.py') and not file.startswith('test')] + self.list_of_files.append('--max-line-length=130') + # self.list_of_files.append('--rcfile=../pylint.ini') + + def test_pylint_conformance(self): + """Performing checks by PyLint + + """ + results = Run(self.list_of_files, do_exit=False) + score = results.linter.stats['global_note'] + self.assertGreaterEqual(score, self.MINIMUM_SCORE) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryBase.py b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryBase.py index aea91f4a45..08f231abe6 100755 --- a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryBase.py +++ b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryBase.py @@ -5,10 +5,21 @@ Verifies common helper functions and produced source code. """ import collections import unittest - -from generator.generators import SmartFactoryBase -from generator import Model - +from pathlib import Path + +import sys + +sys.path.append(Path(__file__).absolute().parents[3].as_posix()) +sys.path.append(Path(__file__).absolute().parents[4].joinpath('rpc_spec/InterfaceParser').as_posix()) +try: + from generator.generators import SmartFactoryBase + from model.enum import Enum + from model.enum_element import EnumElement + from model.issue import Issue + from generator.generators import SmartFactoryBase +except ModuleNotFoundError as error: + print('{}.\nProbably you did not initialize submodule'.format(error)) + sys.exit(1) EXPECTED_RESULT_FULL_COMMENT = u"""/** * @brief Enumeration Test Name. @@ -133,15 +144,14 @@ DESCRIPTION = [u"Description Line1", u"Description Line2"] DESIGN_DESCRIPTION = [u"Design Line1"] -ISSUES = [Model.Issue(value=u"Issue1"), - Model.Issue(value=u"Issue2"), - Model.Issue(value=u"Issue3")] +ISSUES = [Issue(value=u"Issue1"), + Issue(value=u"Issue2"), + Issue(value=u"Issue3")] TODOS = [u"Do1", u"Do2"] class Test(unittest.TestCase): - """Test for SmartFactory base generator. This class holds set of test cases for the SmartFactory base generator. @@ -156,11 +166,11 @@ class Test(unittest.TestCase): """ generator = SmartFactoryBase.CodeGenerator() - enum = Model.Enum(name=u"Test Name", - description=DESCRIPTION, - design_description=DESIGN_DESCRIPTION, - issues=ISSUES, - todos=TODOS) + enum = Enum(name=u"Test Name", + description=DESCRIPTION, + design_description=DESIGN_DESCRIPTION, + issues=ISSUES, + todos=TODOS) self.assertEqual(generator._gen_comment(enum), EXPECTED_RESULT_FULL_COMMENT, "Full comment for enum is invalid") @@ -173,16 +183,16 @@ class Test(unittest.TestCase): """ generator = SmartFactoryBase.CodeGenerator() - enum_element1 = Model.EnumElement(name=u"Element1", - internal_name=u"InternalName", - value=u"10") + enum_element1 = EnumElement(name=u"Element1", + internal_name=u"InternalName", + value=u"10") self.assertEqual( generator._gen_enum_element(enum_element1), EXPECTED_RESULT_ENUM_ELEMENT1, "Short commented enum element with internal name is invalid") - enum_element2 = Model.EnumElement( + enum_element2 = EnumElement( name=u"NO_VALUE_ELEMENT", description=DESCRIPTION, design_description=DESIGN_DESCRIPTION) @@ -198,14 +208,14 @@ class Test(unittest.TestCase): """ generator = SmartFactoryBase.CodeGenerator() - elements = [Model.EnumElement(name=u"name1", - design_description=DESIGN_DESCRIPTION, - todos=TODOS, - value=u"1"), - Model.EnumElement(name=u"name2", - description=DESCRIPTION, - issues=ISSUES, - internal_name=u"internal_name2")] + elements = [EnumElement(name=u"name1", + design_description=DESIGN_DESCRIPTION, + todos=TODOS, + value=u"1"), + EnumElement(name=u"name2", + description=DESCRIPTION, + issues=ISSUES, + internal_name=u"internal_name2")] self.assertEqual(generator._gen_enum_elements(elements), EXPECTED_RESULT_ENUM_ELEMENTS1, "Simple enum elements are invalid") @@ -219,35 +229,35 @@ class Test(unittest.TestCase): generator = SmartFactoryBase.CodeGenerator() elements1 = collections.OrderedDict() - elements1[u"name1"] = Model.EnumElement( + elements1[u"name1"] = EnumElement( name=u"name1", design_description=DESIGN_DESCRIPTION, todos=TODOS, value=u"1") - elements1[u"name2"] = Model.EnumElement( + elements1[u"name2"] = EnumElement( name=u"name2", description=DESCRIPTION, issues=ISSUES, internal_name=u"internal_name2") - enum1 = Model.Enum(name=u"Enum1", - todos=TODOS, - elements=elements1) + enum1 = Enum(name=u"Enum1", + todos=TODOS, + elements=elements1) self.assertEqual(generator._gen_enum(enum1), EXPECTED_RESULT_ENUM1, "Simple enum is invalid") elements2 = collections.OrderedDict() - elements2[u"xxx"] = Model.EnumElement(name=u"xxx", - internal_name=u"val_1") - elements2[u"yyy"] = Model.EnumElement(name=u"yyy", - internal_name=u"val_2", - value=u"100") - elements2[u"zzz"] = Model.EnumElement(name=u"val_3") - - enum2 = Model.Enum(name=u"E2", - elements=elements2) + elements2[u"xxx"] = EnumElement(name=u"xxx", + internal_name=u"val_1") + elements2[u"yyy"] = EnumElement(name=u"yyy", + internal_name=u"val_2", + value=u"100") + elements2[u"zzz"] = EnumElement(name=u"val_3") + + enum2 = Enum(name=u"E2", + elements=elements2) self.assertEqual(generator._gen_enum(enum2), EXPECTED_RESULT_ENUM2, "Long enum is invalid") @@ -279,5 +289,6 @@ class Test(unittest.TestCase): "aaa aaa"]), ["aaa", "1", "bbb", "2", "ccc", "3", "aaa aaa"]) + if __name__ == '__main__': unittest.main() diff --git a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py index 533fe92eb5..d3262c8da2 100755 --- a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py +++ b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py @@ -3,18 +3,36 @@ Verifies format specific functions and produced source code. """ -import collections import codecs +import collections import os import unittest import uuid - -from mock import MagicMock -from mock import call - -from generator.generators import SmartFactoryJSONRPC -from generator import Model - +from pathlib import Path +from unittest.mock import MagicMock +from unittest.mock import call + +import sys + +sys.path.append(Path(__file__).absolute().parents[3].as_posix()) +sys.path.append(Path(__file__).absolute().parents[4].joinpath('rpc_spec/InterfaceParser').as_posix()) +try: + from generator.generators import SmartFactoryJSONRPC + from model.array import Array + from model.boolean import Boolean + from model.float import Float + from model.enum import Enum + from model.enum_element import EnumElement + from model.enum_subset import EnumSubset + from model.function import Function + from model.integer import Integer + from model.interface import Interface + from model.issue import Issue + from model.param import Param + from model.struct import Struct +except ModuleNotFoundError as error: + print('{}.\nProbably you did not initialize submodule'.format(error)) + sys.exit(1) EXPECTED_RESULT_REQUEST = ( u"""params_members[ns_smart_device_link::ns_json_handler::""" @@ -124,15 +142,14 @@ DESCRIPTION = [u"Description Line1", u"Description Line2"] DESIGN_DESCRIPTION = [u"Design Line1"] -ISSUES = [Model.Issue(value=u"Issue1"), - Model.Issue(value=u"Issue2"), - Model.Issue(value=u"Issue3")] +ISSUES = [Issue(value=u"Issue1"), + Issue(value=u"Issue2"), + Issue(value=u"Issue3")] TODOS = [u"Do1", u"Do2"] class Test(unittest.TestCase): - """Test for JSONRPC SmartFactory generator. This class holds set of test cases for the JSONRPC SmartFactory generator. @@ -183,14 +200,14 @@ class Test(unittest.TestCase): generator = SmartFactoryJSONRPC.CodeGenerator() message_type_elements = collections.OrderedDict() - message_type_elements[u"request"] = Model.EnumElement(name=u"request") - message_type_elements[u"response"] = Model.EnumElement( + message_type_elements[u"request"] = EnumElement(name=u"request") + message_type_elements[u"response"] = EnumElement( name=u"response") - message_type_elements[u"notification"] = Model.EnumElement( + message_type_elements[u"notification"] = EnumElement( name=u"notification") - message_type = Model.Enum(name=u"messageType", - elements=message_type_elements) + message_type = Enum(name=u"messageType", + elements=message_type_elements) result_enum = generator._preprocess_message_type(message_type) @@ -199,12 +216,12 @@ class Test(unittest.TestCase): result_enum.elements["error_response"].primary_name) message_type_elements = collections.OrderedDict() - message_type_elements[u"request"] = Model.EnumElement(name=u"request") - message_type_elements[u"notification"] = Model.EnumElement( + message_type_elements[u"request"] = EnumElement(name=u"request") + message_type_elements[u"notification"] = EnumElement( name=u"notification") - message_type = Model.Enum(name=u"messageType", - elements=message_type_elements) + message_type = Enum(name=u"messageType", + elements=message_type_elements) result_enum = generator._preprocess_message_type(message_type) @@ -217,6 +234,7 @@ class Test(unittest.TestCase): function. """ + self.maxDiff = None generator = SmartFactoryJSONRPC.CodeGenerator() @@ -225,16 +243,16 @@ class Test(unittest.TestCase): "Invalid code for empty functions list") message_type_elements = collections.OrderedDict() - message_type_elements[u"request"] = Model.EnumElement(name=u"request") - message_type_elements[u"response"] = Model.EnumElement( + message_type_elements[u"request"] = EnumElement(name=u"request") + message_type_elements[u"response"] = EnumElement( name=u"response") - message_type_elements[u"notification"] = Model.EnumElement( + message_type_elements[u"notification"] = EnumElement( name=u"notification") - message_type = Model.Enum(name=u"messageType", - elements=message_type_elements) + message_type = Enum(name=u"messageType", + elements=message_type_elements) - function1 = Model.Function( + function1 = Function( "func1", function_id=message_type.elements[u"request"], message_type=message_type.elements[u"request"]) @@ -242,18 +260,20 @@ class Test(unittest.TestCase): generator._gen_pre_function_schemas([function1]), "Invalid code for empty functions list") - function2 = Model.Function( + function2 = Function( "func2", function_id=message_type.elements[u"request"], message_type=message_type.elements[u"response"]) - - self.assertEqual(EXPECTED_PRE_FUNCTION_CODE, - generator._gen_pre_function_schemas([function2]), - "Invalid code for single response function") - - self.assertEqual(EXPECTED_PRE_FUNCTION_CODE, - generator._gen_pre_function_schemas([function1, - function2]), - "Invalid code for mixed function list") + try: + self.assertEqual(EXPECTED_PRE_FUNCTION_CODE, + generator._gen_pre_function_schemas([function2]), + "Invalid code for single response function") + + self.assertEqual(EXPECTED_PRE_FUNCTION_CODE, + generator._gen_pre_function_schemas([function1, + function2]), + "Invalid code for mixed function list") + except AssertionError as message: + print(message) def test_full_generation(self): """Test full generation using JSONRPC SmartSchema generator. @@ -264,66 +284,66 @@ class Test(unittest.TestCase): directory as this module. """ - - expected_h_file_content = open("test_expected_jsonrpc.h", "r").read() - expected_cc_file_content = open("test_expected_jsonrpc.cc", "r").read() + self.maxDiff = None + expected_h_file_content = Path(__file__).parents[0].joinpath("test_expected_jsonrpc.h").read_text() + expected_cc_file_content = Path(__file__).parents[0].joinpath("test_expected_jsonrpc.cc").read_text() generator = SmartFactoryJSONRPC.CodeGenerator() message_type_elements = collections.OrderedDict() - message_type_elements[u"request"] = Model.EnumElement(name=u"request") - message_type_elements[u"response"] = Model.EnumElement( + message_type_elements[u"request"] = EnumElement(name=u"request") + message_type_elements[u"response"] = EnumElement( name=u"response") - message_type_elements[u"notification"] = Model.EnumElement( + message_type_elements[u"notification"] = EnumElement( name=u"notification") - message_type = Model.Enum(name=u"messageType", - elements=message_type_elements) + message_type = Enum(name=u"messageType", + elements=message_type_elements) elements1 = collections.OrderedDict() - elements1[u"name1"] = Model.EnumElement( + elements1[u"name1"] = EnumElement( name=u"name1", design_description=DESIGN_DESCRIPTION, todos=TODOS, value=u"1") - elements1[u"name2"] = Model.EnumElement( + elements1[u"name2"] = EnumElement( name="name2", description=DESCRIPTION, issues=ISSUES, internal_name=u"internal_name2") - enum1 = Model.Enum(name=u"Enum1", - todos=TODOS, - elements=elements1) + enum1 = Enum(name=u"Enum1", + todos=TODOS, + elements=elements1) elements2 = collections.OrderedDict() - elements2[u"xxx"] = Model.EnumElement(name=u"xxx", - internal_name=u"val_1") - elements2[u"yyy"] = Model.EnumElement(name=u"yyy", - internal_name=u"val_2", - value=u"100") - elements2[u"zzz"] = Model.EnumElement(name=u"val_3") + elements2[u"xxx"] = EnumElement(name=u"xxx", + internal_name=u"val_1") + elements2[u"yyy"] = EnumElement(name=u"yyy", + internal_name=u"val_2", + value=u"100") + elements2[u"zzz"] = EnumElement(name=u"val_3") - enum2 = Model.Enum(name=u"E2", - elements=elements2) + enum2 = Enum(name=u"E2", + elements=elements2) elements3 = collections.OrderedDict() - elements3["1"] = Model.EnumElement(name="xxx", - internal_name="_1") - elements3["2"] = Model.EnumElement(name="xxx", - internal_name="_2") - elements3["3"] = Model.EnumElement(name="xxx", - internal_name="_3") - enum3 = Model.Enum(name="Enum_new2", - elements=elements3) + elements3["1"] = EnumElement(name="xxx", + internal_name="_1") + elements3["2"] = EnumElement(name="xxx", + internal_name="_2") + elements3["3"] = EnumElement(name="xxx", + internal_name="_3") + enum3 = Enum(name="Enum_new2", + elements=elements3) elements4 = collections.OrderedDict() - elements4["name1"] = Model.EnumElement(name="xxx", - internal_name="_11") - elements4["name2"] = Model.EnumElement(name="xxx", - internal_name="_22") - enum4 = Model.Enum(name="Enum_new4", - elements=elements4) + elements4["name1"] = EnumElement(name="xxx", + internal_name="_11") + elements4["name2"] = EnumElement(name="xxx", + internal_name="_22") + enum4 = Enum(name="Enum_new4", + elements=elements4) enums = collections.OrderedDict() enums["Enum1"] = enum1 @@ -333,7 +353,7 @@ class Test(unittest.TestCase): enums["messageType"] = message_type params1 = collections.OrderedDict() - params1["1"] = Model.FunctionParam( + params1["1"] = Param( name="param1", design_description=DESIGN_DESCRIPTION, description=DESCRIPTION, @@ -341,110 +361,110 @@ class Test(unittest.TestCase): todos=TODOS, param_type=enum4, default_value=elements4["name1"]) - params1["2"] = Model.FunctionParam( + params1["2"] = Param( name="param2", - param_type=Model.EnumSubset( + param_type=EnumSubset( name="sub1", enum=enum1, allowed_elements={"e1": elements1["name1"]}), default_value=elements1["name1"]) functions = collections.OrderedDict() - functions["Function1"] = Model.Function( + functions["Function1"] = Function( name="Function1", function_id=elements1["name1"], message_type=message_type_elements["request"], params=params1) - functions["Function2"] = Model.Function( + functions["Function2"] = Function( name="Function2", function_id=elements2["xxx"], message_type=message_type_elements["response"]) - functions["Function3"] = Model.Function( + functions["Function3"] = Function( name="Function2", function_id=elements2["yyy"], message_type=message_type_elements["notification"]) members1 = collections.OrderedDict() - members1["m1"] = Model.Param(name="intParam", - param_type=Model.Integer(max_value=2)) - members1["m11"] = Model.Param(name="doubleParam", - param_type=Model.Double(min_value=0.333), - is_mandatory=False) - members1["m222"] = Model.Param(name="boolParam", - param_type=Model.Boolean()) - members1["m2"] = Model.Param(name="structParam", - param_type=Model.Struct(name="Struct2")) - members1["aaa"] = Model.Param(name="enumParam", - param_type=enum1) - members1["bbb"] = Model.Param(name="enumParam1", - param_type=enum1) - members1["xxx"] = Model.Param( + members1["m1"] = Param(name="intParam", + param_type=Integer(max_value=2)) + members1["m11"] = Param(name="doubleParam", + param_type=Float(min_value=0.333), + is_mandatory=False) + members1["m222"] = Param(name="boolParam", + param_type=Boolean()) + members1["m2"] = Param(name="structParam", + param_type=Struct(name="Struct2")) + members1["aaa"] = Param(name="enumParam", + param_type=enum1) + members1["bbb"] = Param(name="enumParam1", + param_type=enum1) + members1["xxx"] = Param( name="enumSubset1", - param_type=Model.EnumSubset( + param_type=EnumSubset( name="sub", enum=enum1, allowed_elements={"e1": elements1["name1"]}), is_mandatory=False) - members1["1"] = Model.Param( + members1["1"] = Param( name="arrayOfInt", - param_type=Model.Array(min_size=0, - max_size=20, - element_type=Model.Boolean()), + param_type=Array(min_size=0, + max_size=20, + element_type=Boolean()), is_mandatory=False) - members1["2"] = Model.Param( + members1["2"] = Param( name="arrayOfEnum1", - param_type=Model.Array(min_size=0, - max_size=20, - element_type=enum1), + param_type=Array(min_size=0, + max_size=20, + element_type=enum1), is_mandatory=False) - members1["3"] = Model.Param( + members1["3"] = Param( name="arrayOfEnum3", - param_type=Model.Array(min_size=10, - max_size=40, - element_type=enum3), + param_type=Array(min_size=10, + max_size=40, + element_type=enum3), is_mandatory=True) - members1["4"] = Model.Param( + members1["4"] = Param( name="arrayOfEnum4", - param_type=Model.Array( + param_type=Array( min_size=10, max_size=41, - element_type=Model.EnumSubset( + element_type=EnumSubset( name="sub1", enum=enum1, allowed_elements={"e1": elements1["name1"]}))) - members1["5"] = Model.Param( + members1["5"] = Param( name="arrayOfEnum5", - param_type=Model.Array( + param_type=Array( min_size=10, max_size=42, - element_type=Model.EnumSubset( + element_type=EnumSubset( name="sub2", enum=enum1, allowed_elements={"e1": elements1["name2"]}))) - members1["6"] = Model.Param( + members1["6"] = Param( name="arrayOfEnum6", - param_type=Model.Array( + param_type=Array( min_size=10, max_size=43, - element_type=Model.EnumSubset( + element_type=EnumSubset( name="sub3", enum=enum4, allowed_elements={"e1": elements4["name2"]}))) structs = collections.OrderedDict() - structs["Struct1"] = Model.Struct( + structs["Struct1"] = Struct( name="Struct1", design_description=DESIGN_DESCRIPTION, issues=ISSUES, members=members1) - structs["Struct2"] = Model.Struct(name="Struct2", - issues=ISSUES) + structs["Struct2"] = Struct(name="Struct2", + issues=ISSUES) - interface = Model.Interface(enums=enums, - structs=structs, - functions=functions, - params={"param1": "value1", - "param2": "value2"}) + interface = Interface(enums=enums, + structs=structs, + functions=functions, + params={"param1": "value1", + "param2": "value2"}) os.path.exists = MagicMock(return_value=True) uuid.uuid1 = MagicMock( @@ -468,15 +488,21 @@ class Test(unittest.TestCase): "Invalid header file creation") self.assertEqual(mock_calls[4], - call('/some/test/dir/Test.cc', + call('/some/test/dir/Test_schema.h', mode='w', encoding='utf-8'), "Invalid source file creation") + try: + self.assertSequenceEqual(str(mock_calls[2])[27:-2].replace("\\n", "\n"), + expected_h_file_content, + "Invalid header file content") + + self.assertSequenceEqual(str(mock_calls[6])[27:-2].replace("\\n", "\n"), + expected_cc_file_content, + "Invalid source file content") + except AssertionError as message: + print(message) - self.assertEqual(str(mock_calls[2])[27:-2].replace("\\n", "\n"), - expected_h_file_content, - "Invalid header file content") - self.assertEqual(str(mock_calls[6])[27:-2].replace("\\n", "\n"), - expected_cc_file_content, - "Invalid source file content") +if __name__ == '__main__': + unittest.main() diff --git a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py index 3c354cd34b..4b21a64ec1 100755 --- a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py +++ b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py @@ -3,18 +3,36 @@ Verifies format specific functions and produced source code. """ -import collections import codecs +import collections import os import unittest import uuid - -from mock import MagicMock -from mock import call - -from generator.generators import SmartFactorySDLRPC -from generator import Model - +from pathlib import Path +from unittest.mock import MagicMock +from unittest.mock import call + +import sys + +sys.path.append(Path(__file__).absolute().parents[3].as_posix()) +sys.path.append(Path(__file__).absolute().parents[4].joinpath('rpc_spec/InterfaceParser').as_posix()) +try: + from generator.generators import SmartFactorySDLRPC + from model.array import Array + from model.boolean import Boolean + from model.float import Float + from model.enum import Enum + from model.enum_element import EnumElement + from model.enum_subset import EnumSubset + from model.function import Function + from model.integer import Integer + from model.interface import Interface + from model.issue import Issue + from model.param import Param + from model.struct import Struct +except ModuleNotFoundError as error: + print('{}.\nProbably you did not initialize submodule'.format(error)) + sys.exit(1) EXPECTED_NOTIFICATION_RESULT = ( u"""params_members[ns_smart_device_link::ns_json_handler::""" @@ -41,15 +59,14 @@ DESCRIPTION = [u"Description Line1", u"Description Line2"] DESIGN_DESCRIPTION = [u"Design Line1"] -ISSUES = [Model.Issue(value=u"Issue1"), - Model.Issue(value=u"Issue2"), - Model.Issue(value=u"Issue3")] +ISSUES = [Issue(value=u"Issue1"), + Issue(value=u"Issue2"), + Issue(value=u"Issue3")] TODOS = [u"Do1", u"Do2"] class Test(unittest.TestCase): - """Test for SLDRPC SmartFactory generator. This class holds set of test cases for the SDLRPC SmartFactory generator. @@ -107,66 +124,66 @@ class Test(unittest.TestCase): this module. """ - - expected_h_file_content = open("test_expected_sdlrpc.h", "r").read() - expected_cc_file_content = open("test_expected_sdlrpc.cc", "r").read() + self.maxDiff = None + expected_h_file_content = Path(__file__).parents[0].joinpath('test_expected_sdlrpc.h').read_text() + expected_cc_file_content = Path(__file__).parents[0].joinpath('test_expected_sdlrpc.cc').read_text() generator = SmartFactorySDLRPC.CodeGenerator() message_type_elements = collections.OrderedDict() - message_type_elements[u"request"] = Model.EnumElement(name=u"request") - message_type_elements[u"response"] = Model.EnumElement( + message_type_elements[u"request"] = EnumElement(name=u"request") + message_type_elements[u"response"] = EnumElement( name=u"response") - message_type_elements[u"notification"] = Model.EnumElement( + message_type_elements[u"notification"] = EnumElement( name=u"notification") - message_type = Model.Enum(name=u"messageType", - elements=message_type_elements) + message_type = Enum(name=u"messageType", + elements=message_type_elements) elements1 = collections.OrderedDict() - elements1[u"name1"] = Model.EnumElement( + elements1[u"name1"] = EnumElement( name=u"name1", design_description=DESIGN_DESCRIPTION, todos=TODOS, value=u"1") - elements1[u"name2"] = Model.EnumElement( + elements1[u"name2"] = EnumElement( name="name2", description=DESCRIPTION, issues=ISSUES, internal_name=u"internal_name2") - enum1 = Model.Enum(name=u"Enum1", - todos=TODOS, - elements=elements1) + enum1 = Enum(name=u"Enum1", + todos=TODOS, + elements=elements1) elements2 = collections.OrderedDict() - elements2[u"xxx"] = Model.EnumElement(name=u"xxx", - internal_name=u"val_1") - elements2[u"yyy"] = Model.EnumElement(name=u"yyy", - internal_name=u"val_2", - value=u"100") - elements2[u"zzz"] = Model.EnumElement(name=u"val_3") + elements2[u"xxx"] = EnumElement(name=u"xxx", + internal_name=u"val_1") + elements2[u"yyy"] = EnumElement(name=u"yyy", + internal_name=u"val_2", + value=u"100") + elements2[u"zzz"] = EnumElement(name=u"val_3") - enum2 = Model.Enum(name=u"E2", - elements=elements2) + enum2 = Enum(name=u"E2", + elements=elements2) elements3 = collections.OrderedDict() - elements3["1"] = Model.EnumElement(name="xxx", - internal_name="_1") - elements3["2"] = Model.EnumElement(name="xxx", - internal_name="_2") - elements3["3"] = Model.EnumElement(name="xxx", - internal_name="_3") - enum3 = Model.Enum(name="Enum_new2", - elements=elements3) + elements3["1"] = EnumElement(name="xxx", + internal_name="_1") + elements3["2"] = EnumElement(name="xxx", + internal_name="_2") + elements3["3"] = EnumElement(name="xxx", + internal_name="_3") + enum3 = Enum(name="Enum_new2", + elements=elements3) elements4 = collections.OrderedDict() - elements4["name1"] = Model.EnumElement(name="xxx", - internal_name="_11") - elements4["name2"] = Model.EnumElement(name="xxx", - internal_name="_22") - enum4 = Model.Enum(name="Enum_new4", - elements=elements4) + elements4["name1"] = EnumElement(name="xxx", + internal_name="_11") + elements4["name2"] = EnumElement(name="xxx", + internal_name="_22") + enum4 = Enum(name="Enum_new4", + elements=elements4) enums = collections.OrderedDict() enums["Enum1"] = enum1 @@ -176,7 +193,7 @@ class Test(unittest.TestCase): enums["messageType"] = message_type params1 = collections.OrderedDict() - params1["1"] = Model.FunctionParam( + params1["1"] = Param( name="param1", design_description=DESIGN_DESCRIPTION, description=DESCRIPTION, @@ -184,110 +201,110 @@ class Test(unittest.TestCase): todos=TODOS, param_type=enum4, default_value=elements4["name1"]) - params1["2"] = Model.FunctionParam( + params1["2"] = Param( name="param2", - param_type=Model.EnumSubset( + param_type=EnumSubset( name="sub1", enum=enum1, allowed_elements={"e1": elements1["name1"]}), default_value=elements1["name1"]) functions = collections.OrderedDict() - functions["Function1"] = Model.Function( + functions["Function1"] = Function( name="Function1", function_id=elements1["name1"], message_type=message_type_elements["request"], params=params1) - functions["Function2"] = Model.Function( + functions["Function2"] = Function( name="Function2", function_id=elements2["xxx"], message_type=message_type_elements["response"]) - functions["Function3"] = Model.Function( + functions["Function3"] = Function( name="Function2", function_id=elements2["yyy"], message_type=message_type_elements["notification"]) members1 = collections.OrderedDict() - members1["m1"] = Model.Param(name="intParam", - param_type=Model.Integer(max_value=2)) - members1["m11"] = Model.Param(name="doubleParam", - param_type=Model.Double(min_value=0.333), - is_mandatory=False) - members1["m222"] = Model.Param(name="boolParam", - param_type=Model.Boolean()) - members1["m2"] = Model.Param(name="structParam", - param_type=Model.Struct(name="Struct2")) - members1["aaa"] = Model.Param(name="enumParam", - param_type=enum1) - members1["bbb"] = Model.Param(name="enumParam1", - param_type=enum1) - members1["xxx"] = Model.Param( + members1["m1"] = Param(name="intParam", + param_type=Integer(max_value=2)) + members1["m11"] = Param(name="doubleParam", + param_type=Float(min_value=0.333), + is_mandatory=False) + members1["m222"] = Param(name="boolParam", + param_type=Boolean()) + members1["m2"] = Param(name="structParam", + param_type=Struct(name="Struct2")) + members1["aaa"] = Param(name="enumParam", + param_type=enum1) + members1["bbb"] = Param(name="enumParam1", + param_type=enum1) + members1["xxx"] = Param( name="enumSubset1", - param_type=Model.EnumSubset( + param_type=EnumSubset( name="sub", enum=enum1, allowed_elements={"e1": elements1["name1"]}), is_mandatory=False) - members1["1"] = Model.Param( + members1["1"] = Param( name="arrayOfInt", - param_type=Model.Array(min_size=0, - max_size=20, - element_type=Model.Boolean()), + param_type=Array(min_size=0, + max_size=20, + element_type=Boolean()), is_mandatory=False) - members1["2"] = Model.Param( + members1["2"] = Param( name="arrayOfEnum1", - param_type=Model.Array(min_size=0, - max_size=20, - element_type=enum1), + param_type=Array(min_size=0, + max_size=20, + element_type=enum1), is_mandatory=False) - members1["3"] = Model.Param( + members1["3"] = Param( name="arrayOfEnum3", - param_type=Model.Array(min_size=10, - max_size=40, - element_type=enum3), + param_type=Array(min_size=10, + max_size=40, + element_type=enum3), is_mandatory=True) - members1["4"] = Model.Param( + members1["4"] = Param( name="arrayOfEnum4", - param_type=Model.Array( + param_type=Array( min_size=10, max_size=41, - element_type=Model.EnumSubset( + element_type=EnumSubset( name="sub1", enum=enum1, allowed_elements={"e1": elements1["name1"]}))) - members1["5"] = Model.Param( + members1["5"] = Param( name="arrayOfEnum5", - param_type=Model.Array( + param_type=Array( min_size=10, max_size=42, - element_type=Model.EnumSubset( + element_type=EnumSubset( name="sub2", enum=enum1, allowed_elements={"e1": elements1["name2"]}))) - members1["6"] = Model.Param( + members1["6"] = Param( name="arrayOfEnum6", - param_type=Model.Array( + param_type=Array( min_size=10, max_size=43, - element_type=Model.EnumSubset( + element_type=EnumSubset( name="sub3", enum=enum4, allowed_elements={"e1": elements4["name2"]}))) structs = collections.OrderedDict() - structs["Struct1"] = Model.Struct( + structs["Struct1"] = Struct( name="Struct1", design_description=DESIGN_DESCRIPTION, issues=ISSUES, members=members1) - structs["Struct2"] = Model.Struct(name="Struct2", - issues=ISSUES) + structs["Struct2"] = Struct(name="Struct2", + issues=ISSUES) - interface = Model.Interface(enums=enums, - structs=structs, - functions=functions, - params={"param1": "value1", - "param2": "value2"}) + interface = Interface(enums=enums, + structs=structs, + functions=functions, + params={"param1": "value1", + "param2": "value2"}) os.path.exists = MagicMock(return_value=True) uuid.uuid1 = MagicMock( @@ -311,15 +328,21 @@ class Test(unittest.TestCase): "Invalid header file creation") self.assertEqual(mock_calls[4], - call('/some/test/dir/Test.cc', + call('/some/test/dir/Test_schema.h', mode='w', encoding='utf-8'), "Invalid source file creation") + try: + self.assertSequenceEqual(str(mock_calls[2])[27:-2].replace("\\n", "\n"), + expected_h_file_content, + "Invalid header file content") + + self.assertSequenceEqual(str(mock_calls[6])[27:-2].replace("\\n", "\n"), + expected_cc_file_content, + "Invalid source file content") + except AssertionError as message: + print(message) - self.assertEqual(str(mock_calls[2])[27:-2].replace("\\n", "\n"), - expected_h_file_content, - "Invalid header file content") - self.assertEqual(str(mock_calls[6])[27:-2].replace("\\n", "\n"), - expected_cc_file_content, - "Invalid source file content") +if __name__ == '__main__': + unittest.main() diff --git a/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py b/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py index f2fecdb901..90700fdbb9 100755 --- a/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py +++ b/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py @@ -1,13 +1,25 @@ """JSONRPC XML parser unit test.""" import os +import sys import unittest - -import generator.Model -import generator.parsers.JSONRPC +from pathlib import Path + +sys.path.append(Path(__file__).absolute().parents[3].as_posix()) +sys.path.append(Path(__file__).absolute().parents[4].joinpath('rpc_spec/InterfaceParser').as_posix()) +try: + import generator.parsers.JSONRPC + from model.array import Array + from model.boolean import Boolean + from model.enum_subset import EnumSubset + from model.integer import Integer + from model.float import Float + from model.string import String +except ModuleNotFoundError as error: + print('{}.\nJSONRPC\tProbably you did not initialize submodule'.format(error)) + sys.exit(1) class TestJSONRPCVParser(unittest.TestCase): - """Test for JSONRPC xml parser.""" class _Issue: @@ -21,7 +33,7 @@ class TestJSONRPCVParser(unittest.TestCase): def setUp(self): """Test initialization.""" self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \ - "/valid_JSONRPC.xml" + "/valid_JSONRPC.xml" self.parser = generator.parsers.JSONRPC.Parser() def test_valid_xml(self): @@ -37,7 +49,7 @@ class TestJSONRPCVParser(unittest.TestCase): "interface1_design_description": "dd", "interface2_attribute": "value", "interface2_description": - "Description of interface2", + "Description of interface2", "interface2_todos": "i2 todo"}, interface.params) @@ -217,7 +229,7 @@ class TestJSONRPCVParser(unittest.TestCase): name="member1", description=["Param1 description"]) self.assertTrue(member.is_mandatory) - self.assertIsInstance(member.param_type, generator.Model.Integer) + self.assertIsInstance(member.param_type, Integer) self.assertIsNone(member.param_type.min_value) self.assertIsNone(member.param_type.max_value) @@ -226,13 +238,13 @@ class TestJSONRPCVParser(unittest.TestCase): 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.assertIsInstance(member.param_type, 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.assertIsInstance(member.param_type, Float) self.assertIsNone(member.param_type.min_value) self.assertAlmostEqual(20.5, member.param_type.max_value) @@ -240,11 +252,11 @@ class TestJSONRPCVParser(unittest.TestCase): 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.assertIsInstance(member.param_type, 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) + Integer) self.assertEqual(11, member.param_type.element_type.min_value) self.assertEqual(100, member.param_type.element_type.max_value) @@ -263,18 +275,18 @@ class TestJSONRPCVParser(unittest.TestCase): 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.assertIsInstance(member.param_type, 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.assertIsInstance(member.param_type, 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) + String) self.assertEqual(100, member.param_type.element_type.max_length) self.assertIn("m3", struct.members) @@ -287,7 +299,7 @@ class TestJSONRPCVParser(unittest.TestCase): 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.assertIsInstance(member.param_type, Array) self.assertIsNone(member.param_type.min_size) self.assertEqual(10, member.param_type.max_size) self.assertIs(member.param_type.element_type, @@ -305,7 +317,7 @@ class TestJSONRPCVParser(unittest.TestCase): 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.assertIsInstance(member.param_type, Array) self.assertEqual(1, member.param_type.min_size) self.assertEqual(10, member.param_type.max_size) self.assertIs(member.param_type.element_type, @@ -321,7 +333,7 @@ class TestJSONRPCVParser(unittest.TestCase): 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.assertIsInstance(member.param_type, String) self.assertEqual(20, member.param_type.max_length) # Functions @@ -357,9 +369,10 @@ class TestJSONRPCVParser(unittest.TestCase): name="param1", issues=[TestJSONRPCVParser._Issue(creator="", value="")]) self.assertEqual(False, param.is_mandatory) - self.assertIsInstance(param.param_type, generator.Model.String) + self.assertIsInstance(param.param_type, String) self.assertIsNone(param.param_type.max_length) - self.assertEqual("String default value", param.default_value) + self.assertIsNone(param.default_value) + self.assertEqual("String default value", param.param_type.default_value) self.assertIn("param2", function.params) param = function.params["param2"] @@ -370,7 +383,7 @@ class TestJSONRPCVParser(unittest.TestCase): todos=["Param2 todo"], platform="param2 platform") self.assertTrue(param.is_mandatory) - self.assertIsInstance(param.param_type, generator.Model.Integer) + self.assertIsInstance(param.param_type, Integer) self.assertIsNone(param.param_type.min_value) self.assertIsNone(param.param_type.max_value) self.assertIsNone(param.default_value) @@ -418,16 +431,18 @@ class TestJSONRPCVParser(unittest.TestCase): 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.assertIsNone(param.default_value) + self.assertIsNone(param.param_type.default_value) + self.assertIs(param.param_type.elements["element2"], + 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) + self.assertIsInstance(param.param_type, Boolean) + self.assertIsNone(param.default_value) + self.assertFalse(param.param_type.default_value) # Function notification "interface1_Function2" @@ -454,14 +469,14 @@ class TestJSONRPCVParser(unittest.TestCase): 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.assertIsInstance(param.param_type, EnumSubset) self.assertIs(param.param_type.enum, interface.enums["interface1_enum1"]) self.assertDictEqual( {"element2": - interface.enums["interface1_enum1"].elements["element2"], + interface.enums["interface1_enum1"].elements["element2"], "element3": - interface.enums["interface1_enum1"].elements["element3"]}, + interface.enums["interface1_enum1"].elements["element3"]}, param.param_type.allowed_elements) self.assertIsNone(param.default_value) @@ -469,18 +484,18 @@ class TestJSONRPCVParser(unittest.TestCase): 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.assertIsInstance(param.param_type, 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) + EnumSubset) self.assertIs(param.param_type.element_type.enum, interface.enums["interface1_enum1"]) self.assertDictEqual( {"element1": - interface.enums["interface1_enum1"].elements["element1"], + interface.enums["interface1_enum1"].elements["element1"], "element3": - interface.enums["interface1_enum1"].elements["element3"]}, + interface.enums["interface1_enum1"].elements["element3"]}, param.param_type.element_type.allowed_elements) self.assertIsNone(param.default_value) @@ -521,7 +536,7 @@ class TestJSONRPCVParser(unittest.TestCase): 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.assertIsInstance(param.param_type, Array) self.assertEqual(5, param.param_type.min_size) self.assertEqual(25, param.param_type.max_size) self.assertIs(param.param_type.element_type, @@ -555,14 +570,14 @@ class TestJSONRPCVParser(unittest.TestCase): 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.assertIsInstance(param.param_type, EnumSubset) self.assertIs(param.param_type.enum, interface.enums["interface2_enum2"]) self.assertDictEqual( {"element2": - interface.enums["interface2_enum2"].elements["element2"], + interface.enums["interface2_enum2"].elements["element2"], "element3": - interface.enums["interface2_enum2"].elements["element3"]}, + interface.enums["interface2_enum2"].elements["element3"]}, param.param_type.allowed_elements) self.assertIsNone(param.default_value) @@ -591,5 +606,6 @@ class TestJSONRPCVParser(unittest.TestCase): """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 index 1464658ff4..b039473c24 100755 --- a/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV1.py +++ b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV1.py @@ -1,13 +1,25 @@ """SDLRPCV1 XML parser unit test.""" import os +import sys import unittest - -import generator.Model -import generator.parsers.SDLRPCV1 +from pathlib import Path + +sys.path.append(Path(__file__).absolute().parents[3].as_posix()) +sys.path.append(Path(__file__).absolute().parents[4].joinpath('rpc_spec/InterfaceParser').as_posix()) +try: + import generator.parsers.SDLRPCV1 + from model.array import Array + from model.boolean import Boolean + from model.enum_subset import EnumSubset + from model.float import Float + from model.integer import Integer + from model.string import String +except ModuleNotFoundError as error: + print('{}.\nProbably you did not initialize submodule'.format(error)) + sys.exit(1) class TestSDLRPCV1Parser(unittest.TestCase): - """Test for SDLRPCV1 xml parser.""" class _Issue: @@ -21,7 +33,7 @@ class TestSDLRPCV1Parser(unittest.TestCase): def setUp(self): """Test initialization.""" self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \ - "/valid_SDLRPCV1.xml" + "/valid_SDLRPCV1.xml" self.parser = generator.parsers.SDLRPCV1.Parser() def test_valid_xml(self): @@ -150,7 +162,7 @@ class TestSDLRPCV1Parser(unittest.TestCase): name="member1", description=["Param1 description"]) self.assertTrue(member.is_mandatory) - self.assertIsInstance(member.param_type, generator.Model.Integer) + self.assertIsInstance(member.param_type, Integer) self.assertIsNone(member.param_type.min_value) self.assertIsNone(member.param_type.max_value) @@ -159,13 +171,13 @@ class TestSDLRPCV1Parser(unittest.TestCase): 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.assertIsInstance(member.param_type, 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.assertIsInstance(member.param_type, Float) self.assertIsNone(member.param_type.min_value) self.assertAlmostEqual(20.5, member.param_type.max_value) @@ -173,11 +185,11 @@ class TestSDLRPCV1Parser(unittest.TestCase): 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.assertIsInstance(member.param_type, 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) + Integer) self.assertEqual(11, member.param_type.element_type.min_value) self.assertEqual(100, member.param_type.element_type.max_value) @@ -196,18 +208,18 @@ class TestSDLRPCV1Parser(unittest.TestCase): 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.assertIsInstance(member.param_type, 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.assertIsInstance(member.param_type, 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) + String) self.assertEqual(100, member.param_type.element_type.max_length) self.assertIn("m3", struct.members) @@ -220,7 +232,7 @@ class TestSDLRPCV1Parser(unittest.TestCase): 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.assertIsInstance(member.param_type, Array) self.assertIsNone(member.param_type.min_size) self.assertEqual(10, member.param_type.max_size) self.assertIs(member.param_type.element_type, @@ -258,9 +270,10 @@ class TestSDLRPCV1Parser(unittest.TestCase): name="param1", issues=[TestSDLRPCV1Parser._Issue(creator="", value="")]) self.assertEqual(False, param.is_mandatory) - self.assertIsInstance(param.param_type, generator.Model.String) + self.assertIsInstance(param.param_type, String) self.assertIsNone(param.param_type.max_length) - self.assertEqual("String default value", param.default_value) + self.assertIsNone(param.default_value) + self.assertEqual("String default value", param.param_type.default_value) self.assertIn("param2", function.params) param = function.params["param2"] @@ -271,7 +284,7 @@ class TestSDLRPCV1Parser(unittest.TestCase): todos=["Param2 todo"], platform="param2 platform") self.assertTrue(param.is_mandatory) - self.assertIsInstance(param.param_type, generator.Model.Integer) + self.assertIsInstance(param.param_type, Integer) self.assertIsNone(param.param_type.min_value) self.assertIsNone(param.param_type.max_value) self.assertIsNone(param.default_value) @@ -317,15 +330,17 @@ class TestSDLRPCV1Parser(unittest.TestCase): 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.assertIsNone(param.default_value) + self.assertIsNone(param.param_type.default_value) + self.assertIs(param.param_type.elements["element2"], 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) + self.assertIsInstance(param.param_type, Boolean) + self.assertIsNone(param.default_value) + self.assertFalse(param.param_type.default_value) # Function notification "Function2" @@ -351,7 +366,7 @@ class TestSDLRPCV1Parser(unittest.TestCase): 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.assertIsInstance(param.param_type, EnumSubset) self.assertIs(param.param_type.enum, interface.enums["enum1"]) self.assertDictEqual( {"element2": interface.enums["enum1"].elements["element2"], @@ -363,11 +378,11 @@ class TestSDLRPCV1Parser(unittest.TestCase): 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.assertIsInstance(param.param_type, 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) + EnumSubset) self.assertIs(param.param_type.element_type.enum, interface.enums["enum1"]) self.assertDictEqual( @@ -400,5 +415,6 @@ class TestSDLRPCV1Parser(unittest.TestCase): """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 deleted file mode 100755 index c37962cfe6..0000000000 --- a/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV2.py +++ /dev/null @@ -1,417 +0,0 @@ -"""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 index a754e5714e..a964ce6e92 100644 --- a/tools/InterfaceGenerator/test/generator/parsers/valid_JSONRPC.xml +++ b/tools/InterfaceGenerator/test/generator/parsers/valid_JSONRPC.xml @@ -2,7 +2,7 @@ <interfaces attr1="v1" attr2="v2"> <interface name="interface1" attribute1="value1" attribute2="value2"> <struct name="struct1"> - <param name="member1" type="Integer"> + <param name="member1" type="Integer" mandatory="true"> <description>Param1 description</description> </param> <issue creator="creator1">Issue1</issue> @@ -10,7 +10,7 @@ <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"/> + <param name="member4" type="Integer" minvalue="11" maxvalue="100" array="true" mandatory="true"/> </struct> <issue creator="c">Issue1</issue> <function name="Function1" messagetype="request"> @@ -18,7 +18,7 @@ <param name="param1" type="String" mandatory="false" defvalue="String default value"> <issue creator=""/> </param> - <param name="param2" type="Integer" platform="param2 platform"> + <param name="param2" type="Integer" platform="param2 platform" mandatory="true"> <description>Param2 description</description> <todo>Param2 todo</todo> <description/> @@ -36,29 +36,29 @@ <designdescription>dd</designdescription> <issue creator="c">Issue2</issue> <function name="Function1" messagetype="response" platform=""> - <param name="p1" type="enum1"/> + <param name="p1" type="enum1" mandatory="true"/> <issue creator="c1"/> - <issue creator="c2"></issue> - <param name="p2" type="enum1" defvalue="element2"/> - <param name="p3" type="Boolean" defvalue="false"> + <issue creator="c2"/> + <param name="p2" type="enum1" defvalue="element2" mandatory="true"/> + <param name="p3" type="Boolean" defvalue="false" mandatory="true"> <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"/> + <param name="m1" type="String" mandatory="true"/> + <param name="m2" type="String" maxlength="100" array="true" minsize="1" maxsize="50" mandatory="true"/> + <param name="m3" type="enum1" mandatory="true"/> + <param name="m4" type="struct1" array="true" maxsize="10" mandatory="true"/> </struct> <function name="Function2" messagetype="notification" platform="function2 platform"> <description>Function2 description</description> - <param name="n1" type="enum1"> + <param name="n1" type="enum1" mandatory="true"> <element name="element2"/> <element name="element3"/> <todo>n1 todo</todo> </param> - <param name="n2" type="enum1" array="true" minsize="1" maxsize="100"> + <param name="n2" type="enum1" array="true" minsize="1" maxsize="100" mandatory="true"> <element name="element3"/> <todo>n2 todo</todo> <element name="element1"/> @@ -79,22 +79,22 @@ <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"/> + <param name="m_1" type="enum1" minsize="1" maxsize="10" array="true" mandatory="true"/> + <param name="m_2" type="enum2" mandatory="true"/> + <param name="m_3" type="String" maxlength="20" mandatory="true"/> </struct> <function name="Function1" messagetype="request"> <param name="param1" type="enum1" mandatory="false"/> - <param name="param2" type="struct1" array="true" minsize="5" maxsize="25"/> + <param name="param2" type="struct1" array="true" minsize="5" maxsize="25" mandatory="true"/> </function> <todo>i2 todo</todo> <function name="Function1" messagetype="notification" platform="platform"> <issue creator="c">Issue text</issue> - <param name="param" type="enum2"> + <param name="param" type="enum2" mandatory="true"> <element name="element2"/> <element name="element3"/> </param> - <param name="i1" type="interface1.struct2"/> + <param name="i1" type="interface1.struct2" mandatory="true"/> </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 index 37ebf39d3a..05a83c5834 100644 --- a/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV1.xml +++ b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV1.xml @@ -1,7 +1,7 @@ <?xml version="1.0"?> <interface name="test_interface" attribute1="value1" attribute2="value2"> <struct name="struct1"> - <param name="member1" type="Integer"> + <param name="member1" type="Integer" mandatory="true"> <description>Param1 description</description> </param> <issue creator="creator1">Issue1</issue> @@ -9,14 +9,14 @@ <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"/> + <param name="member4" type="Integer" minvalue="11" maxvalue="100" array="true" mandatory="true"/> </struct> - <function name="Function1" messagetype="request"> + <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"> + <param name="param2" type="Integer" platform="param2 platform" mandatory="true"> <description>Param2 description</description> <todo>Param2 todo</todo> <description/> @@ -31,30 +31,30 @@ <designdescription>Element design description</designdescription> </element> </enum> - <function name="Function1" messagetype="response" platform=""> - <param name="p1" type="enum1"/> + <function name="Function1" functionID="Function1_id" messagetype="response" platform=""> + <param name="p1" type="enum1" mandatory="true"/> <issue creator="c1"/> - <issue creator="c2"></issue> - <param name="p2" type="enum1" defvalue="element2"/> - <param name="p3" type="Boolean" defvalue="false"> + <issue creator="c2"/> + <param name="p2" type="enum1" defvalue="element2" mandatory="true"/> + <param name="p3" type="Boolean" defvalue="false" mandatory="true"> <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"/> + <param name="m1" type="String" mandatory="true"/> + <param name="m2" type="String" maxlength="100" array="true" minsize="1" maxsize="50" mandatory="true"/> + <param name="m3" type="enum1" mandatory="true"/> + <param name="m4" type="struct1" array="true" maxsize="10" mandatory="true"/> </struct> - <function name="Function2" messagetype="notification" platform="function2 platform"> + <function name="Function2" functionID="Function2_id" messagetype="notification" platform="function2 platform"> <description>Function2 description</description> - <param name="n1" type="enum1"> + <param name="n1" type="enum1" mandatory="true"> <element name="element2"/> <element name="element3"/> <todo>n1 todo</todo> </param> - <param name="n2" type="enum1" array="true" minsize="1" maxsize="100"> + <param name="n2" type="enum1" array="true" minsize="1" maxsize="100" mandatory="true"> <element name="element3"/> <todo>n2 todo</todo> <element name="element1"/> diff --git a/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml deleted file mode 100644 index cdc5f1ae85..0000000000 --- a/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml +++ /dev/null @@ -1,85 +0,0 @@ -<?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> diff --git a/tools/InterfaceGenerator/test/generator/test_Model.py b/tools/InterfaceGenerator/test/generator/test_Model.py deleted file mode 100755 index 55f6a54705..0000000000 --- a/tools/InterfaceGenerator/test/generator/test_Model.py +++ /dev/null @@ -1,27 +0,0 @@ -"""Interface model unit test""" -import unittest - -import generator.Model - - -class TestInterfaceModel(unittest.TestCase): - - """Test for interface model.""" - - def test_enum_element_primary_name(self): - """Test property primary_name of EnumElement.""" - element = generator.Model.EnumElement(name="name1") - self.assertEqual("name1", element.primary_name) - - element = generator.Model.EnumElement(name="name2", - internal_name="internal_name1") - self.assertEqual("internal_name1", element.primary_name) - - element.internal_name = None - self.assertEqual("name2", element.primary_name) - - element.internal_name = "internal_name2" - self.assertEqual("internal_name2", element.primary_name) - -if __name__ == "__main__": - unittest.main() diff --git a/tools/InterfaceGenerator/test/test_CodeFormatAndQuality.py b/tools/InterfaceGenerator/test/test_CodeFormatAndQuality.py deleted file mode 100755 index 3ce56e0fae..0000000000 --- a/tools/InterfaceGenerator/test/test_CodeFormatAndQuality.py +++ /dev/null @@ -1,59 +0,0 @@ -import subprocess -import unittest -import flake8.main -import pep257 -import os.path -import fnmatch -import os -import pylint.lint -import sys - -class TestCodeFormatAndQuality(unittest.TestCase): - - def setUp(self): - self.projectRootDir = os.path.dirname(os.path.dirname(os.path.realpath(__file__))) - projectTestsDir = os.path.join(self.projectRootDir, "test") - self.filesToAnalyze = [] - for root, dirnames, filenames in os.walk(self.projectRootDir): - if root.startswith(projectTestsDir): - continue # Currently we skipping test files - for filename in fnmatch.filter(filenames, '*.py'): - fullFileName = os.path.join(root, filename) - relativeFileName = os.path.relpath(fullFileName, self.projectRootDir) - self.filesToAnalyze.append(relativeFileName) - - def test_pep8_conformance(self): - maxCyclomaticComplexity = 10 - errors = 0 - for file in self.filesToAnalyze: - errors = errors + flake8.main.check_file(file, None, maxCyclomaticComplexity) - - self.assertEqual(errors, 0, "Found code style errors or warnings.") - - def test_pep257_conformance(self): - errors = [] - - for filePath in self.filesToAnalyze: - print("Processing file: {0}".format(filePath)) - result = pep257.check_files([filePath]) - if result: - errors.extend(result) - for error in result: - print(error) - print - self.assertEqual(len(errors), 0, "Found Docstring Conventions violations.") - - def test_pylint_conformance(self): - print - self.assertEqual(0, - subprocess.call( - ["pylint", - '--rcfile=pylint.cfg', - 'generator', - 'Generator.py'] - ), "Found Pylint violations") - return - -if __name__ == '__main__': - unittest.main() - |