def test_equal(self): f1 = Function('a', ['b', 'c'], "a = b + c", name="add") f2 = Function('a', ['c', 'b'], "a = b + c", name="huhu") self.assertTrue(f1 == f2) f3 = Function('a', ['c', 'b'], "a = b + c ") self.assertFalse(f1 == f3) f4 = Function('d', ['b', 'c'], "d = b + c ") self.assertTrue(f1 != f4) f5 = Function('a', ['b', 'c', 'd'], "a = b + c") self.assertTrue(f1 != f5)
def test_SetDisplayLayout(self): """ generator/transformers/common_producer.py 66% generator/transformers/functions_producer.py 63% """ params = OrderedDict() params['displayLayout'] = Param(name='displayLayout', param_type=String(max_length=500, min_length=1)) item = Function(name='SetDisplayLayout', function_id=EnumElement(name='SetDisplayLayoutID'), message_type=EnumElement(name='request'), params=params, history=[ Function(name='SetDisplayLayout', function_id=EnumElement(name='SetDisplayLayoutID'), message_type=EnumElement(name='request'), params={}, history=None, since='3.0.0', until='6.0.0') ], since='6.0.0', until=None, deprecated='true') expected = OrderedDict() expected['origin'] = 'SetDisplayLayout' expected['name'] = 'SDLSetDisplayLayout' expected['extends_class'] = 'SDLRPCRequest' expected['imports'] = { '.h': { 'enum': ['SDLRPCRequest'], 'struct': []}, '.m': [ 'NSMutableDictionary+Store', 'SDLRPCFunctionNames', 'SDLRPCParameterNames', 'SDLSetDisplayLayout' ] } expected['history'] = '3.0.0' expected['since'] = '6.0.0' expected['deprecated'] = True expected['params'] = ( self.producer.param_named( history=None, constructor_argument='displayLayout', constructor_argument_override=None, constructor_prefix='DisplayLayout', deprecated=False, description=['{"string_min_length": 1, "string_max_length": 500}'], for_name='object', mandatory=True, method_suffix='DisplayLayout', modifier='strong', of_class='NSString.class', origin='displayLayout', since=None, type_native='NSString *', type_sdl='NSString *'),) argument = [ self.producer.argument_named(variable='displayLayout', deprecated=False, constructor_argument='displayLayout', origin='displayLayout')] expected['constructors'] = (self.producer.constructor_named( all=argument, arguments=argument, self=True, init='DisplayLayout:(NSString *)displayLayout'),) actual = self.producer.transform(item) self.assertDictEqual(expected, actual)
def test_process_function_name(self): """ generator/transformers/common_producer.py 29% generator/transformers/functions_producer.py 61% """ functions = { 'RegisterAppInterface': Function(name='RegisterAppInterface', function_id=EnumElement(name='RegisterAppInterfaceID'), since='3.0.0', message_type=EnumElement(name='request'), description=['RegisterAppInterface description'], params={ 'syncMsgVersion': Param(name='syncMsgVersion', param_type=Float(), since='3.5.0', description=['syncMsgVersion description'])}), 'OnHMIStatus': Function(name='OnHMIStatus', function_id=EnumElement(name='OnHMIStatusID'), since='4.0.0', message_type=EnumElement(name='notification'), description=['OnHMIStatus description'], params={ 'acEnable': Param(name='acEnable', param_type=Integer(), since='4.5.0', description=['acEnable description'])})} structs = { 'SoftButton': Struct(name='SoftButton', members={ 'image': Param(name='image', param_type=String(), since='1.0.0', description=['image description']), 'dayColorScheme': Param(name='dayColorScheme', param_type=Struct(name='TemplateColorScheme', description=[ '\nA color scheme for all display layout templates.\n']))}), 'PresetBankCapabilities': Struct(name='PresetBankCapabilities', members={ 'availableHdChannelsAvailable': Param(name='availableHdChannelsAvailable', param_type=Boolean(), since='2.0.0', description=['availableHDChannelsAvailable description'])})} expected = [ self.producer.common_names( description=['OnHMIStatus description'], name='OnHMIStatus', origin='OnHMIStatus', since='4.0.0'), self.producer.common_names( description=['RegisterAppInterface description'], name='RegisterAppInterface', origin='RegisterAppInterface', since='3.0.0')] actual = self.producer.get_function_names(functions) self.assertListEqual(expected, actual['params']) expected = [ self.producer.common_names(description=['acEnable description'], name='AcEnable', origin='acEnable', since='4.5.0'), self.producer.common_names(description=['availableHDChannelsAvailable description'], since='2.0.0', name='AvailableHdChannelsAvailable', origin='availableHdChannelsAvailable'), self.producer.common_names(description=[], name='DayColorScheme', origin='dayColorScheme', since=None), self.producer.common_names(description=['image description'], name='Image', origin='image', since='1.0.0'), self.producer.common_names(description=['syncMsgVersion description'], name='SdlMsgVersion', origin='syncMsgVersion', since='3.5.0')] actual = self.producer.get_simple_params(functions, structs) self.assertCountEqual(expected, actual['params'])
def test_DeleteCommand(self): item = Function(name='DeleteCommand', function_id=None, message_type=EnumElement(name='request'), params={ 'cmdID': Param(name='cmdID', param_type=Integer(max_value=2000000000, min_value=0)) }) expected = self.expected_template.copy() expected['kind'] = 'request' expected['function_id'] = 'DELETE_COMMAND' expected['class_name'] = 'DeleteCommand' expected['extends_class'] = 'RPCRequest' expected['imports'] = [ 'android.support.annotation.NonNull', '', 'com.smartdevicelink.protocol.enums.FunctionID', 'com.smartdevicelink.proxy.RPCRequest', '', 'java.util.Hashtable' ] expected['params'] = (self.producer.params(deprecated=None, key='KEY_CMD_ID', last='cmdID', mandatory=True, origin='cmdID', return_type='Integer', since=None, title='CmdID', description=None, SuppressWarnings=None, param_doc=None, name=None), ) actual = self.producer.transform(item) self.comparison(expected, actual)
def test_Alert(self): item = Function(name='Alert', function_id=None, message_type=EnumElement(name='request'), params={ 'alertText2': Param(name='alertText2', param_type=String(max_length=500)) }) expected = self.expected_template.copy() expected['kind'] = 'request' expected['function_id'] = 'ALERT' expected['class_name'] = 'Alert' expected['extends_class'] = 'RPCRequest' expected['imports'] = [ 'android.support.annotation.NonNull', '', 'com.smartdevicelink.protocol.enums.FunctionID', 'com.smartdevicelink.proxy.RPCRequest', '', 'java.util.Hashtable' ] expected['params'] = (self.producer.params(deprecated=None, key='KEY_ALERT_TEXT_2', last='alertText2', mandatory=True, origin='alertText2', param_doc=None, return_type='String', since=None, title='AlertText2', description=None, SuppressWarnings=None, name=None), ) actual = self.producer.transform(item) self.comparison(expected, actual)
def test_init(self): f = Function('a', ['b', 'c'], "a = b + c", name="add") self.assertEqual(set([str(v) for v in f.vin]), set(['b', 'c'])) self.assertEqual(str(f.vout), 'a') self.assertEqual(f.name, "add") with self.assertRaises(Exception): f = Function('a', ['a'], "a = 2 * a", name="double") # test wrap flag self.assertTrue("def" in f.code) f = Function('a', ['b', 'c'], "a = b + c", name="add", wrap=False) self.assertFalse("def" in f.code) # invalid name (name must follow rules for python identifiers) with self.assertRaises(Exception): f = Function('a', ['b', 'c'], "a = b + c", name="1add") with self.assertRaises(Exception): f = Function('a', ['b', 'c'], "a = b + c", name="add b and c")
def test_ReleaseInteriorVehicleDataModule(self): item = Function(name='ReleaseInteriorVehicleDataModule', function_id=None, message_type=EnumElement(name='request'), params={ 'moduleType': Param(name='moduleType', param_type=Enum(name='ModuleType')) }) expected = self.expected_template.copy() expected['kind'] = 'request' expected['function_id'] = 'RELEASE_INTERIOR_VEHICLE_DATA_MODULE' expected['class_name'] = 'ReleaseInteriorVehicleDataModule' expected['extends_class'] = 'RPCRequest' expected['imports'] = [ 'android.support.annotation.NonNull', '', 'com.smartdevicelink.protocol.enums.FunctionID', 'com.smartdevicelink.proxy.RPCRequest', '', 'java.util.Hashtable' ] expected['params'] = (self.producer.params(deprecated=None, key='KEY_MODULE_TYPE', last='moduleType', mandatory=True, origin='moduleType', return_type='ModuleType', since=None, title='ModuleType', description=None, SuppressWarnings=None, param_doc=None, name=None), ) actual = self.producer.transform(item) self.comparison(expected, actual)
def __get_function_of(self, expr_result): """Creates a function object given the parsers result.""" vout = expr_result['output'] relation = expr_result['relation'] vin = expr_result['inputs'] code = self.__get_code_of(relation) return Function(vout, vin, code, name=relation, wrap=False)
def transform(self, item: Function, render: dict = None) -> dict: """ Main entry point for transforming each Enum/Function/Struct into output dictionary, which going to be applied to Jinja2 template :param item: instance of Enum/Function/Struct :param render: dictionary with pre filled entries, which going to be filled/changed by reference :return: dictionary which going to be applied to Jinja2 template """ list(map(item.params.__delitem__, filter(item.params.__contains__, ['success', 'resultCode', 'info']))) item.name = self._replace_sync(item.name) name = 'SDL' + item.name imports = {'.h': {'enum': set(), 'struct': set()}, '.m': set()} extends_class = None if item.message_type.name == 'response': extends_class = self.response_class name = name + item.message_type.name.capitalize() elif item.message_type.name == 'request': extends_class = self.request_class elif item.message_type.name == 'notification': extends_class = self.notification_class if extends_class: imports['.h']['enum'].add(extends_class) if not render: render = OrderedDict() render['origin'] = item.name render['name'] = name render['extends_class'] = extends_class render['imports'] = imports render['history'] = item.history super(FunctionsProducer, self).transform(item, render) return render
def test_PutFileRequest(self): params = OrderedDict() params['fileType'] = Param( name='fileType', param_type=Enum( name='FileType', description=['Enumeration listing'], elements={'AUDIO_MP3': EnumElement(name='AUDIO_MP3')}), description=['Selected file type.']) params['syncFileName'] = Param(name='syncFileName', param_type=String(max_length=255, min_length=1)) item = Function(name='PutFile', function_id=None, description=['\n Used to'], message_type=EnumElement(name='request'), params=params) expected = self.expected_template.copy() expected['kind'] = 'request' expected['function_id'] = 'PUT_FILE' expected['class_name'] = 'PutFile' expected['extends_class'] = 'RPCRequest' expected['history'] = None expected['imports'] = [ 'androidx.annotation.NonNull', '', 'com.smartdevicelink.protocol.enums.FunctionID', 'com.smartdevicelink.proxy.RPCRequest', 'com.smartdevicelink.proxy.rpc.enums.FileType', '', 'java.util.Hashtable' ] expected['description'] = ['Used to'] expected['params'] = (self.producer.params( deprecated=None, description=['Selected file type.'], key='KEY_FILE_TYPE', last='fileType', mandatory=True, origin='fileType', SuppressWarnings=None, return_type='FileType', since=None, title='FileType', param_doc=None, name=None), self.producer.params(deprecated=None, key='KEY_SDL_FILE_NAME', last='sdlFileName', mandatory=True, origin='syncFileName', return_type='String', description=None, since=None, title='SdlFileName', SuppressWarnings=None, param_doc=None, name=None)) actual = self.producer.transform(item) self.comparison(expected, actual)
def test_preserve_vars(self): # note: local variables can only preserved when # - the function is *not* wrapped # The variables are created as local variables of the function # (global c does not work here -- there is no global variable c). f = Function('a', ['b'], "try:\n" \ " c = c + 1\n" \ "except:\n" " c = 0\n" \ "a.v = b.v + c\n", name="inc", wrap=False) b = Itom('b', 1) o = f.execute([b]) self.assertEqual(o['a'].v, 1) o = f.execute([b]) self.assertEqual(o['a'].v, 2)
def test_CreateInteractionChoiceSet(self): """ generator/transformers/common_producer.py 67% generator/transformers/functions_producer.py 63% """ params = OrderedDict() params['choiceSet'] = Param( name='choiceSet', param_type=Array(element_type=Struct(name='Choice'))) item = Function( name='CreateInteractionChoiceSet', function_id=EnumElement(name='CreateInteractionChoiceSetID'), message_type=EnumElement(name='request'), params=params) expected = OrderedDict() expected['origin'] = 'CreateInteractionChoiceSet' expected['name'] = 'SDLCreateInteractionChoiceSet' expected['extends_class'] = 'SDLRPCRequest' expected['imports'] = { '.m': {'SDLChoice'}, '.h': { 'struct': {'SDLChoice'}, 'enum': {'SDLRPCRequest'} } } expected['params'] = (self.producer.param_named( constructor_argument='choiceSet', constructor_argument_override=None, constructor_prefix='ChoiceSet', deprecated=False, description=[], for_name='objects', mandatory=True, method_suffix='ChoiceSet', modifier='strong', of_class='SDLChoice.class', origin='choiceSet', since=None, type_native='NSArray<SDLChoice *> *', type_sdl='NSArray<SDLChoice *> *'), ) argument = [ self.producer.argument_named(variable='choiceSet', deprecated=False, constructor_argument='choiceSet', origin='choiceSet') ] expected['constructors'] = (self.producer.constructor_named( all=argument, arguments=argument, deprecated=False, self=True, init='ChoiceSet:(NSArray<SDLChoice *> *)choiceSet'), ) actual = self.producer.transform(item) self.assertDictEqual(expected, actual)
def test_implementation_multiline(self): self.__pli.reset() self.__pli.load("test/test_py-implementation-multiline.pl") result = self.__pli.evaluate("query(implementation(r1, X)).") relation, code = self.__pli.parse_implementation(list(result)[0]) self.assertEqual(relation, "r1") # create function to execute f = Function('a', 'b', code, name='r1') itoms = f.execute(Itoms([Itom('b', 1, timestamp=0, variable='b')])) self.assertEqual(itoms['a'].v, 2) self.assertEqual(itoms['a'].t, 0) # execute through substitution S = self.__get_substitutions("query(substitution(a,S)).") itoms = Itoms([Itom('b1', 1, timestamp=0, variable='b')]) outputs = self.__execute_substitutions(S, itoms) s = list(S)[0] self.assertEqual(outputs[s]['a'].v, 2) self.assertEqual(outputs[s]['a'].t, 0)
def test_gen_pre_function_schemas(self): """Test code that goes before schema initialization. Verifies JSONPRC implementation of the _gen_pre_function_schemas function. """ self.maxDiff = None generator = SmartFactoryJSONRPC.CodeGenerator() self.assertEqual(u"", generator._gen_pre_function_schemas([]), "Invalid code for empty functions list") message_type_elements = collections.OrderedDict() message_type_elements[u"request"] = EnumElement(name=u"request") message_type_elements[u"response"] = EnumElement(name=u"response") message_type_elements[u"notification"] = EnumElement( name=u"notification") message_type = Enum(name=u"messageType", elements=message_type_elements) function1 = Function("func1", function_id=message_type.elements[u"request"], message_type=message_type.elements[u"request"]) self.assertEqual(u"", generator._gen_pre_function_schemas([function1]), "Invalid code for empty functions list") function2 = Function("func2", function_id=message_type.elements[u"request"], message_type=message_type.elements[u"response"]) 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_OnHMIStatus(self): """ generator/transformers/common_producer.py 66% generator/transformers/functions_producer.py 65% """ item = Function(name='OnHMIStatus', function_id=EnumElement(name='OnHMIStatusID'), message_type=EnumElement(name='notification'), params={ 'hmiLevel': Param(name='hmiLevel', param_type=Enum(name='HMILevel')) }) expected = OrderedDict() expected['origin'] = 'OnHMIStatus' expected['name'] = 'SDLOnHMIStatus' expected['extends_class'] = 'SDLRPCNotification' expected['imports'] = { ".h": { 'enum': {'SDLRPCNotification'}, 'struct': set() }, ".m": set() } expected['params'] = (self.producer.param_named( constructor_argument='hmiLevel', constructor_argument_override=None, constructor_prefix='HmiLevel', deprecated=False, description=[], for_name='enum', mandatory=True, method_suffix='HmiLevel', modifier='strong', of_class='', origin='hmiLevel', since=None, type_native='SDLHMILevel ', type_sdl='SDLHMILevel '), ) arguments = [ self.producer.argument_named(variable='hmiLevel', deprecated=False, origin='hmiLevel', constructor_argument='hmiLevel') ] expected['constructors'] = (self.producer.constructor_named( all=arguments, arguments=arguments, deprecated=False, self=True, init='HmiLevel:(SDLHMILevel)hmiLevel'), ) actual = self.producer.transform(item) self.assertDictEqual(expected, actual)
def test_diversity(self): fa = Function('a', ['a1'], "", name="equals_a") fb = Function('b', ['b1'], "", name="equals_b") f1 = Function('a', ['b'], "", name="f1") se = Substitution([fa]) s1 = Substitution([fb, f1]) d_s1 = s1.diversity([se]) d_se = se.diversity([s1]) self.assertEqual(d_s1, d_se) self.assertEqual(d_s1, 1) fc = Function('c', ['c1'], "", name="equals_c") f2 = Function('a', ['b', 'c'], "", name="f2") s2 = Substitution([fc, fb, f2]) d = se.diversity([s1, s2]) self.assertEqual(d, 2) d = s1.diversity([s2]) self.assertEqual(d, 0) d = s2.diversity([s1]) self.assertEqual(d, 1)
def test_RegisterAppInterface(self): params = OrderedDict() params['syncMsgVersion'] = Param( name='syncMsgVersion', param_type=Struct(name='SyncMsgVersion')) params['ttsName'] = Param( name='ttsName', param_type=Array(element_type=Struct(name='TTSChunk'))) item = Function(name='RegisterAppInterface', function_id=None, message_type=EnumElement(name='request'), params=params) expected = self.expected_template.copy() expected['kind'] = 'request' expected['function_id'] = 'REGISTER_APP_INTERFACE' expected['class_name'] = 'RegisterAppInterface' expected['extends_class'] = 'RPCRequest' expected['history'] = None expected['imports'] = [ 'androidx.annotation.NonNull', '', 'com.smartdevicelink.protocol.enums.FunctionID', 'com.smartdevicelink.proxy.RPCRequest', '', 'java.util.Hashtable', 'java.util.List' ] expected['params'] = (self.producer.params(deprecated=None, key='KEY_SDL_MSG_VERSION', last='sdlMsgVersion', mandatory=True, SuppressWarnings=None, origin='syncMsgVersion', return_type='SdlMsgVersion', since=None, title='SdlMsgVersion', description=None, param_doc=None, name=None), self.producer.params( SuppressWarnings='unchecked', deprecated=None, key='KEY_TTS_NAME', last='ttsName', mandatory=True, origin='ttsName', description=None, return_type='List<TTSChunk>', since=None, title='TtsName', param_doc=None, name=None)) actual = self.producer.transform(item) self.comparison(expected, actual)
def test_PutFileRequest(self): params = OrderedDict() params['fileType'] = Param( name='fileType', param_type=Enum( name='FileType', description=['Enumeration listing'], elements={'AUDIO_MP3': EnumElement(name='AUDIO_MP3')}), description=['Selected file type.']) item = Function(name='PutFile', function_id=Enum(name='PutFileID'), description=['\n Used to'], message_type=EnumElement(name='request'), params=params) expected = OrderedDict() expected['file_name'] = 'PutFile' expected['name'] = 'PutFile' expected['imports'] = { self.producer.imports(what='FileType', wherefrom='../enums/FileType.js'), self.producer.imports(what='RpcRequest', wherefrom='../RpcRequest.js'), self.producer.imports(what='FunctionID', wherefrom='../enums/FunctionID.js') } expected['methods'] = (self.producer.methods( key='KEY_FILE_TYPE', method_title='FileType', external='FileType', description=['Selected file type.'], param_name='type', type='FileType', param_values={}, since=None, history=None, deprecated=None), ) expected['params'] = (self.producer.params(key='KEY_FILE_TYPE', value="'fileType'"), ) expected['description'] = ['Used to'] expected['since'] = None expected['history'] = None expected['deprecated'] = None expected['script'] = self.producer.get_file_content( 'templates/scripts/PutFileRequest.js') expected['func'] = 'PutFile' expected['extend'] = 'RpcRequest' result = self.producer.transform(item) self.assertDictEqual(expected, result)
def test_CreateInteractionChoiceSetRequest(self): params = OrderedDict() params['choiceSet'] = Param( name='choiceSet', param_type=Array(element_type=Struct( name='Choice', description=['A choice is an option given to ' ]))) item = Function(name='CreateInteractionChoiceSet', function_id=Enum(name='CreateInteractionChoiceSetID'), description=['creates interaction'], message_type=EnumElement(name='request'), params=params) expected = OrderedDict() expected['file_name'] = 'CreateInteractionChoiceSet' expected['name'] = 'CreateInteractionChoiceSet' expected['imports'] = { self.producer.imports(what='Choice', wherefrom='../structs/Choice.js'), self.producer.imports(what='RpcRequest', wherefrom='../RpcRequest.js'), self.producer.imports(what='FunctionID', wherefrom='../enums/FunctionID.js') } expected['methods'] = (self.producer.methods( key='KEY_CHOICE_SET', method_title='ChoiceSet', external='Choice', description=['A choice is an option given to'], param_name='set', type='Choice[]', param_values={}, since=None, history=None, deprecated=None), ) expected['params'] = (self.producer.params(key='KEY_CHOICE_SET', value="'choiceSet'"), ) expected['description'] = ['creates interaction'] expected['since'] = None expected['history'] = None expected['deprecated'] = None expected['func'] = 'CreateInteractionChoiceSet' expected['extend'] = 'RpcRequest' result = self.producer.transform(item) self.assertDictEqual(expected, result)
def __get_substitution_of(self, vout, expr_results): """Recursively constructs a substitution object from parsing results. The recursion stops when no more function can be detected. In this case an empty substitution is returned (no functions). In case of a function, this method is called again (recursively) processing the inputs of the function first. When it returns the function is added. This depth-first approach ensures functions are in the right order to be executed. The last function calculates vout of this substitution. """ substitution = Substitution() # stop condition try: fct_term = expr_results['function'] except Exception as e: # expr_result does not contain a 'function' (any more) # -> it is an itom itom_name = str(expr_results) code = "# {} = {}\n".format(vout, itom_name) # copy (constructor) to copy value and timestamp # (we don't know the value and timestamp yet) # (value might be an object too -> deepcopy) code += "{} = copy.deepcopy({})\n".format( vout, Variable.toidentifier(itom_name)) # change name to variable (its not the original itom!) code += "{}.name = '{}'\n".format(vout, vout) f = Function(vout, [itom_name], code, name="equals", wrap=False) substitution.append(f) return substitution function = self.__get_function_of(fct_term) vin_substitutions = expr_results['other_substitutions'] assert len(function.vin) == len(vin_substitutions) # recursion # first add the substitutions of the inputs for i, s in enumerate(vin_substitutions): substitution.extend(self.__get_substitution_of(function.vin[i], s)) # finally add the function substitution.append(function) assert str(substitution.vout) == str(vout) return substitution
def test_execute_with_interval(self): f = Function('a', ['b', 'c'], "a.v = b.v + c.v", name="add") b = Itom('b', interval([0.5, 1.5])) c = Itom('c', interval([1, 3])) o = f.execute(Itoms([b, c])) self.assertEqual(o['a'].v, interval([1.5, 4.5])) # mix interval arithmetic with scalars b = Itom('b', 1) o = f.execute(Itoms([b, c])) self.assertEqual(o['a'].v, interval([2, 4])) # timestamps are intervals code = "a.v = b.v + c.v" + "\n" + "a.t = b.t & c.t" f = Function('a', ['b', 'c'], code, name="add") b = Itom('b', 1, interval([0.1, 0.2])) c = Itom('c', 2, interval([0.15, 0.25])) o = f.execute(Itoms([b, c])) self.assertEqual(o['a'].v, 3) self.assertEqual(o['a'].t, interval([0.15, 0.2]))
def test_OnEncodedSyncPDataNotification(self): params = OrderedDict() params['URL'] = Param(name='URL', param_type=String(), description=['\n If ']) item = Function(name='OnEncodedSyncPData', function_id=Enum(name='OnEncodedSyncPDataID'), description=['\n Callback including \n'], message_type=EnumElement(name='notification'), params=params) expected = OrderedDict() expected['file_name'] = 'OnEncodedSyncPData' expected['name'] = 'OnEncodedSyncPData' expected['imports'] = { self.producer.imports(what='RpcNotification', wherefrom='../RpcNotification.js'), self.producer.imports(what='FunctionID', wherefrom='../enums/FunctionID.js') } expected['methods'] = (self.producer.methods(key='KEY_URL', method_title='URL', external=None, description=['If'], param_name='url', type='String', param_values={}, since=None, history=None, deprecated=None), ) expected['params'] = (self.producer.params(key='KEY_URL', value="'URL'"), ) expected['description'] = ['Callback including'] expected['since'] = None expected['history'] = None expected['deprecated'] = None expected['func'] = 'OnEncodedSyncPData' expected['extend'] = 'RpcNotification' result = self.producer.transform(item) self.assertDictEqual(expected, result)
def test_OnEncodedSyncPDataNotification(self): item = Function(name='OnEncodedSyncPData', function_id=None, description=['\n Callback including \n'], message_type=EnumElement(name='notification'), params={ 'URL': Param(name='URL', param_type=String(), description=['\n If ']) }) expected = self.expected_template.copy() expected['kind'] = 'notification' expected['function_id'] = 'ON_ENCODED_SYNC_PDATA' expected['class_name'] = 'OnEncodedSyncPData' expected['extends_class'] = 'RPCNotification' expected['history'] = None expected['imports'] = [ 'androidx.annotation.NonNull', '', 'com.smartdevicelink.protocol.enums.FunctionID', 'com.smartdevicelink.proxy.RPCNotification', '', 'java.util.Hashtable' ] expected['description'] = ['Callback including'] expected['params'] = (self.producer.params(deprecated=None, description=['If'], key='KEY_URL', last='URL', title='URL', SuppressWarnings=None, mandatory=True, origin='URL', return_type='String', since=None, param_doc=None, name=None), ) actual = self.producer.transform(item) self.comparison(expected, actual)
def test_UnregisterAppInterfaceRequest(self): item = Function(name='UnregisterAppInterface', function_id=Enum(name='UnregisterAppInterfaceID'), message_type=EnumElement(name='request'), params=OrderedDict()) expected = OrderedDict() expected['file_name'] = 'UnregisterAppInterface' expected['name'] = 'UnregisterAppInterface' expected['imports'] = { self.producer.imports(what='RpcRequest', wherefrom='../RpcRequest.js'), self.producer.imports(what='FunctionID', wherefrom='../enums/FunctionID.js') } expected['methods'] = () expected['params'] = () expected['since'] = None expected['history'] = None expected['deprecated'] = None expected['func'] = 'UnregisterAppInterface' expected['extend'] = 'RpcRequest' result = self.producer.transform(item) self.assertDictEqual(expected, result)
def _parse_function(self, element, prefix): """Parse element as function. :param element: an instance of Element (from ElementTree) :param prefix: empty string :return: an instance of model.Function """ params, subelements, attrib = self._parse_base_item(element, prefix) function_id, message_type = self._parse_function_id_type( params["name"], attrib) params["function_id"] = function_id params["message_type"] = message_type for attribute in attrib: if attribute in ["scope", "deprecated", "removed"]: params[attribute] = attrib[attribute] if attribute in ["since", "until"]: params[attribute] = self._parse_version(attrib[attribute]) function_params = OrderedDict() for subelement in subelements: if subelement.tag == "param": function_param = self._parse_function_param(subelement, prefix) self._check_function_param_name(function_param.name) if function_param.name in function_params: raise ParseError( "Parameter '{}' is specified more than once for function '{}'" .format(function_param.name, params["name"])) function_params[function_param.name] = function_param else: raise ParseError( "Unexpected subelement '{}' in function '{}'".format( subelement.tag, params["name"])) params["params"] = function_params return Function(**params)
def test_GetVehicleDataResponse(self): params = OrderedDict() params['speed'] = Param(name='speed', param_type=Float(max_value=700.0, min_value=0.0)) item = Function(name='GetVehicleData', function_id=None, message_type=EnumElement(name='response'), params=params) expected = self.expected_template.copy() expected['kind'] = 'response' expected['function_id'] = 'GET_VEHICLE_DATA' expected['class_name'] = 'GetVehicleDataResponse' expected['extends_class'] = 'RPCResponse' expected['history'] = None expected['imports'] = [ 'androidx.annotation.NonNull', '', 'com.smartdevicelink.protocol.enums.FunctionID', 'com.smartdevicelink.proxy.RPCResponse', 'com.smartdevicelink.proxy.rpc.enums.Result', 'com.smartdevicelink.util.SdlDataTypeConverter', '', 'java.util.Hashtable' ] expected['params'] = (self.producer.params(deprecated=None, key='KEY_SPEED', description=None, last='speed', mandatory=True, SuppressWarnings=None, origin='speed', return_type='Float', since=None, title='Speed', param_doc=None, name=None), ) actual = self.producer.transform(item) self.comparison(expected, actual)
def test_RegisterAppInterfaceResponse(self): params = OrderedDict() params['language'] = Param(name='language', param_type=Enum(name='Language')) params['success'] = Param(name='success', param_type=Boolean()) item = Function(name='RegisterAppInterface', function_id=None, message_type=EnumElement(name='response'), params=params) expected = self.expected_template.copy() expected['kind'] = 'response' expected['function_id'] = 'REGISTER_APP_INTERFACE' expected['class_name'] = 'RegisterAppInterfaceResponse' expected['extends_class'] = 'RPCResponse' expected['history'] = None expected['imports'] = [ 'androidx.annotation.NonNull', '', 'com.smartdevicelink.protocol.enums.FunctionID', 'com.smartdevicelink.proxy.RPCResponse', 'com.smartdevicelink.proxy.rpc.enums.Language', 'com.smartdevicelink.proxy.rpc.enums.Result', '', 'java.util.Hashtable' ] expected['params'] = (self.producer.params(deprecated=None, key='KEY_LANGUAGE', last='language', mandatory=True, origin='language', return_type='Language', since=None, title='Language', description=None, SuppressWarnings=None, param_doc=None, name=None), ) actual = self.producer.transform(item) self.comparison(expected, actual)
from model.action import ActionTag from model.targeting_type import TargetingType from model.function import Function master_available_functions = [ Function(ActionTag.DamagePosition, TargetingType.KeyboardCoords, 2) ]
def setUp(self): self.__f_add = Function('a', ['b', 'c'], "a.v = b.v + c.v", name="add") self.__f_mult = Function('d', ['a'], "d.v = 2 * a.v", name="mult") self.__f_add2 = Function('a', ['b', 'c'], "a.v = b.v + c.v", name="add")
def test_full_generation(self): """Test full generation using SDLPRC 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_sdlrpc.h and test_expected_sdlrpc.cc in the same as this module. """ 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"] = EnumElement(name=u"request") message_type_elements[u"response"] = EnumElement( name=u"response") message_type_elements[u"notification"] = EnumElement( name=u"notification") message_type = Enum(name=u"messageType", elements=message_type_elements) elements1 = collections.OrderedDict() elements1[u"name1"] = EnumElement( name=u"name1", design_description=DESIGN_DESCRIPTION, todos=TODOS, value=u"1") elements1[u"name2"] = EnumElement( name="name2", description=DESCRIPTION, issues=ISSUES, internal_name=u"internal_name2") enum1 = Enum(name=u"Enum1", todos=TODOS, elements=elements1) elements2 = collections.OrderedDict() 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) elements3 = collections.OrderedDict() 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"] = 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 enums["Enum2"] = enum2 enums["Enum3"] = enum3 enums["Enum4"] = enum4 enums["messageType"] = message_type params1 = collections.OrderedDict() params1["1"] = Param( name="param1", design_description=DESIGN_DESCRIPTION, description=DESCRIPTION, issues=ISSUES, todos=TODOS, param_type=enum4, default_value=elements4["name1"]) params1["2"] = Param( name="param2", param_type=EnumSubset( name="sub1", enum=enum1, allowed_elements={"e1": elements1["name1"]}), default_value=elements1["name1"]) functions = collections.OrderedDict() functions["Function1"] = Function( name="Function1", function_id=elements1["name1"], message_type=message_type_elements["request"], params=params1) functions["Function2"] = Function( name="Function2", function_id=elements2["xxx"], message_type=message_type_elements["response"]) functions["Function3"] = Function( name="Function2", function_id=elements2["yyy"], message_type=message_type_elements["notification"]) members1 = collections.OrderedDict() 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=EnumSubset( name="sub", enum=enum1, allowed_elements={"e1": elements1["name1"]}), is_mandatory=False) members1["1"] = Param( name="arrayOfInt", param_type=Array(min_size=0, max_size=20, element_type=Boolean()), is_mandatory=False) members1["2"] = Param( name="arrayOfEnum1", param_type=Array(min_size=0, max_size=20, element_type=enum1), is_mandatory=False) members1["3"] = Param( name="arrayOfEnum3", param_type=Array(min_size=10, max_size=40, element_type=enum3), is_mandatory=True) members1["4"] = Param( name="arrayOfEnum4", param_type=Array( min_size=10, max_size=41, element_type=EnumSubset( name="sub1", enum=enum1, allowed_elements={"e1": elements1["name1"]}))) members1["5"] = Param( name="arrayOfEnum5", param_type=Array( min_size=10, max_size=42, element_type=EnumSubset( name="sub2", enum=enum1, allowed_elements={"e1": elements1["name2"]}))) members1["6"] = Param( name="arrayOfEnum6", param_type=Array( min_size=10, max_size=43, element_type=EnumSubset( name="sub3", enum=enum4, allowed_elements={"e1": elements4["name2"]}))) structs = collections.OrderedDict() structs["Struct1"] = Struct( name="Struct1", design_description=DESIGN_DESCRIPTION, issues=ISSUES, members=members1) structs["Struct2"] = Struct(name="Struct2", issues=ISSUES) interface = 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_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)