def test_preprocess_message_type(self): """Test preprocessing of the message_type enum. Verifies JSONPRC implementation of the _preprocess_message_type function. """ 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) result_enum = generator._preprocess_message_type(message_type) self.assertIn("error_response", result_enum.elements) self.assertEqual("error_response", 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( name=u"notification") message_type = Model.Enum(name=u"messageType", elements=message_type_elements) result_enum = generator._preprocess_message_type(message_type) self.assertNotIn("error_response", result_enum.elements)
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")
u""" CSmartSchema error_response_schema(CObjectSchemaItem::create(""" u"""root_members_map));\n""" u"""\n""" u""" functions_schemes_.insert(std::make_pair(""" u"""NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<""" u"""FunctionID::eType, messageType::eType>(""" u"""FunctionID::request, messageType::error_response)""" u""", error_response_schema));\n""" u"""\n""") 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") ] 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. """ def test_gen_schema_params_fill(self): """Test feature that allows to create format specific PARAMS.
def _parse_param_base_item(self, element, prefix): """Parse base param items. Returns params, other subelements and attributes. """ params, subelements, attrib = self._parse_base_item(element, "") is_mandatory = self._extract_attrib(attrib, "mandatory") if is_mandatory is None: raise ParseError("'mandatory' is not specified for parameter '" + params["name"] + "'") params["is_mandatory"] = self._get_bool_from_string(is_mandatory) scope = self._extract_attrib(attrib, "scope") if scope is not None: params["scope"] = scope default_value = None param_type = None type_name = self._extract_attrib(attrib, "type") if type_name is None: raise ParseError("Type is not specified for parameter '" + params["name"] + "'") if type_name == "Boolean": default_value = self._extract_attrib(attrib, "defvalue") if default_value != None: default_value = self._get_bool_from_string(default_value) param_type = Model.Boolean(default_value=default_value) elif type_name == "Integer" or \ type_name == "Float" or \ type_name == "Double" : min_value = self._extract_optional_number_attrib( attrib, "minvalue", int if type_name == "Integer" else float) max_value = self._extract_optional_number_attrib( attrib, "maxvalue", int if type_name == "Integer" else float) default_value = self._extract_optional_number_attrib( attrib, "defvalue", int if type_name == "Integer" else float) param_type = \ (Model.Integer if type_name == "Integer" else Model.Double)( min_value=min_value, max_value=max_value, default_value=default_value) elif type_name == "String": min_length = self._extract_optional_number_attrib( attrib, "minlength") # if minlength is not defined default value is 1 if min_length is None: min_length = 1 max_length = self._extract_optional_number_attrib( attrib, "maxlength") default_value = self._extract_attrib(attrib, "defvalue") param_type = Model.String(min_length=min_length, max_length=max_length, default_value=default_value) else: if 1 == type_name.count("."): custom_type_name = type_name.replace(".", "_") else: custom_type_name = prefix + type_name if custom_type_name in self._types: param_type = self._types[custom_type_name] default_value = self._extract_attrib(attrib, "defvalue") if default_value != None: if default_value not in param_type.elements: raise ParseError("Default value '" + default_value + "' for parameter '" + params["name"] + "' is not a member of " + type(param_type).__name__ + "'" + params["name"] + "'") default_value = param_type.elements[default_value] else: raise ParseError("Unknown type '" + type_name + "'") if self._extract_optional_bool_attrib(attrib, "array", False): min_size = self._extract_optional_number_attrib(attrib, "minsize") max_size = self._extract_optional_number_attrib(attrib, "maxsize") param_type = Model.Array(element_type=param_type, min_size=min_size, max_size=max_size) base_type = \ param_type.element_type if isinstance(param_type, Model.Array) \ else param_type other_subelements = [] for subelement in subelements: if subelement.tag == "element": if type(base_type) is not Model.Enum and \ type(base_type) is not Model.EnumSubset: raise ParseError("Elements specified for parameter '" + params["name"] + "' of type " + type(base_type).__name__) if type(base_type) is Model.Enum: base_type = Model.EnumSubset( name=params["name"], enum=base_type, description=params["description"], design_description=params["design_description"], issues=params["issues"], todos=params["todos"], allowed_elements={}) if "name" not in subelement.attrib: raise ParseError( "Element name is not specified for parameter '" + params["name"] + "'") element_name = subelement.attrib["name"] if len(subelement.attrib) != 1: raise ParseError("Unexpected attributes for element '" + element_name + "' of parameter '" + params["name"]) if len(subelement.getchildren()) != 0: raise ParseError("Unexpected subelements for element '" + element_name + "' of parameter '" + params["name"]) if element_name in base_type.allowed_elements: raise ParseError("Element '" + element_name + "' is specified more than once for" + " parameter '" + params["name"] + "'") if element_name not in base_type.enum.elements: raise ParseError("Element '" + element_name + "' is not a member of enum '" + base_type.enum.name + "'") base_type.allowed_elements[element_name] = \ base_type.enum.elements[element_name] else: other_subelements.append(subelement) if isinstance(param_type, Model.Array): param_type.element_type = base_type else: param_type = base_type params["param_type"] = param_type if default_value is not None: params["default_value"] = default_value return params, other_subelements, attrib
*/ val_2 = 100, /** * @brief val_3. */ val_3 }; } // E2 """ 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")] 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. """ def test_gen_comment(self):
def generate(self, interface, filename, namespace, destination_dir): """ Generate SmartFactory source files. Generates source code files at destination directory in accordance with given model in specified namespace. Keyword arguments: interface -- model of the interface to generate source code for. filename -- name of initial XML file. namespace -- name of destination namespace. destination_dir -- directory to create source files. """ if interface is None: raise GenerateError("Given interface is None.") params_set = set() for func in interface.functions.values(): for param in func.params: params_set.add(param) parameter_enum = Model.Enum('Parameter') for item in params_set: parameter_enum.elements[item.upper()] = Model.EnumElement(item) required_enums_for_policy = [ "HMILevel", "FunctionID", "HybridAppPreference", "AppHMIType", "RequestType", "ModuleType", "Common_AppPriority", "Parameter" ] self.required_empty_value = ["RequestType", "ModuleType", "Parameter"] self.enum_items_naming_conversion_ = { "HMILevel": lambda item_name: "HL_" + item_name.replace("HMI_", ""), "AppHMIType": lambda item_name: "AHT_" + item_name, "FunctionID": lambda item_name: item_name, "HybridAppPreference": lambda item_name: item_name, "RequestType": lambda item_name: "RT_" + item_name, "ModuleType": lambda item_name: "MT_" + item_name, "Common_AppPriority": lambda item_name: "P_" + item_name if not item_name == "VOICE_COMMUNICATION" else "P_VOICECOM", "Parameter": lambda item_name: "P_" + to_snake_case(item_name).upper() } self.enum_items_string_naming_conversion_ = { "HMILevel": lambda item_name: item_name, "AppHMIType": lambda item_name: item_name, "FunctionID": lambda item_name: item_name[:item_name.rfind("ID")], "HybridAppPreference": lambda item_name: item_name, "RequestType": lambda item_name: item_name, "ModuleType": lambda item_name: item_name, "Common_AppPriority": lambda item_name: item_name if not item_name == "VOICE_COMMUNICATION" else "VOICECOM", "Parameter": lambda item_name: item_name } self.enum_naming_conversion_ = { "HMILevel": "HmiLevel", "AppHMIType": "AppHMIType", "FunctionID": "FunctionID", "HybridAppPreference": "HybridAppPreference", "RequestType": "RequestType", "ModuleType": "ModuleType", "Common_AppPriority": "Priority", "Parameter": "Parameter" } get_first_enum_value_name = lambda enum: enum.elements.values()[0].name enum_required_for_policy = lambda enum: enum.name in required_enums_for_policy and "." not in get_first_enum_value_name( enum) # In case if "." is in FunctionID name this is HMI_API function ID and should not be included in Policy enums required_enum_values = [ val for val in interface.enums.values() if enum_required_for_policy(val) ] if filename == "MOBILE_API": self._write_cc_with_enum_schema_factory(filename, namespace, destination_dir, interface.enums.values()) # Params should be generated as enum for MOBILE_API to validate RPCSpec parameters required_enum_values.append(parameter_enum) self._write_header_with_enums(filename, namespace, destination_dir, required_enum_values) self._write_cc_with_enums(filename, namespace, destination_dir, required_enum_values)
# dset = simulatedData(opt["dataset_path"], time_points = opt["time_points"]) dset = SCData(opt["dataset_path"]) # denormalizer = dset.denormalize loader = DataLoader(dset, batch_size=opt["batch_size"], shuffle=True, num_workers=0) loader_iterator = iter(loader) data_len = len(loader) gen_o = opt['models']['generator'] dis_o = opt['models']['discriminator'] gen = Gen(opt["z_slow_dim"], opt["z_fast_dim"], opt["genes_num"], opt["time_points"], opt["batch_size"]) dis = Dis(opt["genes_num"], opt["time_points"], opt["batch_size"]) if opt['use_cuda']: start = time.time() gen.cuda() end = time.time() print("Generator moved to GPU in {} seconds".format(end - start)) start = time.time() dis.cuda() end = time.time() print("Discriminator moved to GPU in {} seconds".format(end - start)) start_epoch = 0 #default starting epoch is 0