コード例 #1
0
    def _extract_param_type(self, attrib, prefix, name):
        type_name = self._extract_attrib(attrib, "type")
        if type_name is None:
            raise ParseError(
                "Type is not specified for parameter '{}'".format(name))
        if type_name == "Boolean":
            default_value = self._extract_attrib(attrib, "defvalue")
            if default_value is not None:
                default_value = self._get_bool_from_string(default_value)
            param_type = Boolean(default_value=default_value)
        elif type_name in ('Integer', 'Float', 'Double'):
            min_value = self._extract_optional_number_attrib(
                attrib, "minvalue", int if type_name == "Integer" else float)
            max_value = self._extract_optional_number_attrib(
                attrib, "maxvalue", int if type_name == "Integer" else float)
            default_value = self._extract_optional_number_attrib(
                attrib, "defvalue", int if type_name == "Integer" else float)

            param_type = (Integer if type_name == "Integer" else Float)(
                min_value=min_value,
                max_value=max_value,
                default_value=default_value)
        elif type_name == "String":
            min_length = self._extract_optional_number_attrib(
                attrib, "minlength")
            # if minlength is not defined default value is 1
            if min_length is None:
                min_length = 1
            max_length = self._extract_optional_number_attrib(
                attrib, "maxlength")
            default_value = self._extract_attrib(attrib, "defvalue")
            param_type = String(min_length=min_length,
                                max_length=max_length,
                                default_value=default_value)
        else:
            if type_name.count('.') == 1:
                custom_type_name = type_name.replace(".", "_")
            else:
                custom_type_name = prefix + type_name

            if custom_type_name in self._types:
                param_type = self._types[custom_type_name]
                default_value = self._extract_attrib(attrib, "defvalue")
                if default_value is not None:
                    if default_value not in param_type.elements:
                        raise ParseError(
                            "Default value '{}' for parameter '{}' is not a member of {}"
                            .format(default_value, name,
                                    type(param_type.__name__)))
                    default_value = param_type.elements[default_value]
            else:
                raise ParseError("Unknown type '{}'".format(type_name))
        if self._extract_optional_bool_attrib(attrib, "array", False):
            min_size = self._extract_optional_number_attrib(attrib, "minsize")
            max_size = self._extract_optional_number_attrib(attrib, "maxsize")
            param_type = Array(element_type=param_type,
                               min_size=min_size,
                               max_size=max_size)

        return param_type, default_value
コード例 #2
0
 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)
コード例 #3
0
    def __init__(self, wf):
        self.wf = wf
        if self.wf.update_available:
            wf.add_item('New version available',
                        'Action this item to install the update',
                        autocomplete='workflow:update',
                        icon=ICON_INFO)

        self.models = [
            DateTime(),
            MD5(),
            Base64(),
            Html(),
            Javascript(),
            SHA(),
            Number(),
            ASCII(),
            TheUUID(),
            String(),
            IPAddr(),
        ]
        self.modelDict = dict()
        self.max_age = 60 * 60 * 24 * 365
        for m in self.models:
            self.modelDict[m.name] = m
コード例 #4
0
    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)
コード例 #5
0
    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)
コード例 #6
0
    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'])
コード例 #7
0
 def test_SoftButton(self):
     members = OrderedDict()
     members['image'] = Param(name='image',
                              param_type=Struct(name='Image'),
                              description=['Optional image'])
     members['value'] = Param(name='value', param_type=String())
     item = Struct(name='SoftButton', members=members)
     expected = OrderedDict()
     expected['file_name'] = 'SoftButton'
     expected['name'] = 'SoftButton'
     expected['file_name'] = 'SoftButton'
     expected['imports'] = {
         self.producer.imports(what='Image', wherefrom='./Image.js'),
         self.producer.imports(what='RpcStruct',
                               wherefrom='../RpcStruct.js')
     }
     expected['methods'] = (self.producer.methods(
         description=['Optional image'],
         external='Image',
         key='KEY_IMAGE',
         method_title='Image',
         param_name='image',
         type='Image',
         param_values={},
         deprecated=None,
         history=None,
         since=None),
                            self.producer.methods(description=[],
                                                  external=None,
                                                  key='KEY_VALUE',
                                                  method_title='ValueParam',
                                                  param_name='value',
                                                  type='String',
                                                  param_values={},
                                                  deprecated=None,
                                                  history=None,
                                                  since=None))
     expected['params'] = (self.producer.params(key='KEY_IMAGE',
                                                value="'image'"),
                           self.producer.params(key='KEY_VALUE',
                                                value="'value'"))
     expected['since'] = None
     expected['history'] = None
     expected['deprecated'] = None
     expected['extend'] = 'RpcStruct'
     result = self.producer.transform(item)
     self.assertDictEqual(expected, result)
コード例 #8
0
ファイル: test_structs.py プロジェクト: zx5656/sdl_java_suite
 def test_OASISAddress(self):
     item = Struct(name='OASISAddress', members={
         'countryName': Param(name='countryName', param_type=String(max_length=200))
     })
     expected = {
         'package_name': 'com.smartdevicelink.proxy.rpc',
         'imports': ['android.support.annotation.NonNull', '', 'com.smartdevicelink.proxy.RPCStruct', '',
                     'java.util.Hashtable'],
         'class_name': 'OASISAddress',
         'extends_class': 'RPCStruct',
         'since': None,
         'deprecated': None,
         'params': (
             self.producer.params(deprecated=None, key='KEY_COUNTRY_NAME', last='countryName', mandatory=True,
                                  origin='countryName', return_type='String', since=None, title='CountryName',
                                  description=None, param_doc=None, name=None),)
     }
     actual = self.producer.transform(item)
     self.comparison(expected, actual)
コード例 #9
0
ファイル: test_structs.py プロジェクト: zx5656/sdl_java_suite
 def test_CloudAppProperties(self):
     item = Struct(name='CloudAppProperties', members={
         'nicknames': Param(name='nicknames',
                            param_type=Array(element_type=String(max_length=100, min_length=0), max_size=100,
                                             min_size=0)),
     })
     expected = {
         'class_name': 'CloudAppProperties',
         'extends_class': 'RPCStruct',
         'package_name': 'com.smartdevicelink.proxy.rpc',
         'imports': ['android.support.annotation.NonNull', '', 'com.smartdevicelink.proxy.RPCStruct', '',
                     'java.util.Hashtable', 'java.util.List'],
         'deprecated': None,
         'since': None,
         'params': (self.producer.params(deprecated=None, key='KEY_NICKNAMES',
                                         last='nicknames', mandatory=True,
                                         origin='nicknames', return_type='List<String>', name=None,
                                         since=None, title='Nicknames', description=None, param_doc=None),),
     }
     actual = self.producer.transform(item)
     self.comparison(expected, actual)
コード例 #10
0
 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)
コード例 #11
0
 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)
コード例 #12
0
    def test_CloudAppProperties(self):
        """
        generator/transformers/common_producer.py	64%
        generator/transformers/structs_producer.py	100%
        """
        members = OrderedDict()
        members['appID'] = Param(name='appID', param_type=String())
        members['value'] = Param(name='value', param_type=String())
        item = Struct(name='CloudAppProperties', members=members)
        expected = OrderedDict()
        expected['origin'] = 'CloudAppProperties'
        expected['name'] = 'SDLCloudAppProperties'
        expected['extends_class'] = 'SDLRPCStruct'
        expected['imports'] = {
            '.m': set(),
            '.h': {
                'enum': {'SDLRPCStruct'},
                'struct': set()
            }
        }
        expected['params'] = (
            self.producer.param_named(
                constructor_argument='appID',
                constructor_argument_override=None,
                constructor_prefix='AppID',
                deprecated=False,
                description=[
                    '{"default_value": null, "max_length": null, "min_length": null}'
                ],
                for_name='object',
                mandatory=True,
                method_suffix='AppID',
                modifier='strong',
                of_class='NSString.class',
                origin='appID',
                since=None,
                type_native='NSString *',
                type_sdl='NSString *'),
            self.producer.param_named(
                constructor_argument='valueParam',
                constructor_argument_override=None,
                constructor_prefix='ValueParam',
                deprecated=False,
                description=[
                    '{"default_value": null, "max_length": null, "min_length": null}'
                ],
                for_name='object',
                mandatory=True,
                method_suffix='ValueParam',
                modifier='strong',
                of_class='NSString.class',
                origin='valueParam',
                since=None,
                type_native='NSString *',
                type_sdl='NSString *'))

        argument = [
            self.producer.argument_named(variable='appID',
                                         deprecated=False,
                                         constructor_argument='appID',
                                         origin='appID'),
            self.producer.argument_named(variable='valueParam',
                                         deprecated=False,
                                         constructor_argument='valueParam',
                                         origin='valueParam')
        ]

        expected['constructors'] = (self.producer.constructor_named(
            all=argument,
            arguments=argument,
            deprecated=False,
            self='',
            init='AppID:(NSString *)appID valueParam:(NSString *)valueParam'),
                                    )

        actual = self.producer.transform(item)
        self.assertDictEqual(expected, actual)
コード例 #13
0
ファイル: test_functions.py プロジェクト: zx5656/sdl_ios
    def test_RegisterAppInterfaceRequest(self):
        """
        generator/transformers/common_producer.py		85%
        generator/transformers/functions_producer.py	63%
        """
        params = OrderedDict()
        params['syncMsgVersion'] = Param(name='syncMsgVersion',
                                         param_type=Struct(
                                             name='SyncMsgVersion',
                                             description=['Specifies the'],
                                             members={
                                                 'majorVersion':
                                                 Param(name='majorVersion',
                                                       param_type=Integer())
                                             }),
                                         description=['See SyncMsgVersion'],
                                         is_mandatory=True)
        params['fullAppID'] = Param(name='fullAppID',
                                    description=['ID used'],
                                    param_type=String(),
                                    is_mandatory=False)
        params['dayColorScheme'] = Param(
            name='dayColorScheme',
            param_type=Struct(
                name='TemplateColorScheme',
                description=[
                    '\n            A color scheme for all display layout templates.\n        '
                ]),
            is_mandatory=False)
        params['ttsName'] = Param(
            name='ttsName',
            description=['\n      TTS string for'],
            is_mandatory=False,
            param_type=Array(element_type=Struct(name='TTSChunk',
                                                 description=['A TTS chunk'])))
        params['isMediaApplication'] = Param(
            name='isMediaApplication',
            param_type=Boolean(),
            description=[
                '\n                Indicates if the application is a media or a '
            ],
            is_mandatory=True)

        item = Function(
            name='RegisterAppInterface',
            function_id=EnumElement(name='RegisterAppInterfaceID'),
            since='1.0.0',
            description=[
                '\n            Establishes an interface with a mobile application.\n            '
                'Before registerAppInterface no other commands will be accepted/executed.\n     '
            ],
            message_type=EnumElement(name='request'),
            params=params)
        expected = OrderedDict()
        expected['origin'] = 'RegisterAppInterface'
        expected['name'] = 'SDLRegisterAppInterface'
        expected['extends_class'] = 'SDLRPCRequest'
        expected['imports'] = {
            '.h': {
                'enum': {'SDLRPCRequest'},
                'struct':
                {'SDLTemplateColorScheme', 'SDLTTSChunk', 'SDLSdlMsgVersion'}
            },
            '.m':
            {'SDLTemplateColorScheme', 'SDLTTSChunk', 'SDLSdlMsgVersion'}
        }
        expected['description'] = [
            'Establishes an interface with a mobile application. Before registerAppInterface no '
            'other commands will be', 'accepted/executed.'
        ]
        expected['since'] = '1.0.0'
        expected['params'] = (
            self.producer.param_named(constructor_argument='sdlMsgVersion',
                                      constructor_argument_override=None,
                                      constructor_prefix='SdlMsgVersion',
                                      deprecated=False,
                                      description=['See SyncMsgVersion'],
                                      for_name='object',
                                      mandatory=True,
                                      method_suffix='SdlMsgVersion',
                                      modifier='strong',
                                      of_class='SDLSdlMsgVersion.class',
                                      origin='sdlMsgVersion',
                                      since=None,
                                      type_native='SDLSdlMsgVersion *',
                                      type_sdl='SDLSdlMsgVersion *'),
            self.producer.param_named(
                constructor_argument='fullAppID',
                constructor_argument_override=None,
                constructor_prefix='FullAppID',
                deprecated=False,
                description=[
                    'ID used',
                    '{"default_value": null, "max_length": null, "min_length": null}'
                ],
                for_name='object',
                mandatory=False,
                method_suffix='FullAppID',
                modifier='strong',
                of_class='NSString.class',
                origin='fullAppID',
                since=None,
                type_native='NSString *',
                type_sdl='NSString *'),
            self.producer.param_named(constructor_argument='dayColorScheme',
                                      constructor_argument_override=None,
                                      mandatory=False,
                                      constructor_prefix='DayColorScheme',
                                      deprecated=False,
                                      description=[],
                                      for_name='object',
                                      method_suffix='DayColorScheme',
                                      modifier='strong',
                                      of_class='SDLTemplateColorScheme.class',
                                      origin='dayColorScheme',
                                      since=None,
                                      type_native='SDLTemplateColorScheme *',
                                      type_sdl='SDLTemplateColorScheme *'),
            self.producer.param_named(constructor_argument='ttsName',
                                      constructor_argument_override=None,
                                      constructor_prefix='TtsName',
                                      deprecated=False,
                                      description=['TTS string for'],
                                      for_name='objects',
                                      mandatory=False,
                                      method_suffix='TtsName',
                                      modifier='strong',
                                      of_class='SDLTTSChunk.class',
                                      origin='ttsName',
                                      since=None,
                                      type_native='NSArray<SDLTTSChunk *> *',
                                      type_sdl='NSArray<SDLTTSChunk *> *'),
            self.producer.param_named(
                constructor_argument='isMediaApplication',
                constructor_argument_override=None,
                constructor_prefix='IsMediaApplication',
                deprecated=False,
                description=['Indicates if the application is a media or a'],
                for_name='object',
                mandatory=True,
                method_suffix='IsMediaApplication',
                modifier='strong',
                of_class='NSNumber.class',
                origin='isMediaApplication',
                since=None,
                type_native='BOOL',
                type_sdl='NSNumber<SDLBool> *'))

        mandatory_arguments = [
            self.producer.argument_named(variable='sdlMsgVersion',
                                         deprecated=False,
                                         origin='sdlMsgVersion',
                                         constructor_argument='sdlMsgVersion'),
            self.producer.argument_named(
                variable='isMediaApplication',
                deprecated=False,
                origin='isMediaApplication',
                constructor_argument='@(isMediaApplication)')
        ]
        not_mandatory_arguments = [
            self.producer.argument_named(variable='fullAppID',
                                         deprecated=False,
                                         origin='fullAppID',
                                         constructor_argument='fullAppID'),
            self.producer.argument_named(
                variable='dayColorScheme',
                deprecated=False,
                origin='dayColorScheme',
                constructor_argument='dayColorScheme'),
            self.producer.argument_named(variable='ttsName',
                                         deprecated=False,
                                         origin='ttsName',
                                         constructor_argument='ttsName')
        ]
        mandatory_init = 'SdlMsgVersion:(SDLSdlMsgVersion *)sdlMsgVersion ' \
                         'isMediaApplication:(BOOL)isMediaApplication'

        expected['constructors'] = (
            self.producer.constructor_named(all=mandatory_arguments,
                                            arguments=mandatory_arguments,
                                            deprecated=False,
                                            init=mandatory_init,
                                            self=True),
            self.producer.constructor_named(
                all=mandatory_arguments + not_mandatory_arguments,
                arguments=not_mandatory_arguments,
                deprecated=False,
                init=mandatory_init +
                ' fullAppID:(nullable NSString *)fullAppID dayColorScheme:(nullable '
                'SDLTemplateColorScheme *)dayColorScheme ttsName:(nullable NSArray<SDLTTSChunk '
                '*> *)ttsName',
                self=re.sub(r'([\w\d]+:)\([\w\d\s<>*]*\)([\w\d]+\s*)', r'\1\2',
                            mandatory_init)))

        actual = self.producer.transform(item)
        self.assertDictEqual(expected, actual)
コード例 #14
0
    def test_RegisterAppInterfaceRequest(self):
        params = OrderedDict()
        params['syncMsgVersion'] = Param(name='syncMsgVersion',
                                         param_type=Struct(
                                             name='SyncMsgVersion',
                                             description=['Specifies the'],
                                             members={
                                                 'majorVersion':
                                                 Param(name='majorVersion',
                                                       param_type=Integer())
                                             }),
                                         description=['See SyncMsgVersion'])
        params['fullAppID'] = Param(name='fullAppID',
                                    description=['ID used'],
                                    param_type=String())
        params['dayColorScheme'] = Param(
            name='dayColorScheme',
            param_type=Struct(
                name='TemplateColorScheme',
                description=[
                    '\n            A color scheme for all display layout templates.\n        '
                ]))
        params['ttsName'] = Param(
            name='ttsName',
            description=['\n      TTS string for'],
            param_type=Array(element_type=Struct(name='TTSChunk',
                                                 description=['A TTS chunk'])))

        item = Function(name='RegisterAppInterface',
                        function_id=Enum(name='RegisterAppInterfaceID'),
                        message_type=EnumElement(name='request'),
                        params=params)
        expected = OrderedDict()
        expected['file_name'] = 'RegisterAppInterface'
        expected['name'] = 'RegisterAppInterface'
        expected['imports'] = {
            self.producer.imports(what='SdlMsgVersion',
                                  wherefrom='../structs/SdlMsgVersion.js'),
            self.producer.imports(
                what='TemplateColorScheme',
                wherefrom='../structs/TemplateColorScheme.js'),
            self.producer.imports(what='TTSChunk',
                                  wherefrom='../structs/TTSChunk.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_SDL_MSG_VERSION',
                                  method_title='SdlMsgVersion',
                                  external='SdlMsgVersion',
                                  description=['See SyncMsgVersion'],
                                  param_name='version',
                                  type='SdlMsgVersion',
                                  param_values={},
                                  since=None,
                                  history=None,
                                  deprecated=None),
            self.producer.methods(key='KEY_FULL_APP_ID',
                                  method_title='FullAppID',
                                  external=None,
                                  description=['ID used'],
                                  param_name='id',
                                  type='String',
                                  param_values={},
                                  since=None,
                                  history=None,
                                  deprecated=None),
            self.producer.methods(
                key='KEY_DAY_COLOR_SCHEME',
                param_name='scheme',
                method_title='DayColorScheme',
                external='TemplateColorScheme',
                description=[
                    'A color scheme for all display layout templates.'
                ],
                type='TemplateColorScheme',
                param_values={},
                since=None,
                history=None,
                deprecated=None),
            self.producer.methods(key='KEY_TTS_NAME',
                                  param_name='name',
                                  method_title='TtsName',
                                  external='TTSChunk',
                                  description=['TTS string for'],
                                  type='TTSChunk[]',
                                  param_values={},
                                  since=None,
                                  history=None,
                                  deprecated=None))
        expected['params'] = (self.producer.params(key='KEY_SDL_MSG_VERSION',
                                                   value="'syncMsgVersion'"),
                              self.producer.params(key='KEY_FULL_APP_ID',
                                                   value="'fullAppID'"),
                              self.producer.params(key='KEY_DAY_COLOR_SCHEME',
                                                   value="'dayColorScheme'"),
                              self.producer.params(key='KEY_TTS_NAME',
                                                   value="'ttsName'"),
                              self.producer.params(key='APP_ID_MAX_LENGTH',
                                                   value=10))
        expected['since'] = None
        expected['history'] = None
        expected['deprecated'] = None
        expected['func'] = 'RegisterAppInterface'
        expected['extend'] = 'RpcRequest'

        result = self.producer.transform(item)
        self.assertDictEqual(expected, result)