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)
