def test_FunctionID(self):
"""
generator/transformers/common_producer.py 34%
generator/transformers/enums_producer.py 80%
"""
elements = OrderedDict()
elements['RESERVED'] = EnumElement(name='RESERVED', value=0)
elements['RegisterAppInterfaceID'] = EnumElement(name='RegisterAppInterfaceID', hex_value=1)
elements['PerformAudioPassThruID'] = EnumElement(name='PerformAudioPassThruID', hex_value=10)
item = Enum(name='FunctionID', elements=elements)
expected = OrderedDict()
expected['origin'] = 'FunctionID'
expected['name'] = 'SDLFunctionID'
expected['imports'] = {
'.h': {'SDLEnum'},
'.m': ['SDLEnum']
}
expected['history'] = None
expected['params'] = (
self.producer.param_named(history=None, description=[], name='Reserved', origin='RESERVED', since=None, deprecated=False),
self.producer.param_named(history=None, description=[], name='RegisterAppInterface', origin='RegisterAppInterfaceID',
since=None, deprecated=False),
self.producer.param_named(history=None, description=[], name='PerformAudioPassThru', origin='PerformAudioPassThruID',
since=None, deprecated=False),)
actual = self.producer.transform(item)
self.assertDictEqual(expected, actual)
def test_TextFieldName(self):
"""
generator/transformers/common_producer.py 34%
generator/transformers/enums_producer.py 98%
"""
elements = OrderedDict()
elements['SUCCESS'] = EnumElement(name='SUCCESS')
elements['mainField1'] = EnumElement(name='mainField1')
elements['H264'] = EnumElement(name='H264')
elements['UNSUPPORTED_REQUEST'] = EnumElement(name='UNSUPPORTED_REQUEST')
item = Enum(name='TextFieldName', elements=elements)
expected = OrderedDict()
expected['origin'] = 'TextFieldName'
expected['name'] = 'SDLTextFieldName'
expected['imports'] = {
'.h': {'SDLEnum'},
'.m': ['SDLEnum']
}
expected['history'] = None
expected['params'] = (
self.producer.param_named(history=None, description=[], name='Success', origin='SUCCESS', since=None,
deprecated=False),
self.producer.param_named(history=None, description=[], name='MainField1', origin='mainField1', since=None,
deprecated=False),
self.producer.param_named(history=None, description=[], name='H264', origin='H264', since=None, deprecated=False),
self.producer.param_named(history=None, description=[], name='UnsupportedRequest', origin='UNSUPPORTED_REQUEST',
since=None, deprecated=False))
actual = self.producer.transform(item)
self.assertDictEqual(expected, actual)
def test_SystemCapabilityType(self):
elements = OrderedDict()
elements['DISPLAYS'] = EnumElement(name='DISPLAYS')
elements['NAVIGATION'] = EnumElement(name='NAVIGATION')
item = Enum(name='SystemCapabilityType', elements=elements)
expected = {
'kind':
'simple',
'package_name':
'com.smartdevicelink.proxy.rpc.enums',
'class_name':
'SystemCapabilityType',
'params': (self.producer.params(deprecated=None,
value=None,
description=None,
name='DISPLAYS',
origin='DISPLAYS',
since=None,
internal=None),
self.producer.params(deprecated=None,
value=None,
description=None,
name='NAVIGATION',
origin='NAVIGATION',
since=None,
internal=None)),
'since':
None,
'deprecated':
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.'])
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_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_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_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_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_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_VehicleDataEventStatus(self):
item = Enum(name='VehicleDataEventStatus',
elements={
'NO_EVENT':
EnumElement(name='NO_EVENT',
internal_name='VDES_NO_EVENT')
})
expected = {
'kind':
'simple',
'package_name':
'com.smartdevicelink.proxy.rpc.enums',
'class_name':
'VehicleDataEventStatus',
'params': (self.producer.params(deprecated=None,
value=None,
description=None,
name='NO_EVENT',
origin='NO_EVENT',
since=None,
internal=None), ),
'since':
None,
'deprecated':
None,
}
actual = self.producer.transform(item)
self.comparison(expected, actual)
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 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_Language(self):
item = Enum(name='Language',
elements={
'EN-US': EnumElement(name='EN-US',
internal_name='EN-US')
})
expected = {
'kind':
'custom',
'package_name':
'com.smartdevicelink.proxy.rpc.enums',
'class_name':
'Language',
'params': (self.producer.params(name='EN_US',
origin='EN-US',
internal='"EN-US"',
description=None,
since=None,
value=None,
deprecated=None), ),
'since':
None,
'deprecated':
None,
'imports': {'java.util.EnumSet'}
}
actual = self.producer.transform(item)
self.comparison(expected, actual)
def test_DisplayType(self):
item = Enum(name='DisplayType',
deprecated=True,
since='5.0.0',
elements={'CID': EnumElement(name='CID', since='3.0.0')})
expected = {
'kind':
'simple',
'package_name':
'com.smartdevicelink.proxy.rpc.enums',
'class_name':
'DisplayType',
'params': (self.producer.params(name='CID',
origin='CID',
internal=None,
description=None,
since='3.0.0',
value=None,
deprecated=None), ),
'since':
'5.0.0',
'deprecated':
True
}
actual = self.producer.transform(item)
self.comparison(expected, actual)
def test_VrCapabilities1(self):
item = Enum(name='VrCapabilities',
elements={
'TEXT': EnumElement(name='TEXT',
internal_name='VR_TEXT')
})
expected = {
'kind':
'simple',
'package_name':
'com.smartdevicelink.proxy.rpc.enums',
'class_name':
'VrCapabilities',
'params': (self.producer.params(name='TEXT',
origin='TEXT',
description=None,
since=None,
value=None,
deprecated=None,
internal=None), ),
'since':
None,
'deprecated':
None
}
actual = self.producer.transform(item)
self.comparison(expected, actual)
def test_deprecated(self):
item = Enum(name='TestDeprecated',
deprecated=True,
elements={
'PRIMARY_WIDGET':
EnumElement(name='PRIMARY_WIDGET',
internal_name='PRIMARY_WIDGET',
value=1,
deprecated=True)
})
expected = {
'kind':
'simple',
'package_name':
'com.smartdevicelink.proxy.rpc.enums',
'class_name':
'TestDeprecated',
'params': (self.producer.params(name='PRIMARY_WIDGET',
origin='PRIMARY_WIDGET',
deprecated=True,
internal=1,
description=None,
since=None,
value=None), ),
'since':
None,
'deprecated':
True
}
actual = self.producer.transform(item)
self.comparison(expected, actual)
def test_Result(self):
elements = OrderedDict()
elements['SUCCESS'] = EnumElement(name='SUCCESS')
item = Enum(name='Result', elements=elements)
expected = OrderedDict()
expected['file_name'] = 'Result'
expected['name'] = 'Result'
expected['file_name'] = 'Result'
expected['imports'] = {
self.producer.imports(what='Enum', wherefrom='../../util/Enum.js')
}
expected['methods'] = (self.producer.methods(method_title='SUCCESS',
description=[],
type='String',
since=None,
history=None,
deprecated=None), )
expected['params'] = (self.producer.params(key='SUCCESS',
value="'SUCCESS'"), )
expected['since'] = None
expected['history'] = None
expected['deprecated'] = None
expected['extend'] = 'Enum'
result = self.producer.transform(item)
self.assertDictEqual(expected, result)
def _parse_enum_element(self, element):
"""Parse element as element of enumeration.
:param element: an instance of Element (from ElementTree)
:return: an instance of model.EnumElement
"""
params, subelements, attrib = self._parse_base_item(element, "")
if len(subelements) != 0:
raise ParseError("Unexpected subelements in enum element")
self._ignore_attribute(attrib, "scope")
self._ignore_attribute(attrib, "rootscreen")
for attribute in attrib:
if attribute == "value":
try:
params[attribute] = int(attrib[attribute])
except:
raise ParseError(
"Invalid value for enum element: '{}'".format(
attrib[attribute]))
elif attribute == "hexvalue":
params["hex_value"] = attrib[attribute]
elif attribute in ["internal_name", "deprecated", "removed"]:
params[attribute] = attrib[attribute]
elif attribute in ["since", "until"]:
params[attribute] = self._parse_version(attrib[attribute])
return EnumElement(**params)
def test_FunctionID(self):
elements = OrderedDict()
elements['RESERVED'] = EnumElement(name='RESERVED', value=0)
elements['RegisterAppInterfaceID'] = EnumElement(
name='RegisterAppInterfaceID', hex_value=1)
elements['PerformAudioPassThruID'] = EnumElement(
name='PerformAudioPassThruID', hex_value=10)
item = Enum(name='FunctionID', elements=elements)
expected = OrderedDict()
expected['file_name'] = 'FunctionID'
expected['name'] = 'FunctionID'
expected['imports'] = {
self.producer.imports(what='Enum', wherefrom='../../util/Enum.js')
}
expected['methods'] = (self.producer.methods(method_title='RESERVED',
description=[],
type='Number',
since=None,
history=None,
deprecated=None),
self.producer.methods(
method_title='RegisterAppInterface',
description=[],
type='Number',
since=None,
history=None,
deprecated=None),
self.producer.methods(
method_title='PerformAudioPassThru',
description=[],
type='Number',
since=None,
history=None,
deprecated=None))
expected['params'] = (self.producer.params(key='RESERVED',
value="'RESERVED'"),
self.producer.params(key='RegisterAppInterface',
value='0x01'),
self.producer.params(key='PerformAudioPassThru',
value='0x10'))
expected['since'] = None
expected['history'] = None
expected['deprecated'] = None
expected['extend'] = 'Enum'
result = self.producer.transform(item)
self.assertDictEqual(expected, result)
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_Dimension(self):
item = Enum(name='Dimension',
elements={
'NO_FIX':
EnumElement(name='NO_FIX',
internal_name='Dimension_NO_FIX'),
'2D':
EnumElement(name='2D', internal_name='Dimension_2D')
})
expected = {
'kind':
'custom',
'package_name':
'com.smartdevicelink.proxy.rpc.enums',
'class_name':
'Dimension',
'params': (
self.producer.params(deprecated=None,
value=None,
description=None,
name='NO_FIX',
origin='NO_FIX',
since=None,
internal='"NO_FIX"'),
self.producer.params(deprecated=None,
value=None,
description=None,
name='_2D',
origin='2D',
since=None,
internal='"2D"'),
),
'since':
None,
'deprecated':
None,
'imports': {'java.util.EnumSet'}
}
actual = self.producer.transform(item)
self.comparison(expected, actual)
def test_gen_enum_elements(self):
"""Test generation of the enum elements.
Verifies correct generation of the enum elements.
"""
generator = SmartFactoryBase.CodeGenerator()
elements = [
EnumElement(name=u"name1",
design_description=DESIGN_DESCRIPTION,
todos=TODOS,
value=u"1"),
EnumElement(name=u"name2",
description=DESCRIPTION,
issues=ISSUES,
internal_name=u"internal_name2")
]
self.assertEqual(generator._gen_enum_elements(elements),
EXPECTED_RESULT_ENUM_ELEMENTS1,
"Simple enum elements are invalid")
def test_PredefinedWindows(self):
elements = OrderedDict()
elements['DEFAULT_WINDOW'] = EnumElement(name='DEFAULT_WINDOW', value=0)
elements['PRIMARY_WIDGET'] = EnumElement(name='PRIMARY_WIDGET', value=1)
item = Enum(name='PredefinedWindows', elements=elements)
expected = {
'kind': 'simple',
'package_name': 'com.smartdevicelink.proxy.rpc.enums',
'class_name': 'PredefinedWindows',
'params': (self.producer.params(name='DEFAULT_WINDOW', origin='DEFAULT_WINDOW',
internal=0, description=None, since=None, value=None,
deprecated=None),
self.producer.params(name='PRIMARY_WIDGET', origin='PRIMARY_WIDGET',
internal=1, description=None, since=None, value=None,
deprecated=None)),
'since': None,
'history': None,
'deprecated': None
}
actual = self.producer.transform(item)
self.comparison(expected, actual)
def test_Result(self):
elements = OrderedDict()
elements['SUCCESS'] = EnumElement(name='SUCCESS', description=['The request succeeded'])
elements['VEHICLE_DATA_NOT_AVAILABLE'] = EnumElement(name='VEHICLE_DATA_NOT_AVAILABLE', since='2.0.0')
item = Enum(name='Result', elements=elements)
expected = {
'kind': 'simple',
'package_name': 'com.smartdevicelink.proxy.rpc.enums',
'class_name': 'Result',
'params': (
self.producer.params(name='SUCCESS', origin='SUCCESS', internal=None,
description=['The request succeeded'],
since=None, value=None, deprecated=None),
self.producer.params(name='VEHICLE_DATA_NOT_AVAILABLE', origin='VEHICLE_DATA_NOT_AVAILABLE',
internal=None, description=None, since='2.0.0', value=None, deprecated=None)),
'since': None,
'history': None,
'deprecated': None
}
actual = self.producer.transform(item)
self.comparison(expected, actual)
def test_gen_enum(self):
"""Test generation of the enum.
Verifies correct generation of the enum.
"""
generator = SmartFactoryBase.CodeGenerator()
elements1 = collections.OrderedDict()
elements1[u"name1"] = EnumElement(
name=u"name1",
design_description=DESIGN_DESCRIPTION,
todos=TODOS,
value=u"1")
elements1[u"name2"] = EnumElement(name=u"name2",
description=DESCRIPTION,
issues=ISSUES,
internal_name=u"internal_name2")
enum1 = Enum(name=u"Enum1", todos=TODOS, elements=elements1)
self.assertEqual(generator._gen_enum(enum1), EXPECTED_RESULT_ENUM1,
"Simple enum is invalid")
elements2 = collections.OrderedDict()
elements2[u"xxx"] = EnumElement(name=u"xxx", internal_name=u"val_1")
elements2[u"yyy"] = EnumElement(name=u"yyy",
internal_name=u"val_2",
value=u"100")
elements2[u"zzz"] = EnumElement(name=u"val_3")
enum2 = Enum(name=u"E2", elements=elements2)
self.assertEqual(generator._gen_enum(enum2), EXPECTED_RESULT_ENUM2,
"Long enum is invalid")
self.assertEqual(
generator._gen_enums([enum1, enum2], collections.OrderedDict()),
u"{0}\n{1}".format(EXPECTED_RESULT_ENUM1, EXPECTED_RESULT_ENUM2),
"Generated enums are invalid")
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_gen_enum_element(self):
"""Test generation of the single enum element.
Verifies correct generation of the single enum element.
"""
generator = SmartFactoryBase.CodeGenerator()
enum_element1 = EnumElement(name=u"Element1",
internal_name=u"InternalName",
value=u"10")
self.assertEqual(
generator._gen_enum_element(enum_element1),
EXPECTED_RESULT_ENUM_ELEMENT1,
"Short commented enum element with internal name is invalid")
enum_element2 = EnumElement(name=u"NO_VALUE_ELEMENT",
description=DESCRIPTION,
design_description=DESIGN_DESCRIPTION)
self.assertEqual(generator._gen_enum_element(enum_element2),
EXPECTED_RESULT_ENUM_ELEMENT2,
"Enum element with no value is invalid")
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"] = 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)
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"] = EnumElement(name=u"request")
message_type_elements[u"notification"] = EnumElement(
name=u"notification")
message_type = 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_ButtonName(self):
item = Enum(name='ButtonName', elements={
'OK': EnumElement(name='OK')
})
expected = {
'kind': 'simple',
'package_name': 'com.smartdevicelink.proxy.rpc.enums',
'class_name': 'ButtonName',
'params': (
self.producer.params(deprecated=None, value=None, description=None,
name='OK', origin='OK', since=None, internal=None),),
'since': None,
'history': None,
'deprecated': None
}
actual = self.producer.transform(item)
self.comparison(expected, actual)