def _parse_function_param(self, element, prefix):
"""Parse element as function parameter.
Returns an instance of generator.Model.FunctionParam
"""
params, subelements, attrib = \
self._parse_param_base_item(element, prefix)
default_value = None
default_value_string = self._extract_attrib(attrib, "defvalue")
if default_value_string is not None:
param_type = params["param_type"]
if type(param_type) is Model.Boolean:
default_value = \
self._get_bool_from_string(default_value_string)
elif type(param_type) is Model.Integer:
try:
default_value = int(default_value_string)
except:
raise ParseError("Invalid value for integer: '" +
default_value_string + "'")
elif type(param_type) is Model.Double:
try:
default_value = float(default_value_string)
except:
raise ParseError("Invalid value for float: '" +
default_value_string + "'")
elif type(param_type) is Model.String:
default_value = default_value_string
elif type(param_type) is Model.Enum or \
type(param_type) is Model.EnumSubset:
if type(param_type) is Model.EnumSubset:
allowed_elements = param_type.allowed_elements
else:
allowed_elements = param_type.elements
if default_value_string not in allowed_elements:
raise ParseError("Default value '" + default_value_string +
"' for parameter '" + params["name"] +
"' is not a member of " +
type(param_type).__name__ + "'" +
params["name"] + "'")
default_value = allowed_elements[default_value_string]
else:
raise ParseError("Default value specified for " +
type(param_type).__name__)
params["default_value"] = default_value
if len(attrib) != 0:
raise ParseError("Unexpected attributes in parameter '" +
params["name"] + "'")
if len(subelements) != 0:
raise ParseError("Unexpected subelements in parameter '" +
params["name"] + "'")
# Magic usage is correct
# pylint: disable=W0142
return Model.FunctionParam(**params)
def test_full_generation(self):
"""Test full generation using JSONRPC SmartSchema generator.
Creates output files which is captured by the mock and compare them
with sample files with correct code. This test requires valid
test_expected_jsonrpc.h and test_expected_jsonrpc.cc in the same
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()
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(
name=u"response")
message_type_elements[u"notification"] = Model.EnumElement(
name=u"notification")
message_type = Model.Enum(name=u"messageType",
elements=message_type_elements)
elements1 = collections.OrderedDict()
elements1[u"name1"] = Model.EnumElement(
name=u"name1",
design_description=DESIGN_DESCRIPTION,
todos=TODOS,
value=u"1")
elements1[u"name2"] = Model.EnumElement(
name="name2",
description=DESCRIPTION,
issues=ISSUES,
internal_name=u"internal_name2")
enum1 = Model.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")
enum2 = Model.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)
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)
enums = collections.OrderedDict()
enums["Enum1"] = enum1
enums["Enum2"] = enum2
enums["Enum3"] = enum3
enums["Enum4"] = enum4
enums["messageType"] = message_type
params1 = collections.OrderedDict()
params1["1"] = Model.FunctionParam(
name="param1",
design_description=DESIGN_DESCRIPTION,
description=DESCRIPTION,
issues=ISSUES,
todos=TODOS,
param_type=enum4,
default_value=elements4["name1"])
params1["2"] = Model.FunctionParam(
name="param2",
param_type=Model.EnumSubset(
name="sub1",
enum=enum1,
allowed_elements={"e1": elements1["name1"]}),
default_value=elements1["name1"])
functions = collections.OrderedDict()
functions["Function1"] = Model.Function(
name="Function1",
function_id=elements1["name1"],
message_type=message_type_elements["request"],
params=params1)
functions["Function2"] = Model.Function(
name="Function2",
function_id=elements2["xxx"],
message_type=message_type_elements["response"])
functions["Function3"] = Model.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(
name="enumSubset1",
param_type=Model.EnumSubset(
name="sub",
enum=enum1,
allowed_elements={"e1": elements1["name1"]}),
is_mandatory=False)
members1["1"] = Model.Param(name="arrayOfInt",
param_type=Model.Array(
min_size=0,
max_size=20,
element_type=Model.Boolean()),
is_mandatory=False)
members1["2"] = Model.Param(name="arrayOfEnum1",
param_type=Model.Array(min_size=0,
max_size=20,
element_type=enum1),
is_mandatory=False)
members1["3"] = Model.Param(name="arrayOfEnum3",
param_type=Model.Array(min_size=10,
max_size=40,
element_type=enum3),
is_mandatory=True)
members1["4"] = Model.Param(
name="arrayOfEnum4",
param_type=Model.Array(
min_size=10,
max_size=41,
element_type=Model.EnumSubset(
name="sub1",
enum=enum1,
allowed_elements={"e1": elements1["name1"]})))
members1["5"] = Model.Param(
name="arrayOfEnum5",
param_type=Model.Array(
min_size=10,
max_size=42,
element_type=Model.EnumSubset(
name="sub2",
enum=enum1,
allowed_elements={"e1": elements1["name2"]})))
members1["6"] = Model.Param(
name="arrayOfEnum6",
param_type=Model.Array(
min_size=10,
max_size=43,
element_type=Model.EnumSubset(
name="sub3",
enum=enum4,
allowed_elements={"e1": elements4["name2"]})))
structs = collections.OrderedDict()
structs["Struct1"] = Model.Struct(
name="Struct1",
design_description=DESIGN_DESCRIPTION,
issues=ISSUES,
members=members1)
structs["Struct2"] = Model.Struct(name="Struct2", issues=ISSUES)
interface = Model.Interface(enums=enums,
structs=structs,
functions=functions,
params={
"param1": "value1",
"param2": "value2"
})
os.path.exists = MagicMock(return_value=True)
uuid.uuid1 = MagicMock(
return_value=uuid.UUID("12345678123456781234567812345678"))
codecs.open = MagicMock()
generator.generate(interface=interface,
filename="Test.xml",
namespace="XXX::YYY::ZZZ",
destination_dir="/some/test/dir")
os.path.exists.assert_has_calls([call('/some/test/dir')])
open_result = codecs.open
mock_calls = open_result.mock_calls
self.assertEqual(
mock_calls[0],
call('/some/test/dir/Test.h', mode='w', encoding='utf-8'),
"Invalid header file creation")
self.assertEqual(
mock_calls[4],
call('/some/test/dir/Test.cc', mode='w', encoding='utf-8'),
"Invalid source file creation")
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")
