moving generators to repository root

6 files changed, 750 insertions, 0 deletions

diff --git a/generator/test/__init__.py b/generator/test/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/generator/test/__init__.py
diff --git a/generator/test/runner.py b/generator/test/runner.py
new file mode 100755
index 000000000..a6754d57e
--- /dev/null
+++ b/generator/test/runner.py
@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""
+Main entry point to run all tests
+"""
+import sys
+from pathlib import Path
+from unittest import TestLoader, TestSuite, TextTestRunner
+
+PATH = Path(__file__).absolute()
+
+sys.path.append(PATH.parents[1].joinpath('rpc_spec/InterfaceParser').as_posix())
+sys.path.append(PATH.parents[1].as_posix())
+
+try:
+    from test_enums import TestEnumsProducer
+    from test_functions import TestFunctionsProducer
+    from test_structs import TestStructsProducer
+    from test_code_format_and_quality import CodeFormatAndQuality
+except ImportError as message:
+    print('{}. probably you did not initialize submodule'.format(message))
+    sys.exit(1)
+
+
+def main():
+    """
+    Main entry point to run all tests
+    """
+
+    suite = TestSuite()
+    suite.addTests(TestLoader().loadTestsFromTestCase(TestFunctionsProducer))
+    suite.addTests(TestLoader().loadTestsFromTestCase(TestEnumsProducer))
+    suite.addTests(TestLoader().loadTestsFromTestCase(TestStructsProducer))
+    suite.addTests(TestLoader().loadTestsFromTestCase(CodeFormatAndQuality))
+
+    runner = TextTestRunner(verbosity=2)
+    runner.run(suite)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/generator/test/test_code_format_and_quality.py b/generator/test/test_code_format_and_quality.py
new file mode 100644
index 000000000..43eab71ec
--- /dev/null
+++ b/generator/test/test_code_format_and_quality.py
@@ -0,0 +1,34 @@
+"""Interface model unit test
+
+"""
+
+import unittest
+from os import walk
+from os.path import join
+from pathlib import Path
+
+from flake8.api import legacy as flake8
+
+
+class CodeFormatAndQuality(unittest.TestCase):
+
+    def setUp(self):
+        """Searching for all python files to be checked
+
+        """
+        self.list_of_files = []
+        for (directory, _, filenames) in walk(Path(__file__).absolute().parents[1].as_posix()):
+            self.list_of_files += [join(directory, file) for file in filenames
+                                   if file.endswith('.py') and 'rpc_spec' not in directory]
+
+    def test_check(self):
+        """Performing checks by flake8
+
+        """
+        style_guide = flake8.get_style_guide(max_line_length=120, ignore=['W504', 'N802'])
+        report = style_guide.check_files(self.list_of_files)
+        self.assertEqual(report.total_errors, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/generator/test/test_enums.py b/generator/test/test_enums.py
new file mode 100644
index 000000000..c3b3c5208
--- /dev/null
+++ b/generator/test/test_enums.py
@@ -0,0 +1,282 @@
+import unittest
+from collections import namedtuple, OrderedDict
+
+from model.enum import Enum
+from model.enum_element import EnumElement
+from transformers.enums_producer import EnumsProducer
+
+
+class TestEnumsProducer(unittest.TestCase):
+    def setUp(self):
+        self.maxDiff = None
+        Paths = namedtuple('Prop', 'enums_package')
+        paths = Paths(enums_package='com.smartdevicelink.proxy.rpc.enums')
+        self.producer = EnumsProducer(paths)
+
+    def comparison(self, expected, actual):
+        actual = OrderedDict(sorted(actual.items()))
+        actual['params'] = tuple(sorted(actual['params'], key=lambda x: x.name))
+        expected = OrderedDict(sorted(expected.items()))
+        actual_params = dict(zip(map(lambda k: k.name, actual['params']), actual['params']))
+        expected_params = dict(zip(map(lambda k: k.name, expected['params']), expected['params']))
+        for key, param in actual_params.copy().items():
+            self.assertTrue(key in expected_params)
+        for key, param in expected_params.copy().items():
+            self.assertTrue(key in actual_params)
+            keys = actual_params[key]._asdict()
+            Params = namedtuple('Params', sorted(keys))
+            p = {name: getattr(param, name) for name in keys.keys()}
+            expected_params[key] = Params(**p)
+        expected['params'] = tuple(sorted(expected_params.values(), key=lambda x: x.name))
+
+        self.assertDictEqual(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': 'custom',
+            'return_type': 'int',
+            'package_name': 'com.smartdevicelink.proxy.rpc.enums',
+            'class_name': 'TestDeprecated',
+            'imports': {'java.util.EnumSet'},
+            '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_Language(self):
+        item = Enum(name='Language', elements={
+            'EN-US': EnumElement(name='EN-US', internal_name='EN-US')
+        })
+        expected = {
+            'kind': 'custom',
+            'return_type': 'String',
+            '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_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': 'custom',
+            'return_type': 'int',
+            'package_name': 'com.smartdevicelink.proxy.rpc.enums',
+            'class_name': 'PredefinedWindows',
+            'imports': {'java.util.EnumSet'},
+            '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,
+            'deprecated': None
+        }
+        actual = self.producer.transform(item)
+
+        self.comparison(expected, actual)
+
+    def test_SamplingRate(self):
+        item = Enum(name='SamplingRate', elements={
+            '8KHZ': EnumElement(name='8KHZ', internal_name='SamplingRate_8KHZ')
+        })
+        expected = {
+            'kind': 'custom',
+            'return_type': 'String',
+            'package_name': 'com.smartdevicelink.proxy.rpc.enums',
+            'class_name': 'SamplingRate',
+            'imports': {'java.util.EnumSet'},
+            'params': (
+                self.producer.params(name='_8KHZ', origin='8KHZ', internal='"8KHZ"', description=None, since=None,
+                                     value=None,
+                                     deprecated=None),),
+            'since': 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',
+            'return_type': 'String',
+            '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,
+            'deprecated': None
+        }
+        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',
+            'return_type': 'String',
+            '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_SpeechCapabilities(self):
+        item = Enum(name='SpeechCapabilities', since='1.0.0', elements={
+            'TEXT': EnumElement(name='TEXT', internal_name='SC_TEXT')
+        })
+        expected = {
+            'kind': 'simple',
+            'return_type': 'String',
+            'package_name': 'com.smartdevicelink.proxy.rpc.enums',
+            'class_name': 'SpeechCapabilities',
+            'params': (
+                self.producer.params(name='TEXT', origin='TEXT', description=None,
+                                     since=None, value=None, deprecated=None, internal=None),),
+            'since': '1.0.0',
+            'deprecated': None
+        }
+        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',
+            'return_type': 'String',
+            '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_ButtonName(self):
+        item = Enum(name='ButtonName', elements={
+            'OK': EnumElement(name='OK')
+        })
+        expected = {
+            'kind': 'simple',
+            'return_type': 'String',
+            '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,
+            'deprecated': None
+        }
+        actual = self.producer.transform(item)
+
+        self.comparison(expected, actual)
+
+    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',
+            'return_type': 'String',
+            '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_VehicleDataEventStatus(self):
+        item = Enum(name='VehicleDataEventStatus', elements={
+            'NO_EVENT': EnumElement(name='NO_EVENT', internal_name='VDES_NO_EVENT')
+        })
+        expected = {
+            'kind': 'simple',
+            'return_type': 'String',
+            '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_SystemCapabilityType(self):
+        elements = OrderedDict()
+        elements['DISPLAYS'] = EnumElement(name='DISPLAYS')
+        elements['NAVIGATION'] = EnumElement(name='NAVIGATION')
+
+        item = Enum(name='SystemCapabilityType', elements=elements)
+        expected = {
+            'kind': 'simple',
+            'return_type': 'String',
+            '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)
diff --git a/generator/test/test_functions.py b/generator/test/test_functions.py
new file mode 100644
index 000000000..d6a932141
--- /dev/null
+++ b/generator/test/test_functions.py
@@ -0,0 +1,234 @@
+import re
+import unittest
+from collections import namedtuple, OrderedDict
+
+from model.array import Array
+from model.boolean import Boolean
+from model.enum import Enum
+from model.enum_element import EnumElement
+from model.float import Float
+from model.function import Function
+from model.integer import Integer
+from model.param import Param
+from model.string import String
+from model.struct import Struct
+from transformers.functions_producer import FunctionsProducer
+
+
+class TestFunctionsProducer(unittest.TestCase):
+    def setUp(self):
+        self.maxDiff = None
+        Paths = namedtuple('Prop',
+                           'enums_package structs_package functions_package request_class response_class '
+                           'notification_class')
+        paths = Paths(enums_package='com.smartdevicelink.proxy.rpc.enums',
+                      structs_package='com.smartdevicelink.proxy.rpc',
+                      functions_package='com.smartdevicelink.proxy.rpc',
+                      request_class='com.smartdevicelink.proxy.RPCRequest',
+                      response_class='com.smartdevicelink.proxy.RPCResponse',
+                      notification_class='com.smartdevicelink.proxy.RPCNotification')
+        self.expected_template = OrderedDict()
+        self.expected_template['package_name'] = 'com.smartdevicelink.proxy.rpc'
+        self.expected_template['since'] = None
+        self.expected_template['deprecated'] = None
+        enum_names = ('FileType', 'Language')
+        struct_names = ('SdlMsgVersion', 'TemplateColorScheme', 'TTSChunk', 'Choice')
+        self.producer = FunctionsProducer(paths, enum_names, struct_names)
+
+    def comparison(self, expected, actual):
+        actual_params = dict(zip(map(lambda k: k.title, actual['params']), actual['params']))
+        for param in expected['params']:
+            for field in self.producer.params._fields:
+                self.assertEqual(getattr(param, field), getattr(actual_params[param.title], field, None))
+        expected_filtered = dict(filter(lambda e: e[0] != 'params', expected.items()))
+        actual_filtered = dict(filter(lambda e: e[0] != 'params', actual.items()))
+
+        self.assertDictEqual(expected_filtered, actual_filtered)
+
+    def test_Version(self):
+        version = self.producer.get_version
+        self.assertIsNotNone(version)
+        self.assertTrue(re.match(r'^\d*\.\d*\.\d*$', version))
+
+    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['imports'] = ['android.support.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['imports'] = ['android.support.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)
+
+    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['imports'] = ['android.support.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.'])
+        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['imports'] = ['android.support.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_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['imports'] = ['android.support.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_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_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)
diff --git a/generator/test/test_structs.py b/generator/test/test_structs.py
new file mode 100644
index 000000000..b8985cba8
--- /dev/null
+++ b/generator/test/test_structs.py
@@ -0,0 +1,160 @@
+import unittest
+from collections import namedtuple, OrderedDict
+
+from model.array import Array
+from model.enum import Enum
+from model.float import Float
+from model.param import Param
+from model.string import String
+from model.struct import Struct
+from transformers.structs_producer import StructsProducer
+
+
+class TestStructsProducer(unittest.TestCase):
+    def setUp(self):
+        self.maxDiff = None
+        Paths = namedtuple('Prop', 'enums_package structs_package struct_class')
+        paths = Paths(enums_package='com.smartdevicelink.proxy.rpc.enums',
+                      structs_package='com.smartdevicelink.proxy.rpc',
+                      struct_class='com.smartdevicelink.proxy.RPCStruct')
+        self.producer = StructsProducer(paths, ['SamplingRate'], ('Image',))
+
+    def comparison(self, expected, actual):
+        actual_params = dict(zip(map(lambda k: k.origin, actual['params']), actual['params']))
+        for param in expected['params']:
+            for field in self.producer.params._fields:
+                self.assertEqual(getattr(param, field), getattr(actual_params[param.origin], field, None))
+        expected_filtered = dict(filter(lambda e: e[0] != 'params', expected.items()))
+        actual_filtered = dict(filter(lambda e: e[0] != 'params', actual.items()))
+
+        self.assertDictEqual(expected_filtered, actual_filtered)
+
+    def test_AudioPassThruCapabilities(self):
+        members = OrderedDict()
+        members['range'] = Param(name='range', param_type=Float(max_value=10000.0, min_value=0.0))
+        members['samplingRate'] = Param(name='samplingRate', param_type=Enum(name='SamplingRate'))
+        item = Struct(name='AudioPassThruCapabilities', members=members)
+        expected = {
+            'class_name': 'AudioPassThruCapabilities',
+            'extends_class': 'RPCStruct',
+            'package_name': 'com.smartdevicelink.proxy.rpc',
+            'imports': ['android.support.annotation.NonNull', '', 'com.smartdevicelink.proxy.RPCStruct',
+                        'com.smartdevicelink.proxy.rpc.enums.SamplingRate',
+                        'com.smartdevicelink.util.SdlDataTypeConverter', '', 'java.util.Hashtable'],
+            'deprecated': None,
+            'since': None,
+            'params': (self.producer.params(deprecated=None, key='KEY_RANGE',
+                                            last='range', mandatory=True,
+                                            origin='range', return_type='Float',
+                                            since=None, title='Range', description=None, param_doc=None, name=None),
+                       self.producer.params(deprecated=None, key='KEY_SAMPLING_RATE',
+                                            last='samplingRate', mandatory=True,
+                                            origin='samplingRate', return_type='SamplingRate', name=None,
+                                            since=None, title='SamplingRate', description=None, param_doc=None)),
+        }
+        actual = self.producer.transform(item)
+
+        self.comparison(expected, actual)
+
+    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)
+
+    def test_SoftButton(self):
+        item = Struct(name='SoftButton', members={
+            'image': Param(name='image', param_type=Struct(name='Image'), description=['Optional image']),
+        }, description=['\n            Describes different audio type configurations for PerformAudioPassThru.\n     '])
+        expected = {
+            'package_name': 'com.smartdevicelink.proxy.rpc',
+            'imports': ['android.support.annotation.NonNull', '', 'com.smartdevicelink.proxy.RPCStruct', '',
+                        'java.util.Hashtable'],
+            'class_name': 'SoftButton',
+            'extends_class': 'RPCStruct',
+            'since': None,
+            'deprecated': None,
+            'description': ['Describes different audio type configurations for '
+                            'PerformAudioPassThru.'],
+            'params': (self.producer.params(deprecated=None, description=['Optional image'], key='KEY_IMAGE',
+                                            last='image', mandatory=True, origin='image', return_type='Image',
+                                            since=None, title='Image', param_doc=None, name=None),)
+        }
+        actual = self.producer.transform(item)
+        self.comparison(expected, actual)
+
+    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)
+
+    def test_LocationDetails(self):
+        item = Struct(name='LocationDetails', members={
+            'searchAddress': Param(name='searchAddress', param_type=Struct(name='OASISAddress'))
+        })
+        expected = {
+            'package_name': 'com.smartdevicelink.proxy.rpc',
+            'imports': ['android.support.annotation.NonNull', '', 'com.smartdevicelink.proxy.RPCStruct', '',
+                        'java.util.Hashtable'],
+            'class_name': 'LocationDetails',
+            'extends_class': 'RPCStruct',
+            'since': None,
+            'deprecated': None,
+            'params': (
+                self.producer.params(deprecated=None, key='KEY_SEARCH_ADDRESS', last='searchAddress', mandatory=True,
+                                     origin='searchAddress', return_type='OASISAddress', since=None,
+                                     title='SearchAddress', description=None, param_doc=None, name=None),)
+        }
+        actual = self.producer.transform(item)
+        self.comparison(expected, actual)
+
+    def test_SingleTireStatus(self):
+        item = Struct(name='SingleTireStatus', members={
+            'tpms': Param(name='tpms', param_type=Enum(name='TPMS'))
+        })
+        expected = {
+            'package_name': 'com.smartdevicelink.proxy.rpc',
+            'imports': ['android.support.annotation.NonNull', '', 'com.smartdevicelink.proxy.RPCStruct', '',
+                        'java.util.Hashtable'],
+            'class_name': 'SingleTireStatus',
+            'extends_class': 'RPCStruct',
+            'since': None,
+            'deprecated': None,
+            'params': (
+                self.producer.params(deprecated=None, key='KEY_TPMS', last='tpms', mandatory=True, origin='tpms',
+                                     return_type='TPMS', since=None, title='Tpms', description=None, param_doc=None,
+                                     name=None),)
+        }
+        actual = self.producer.transform(item)
+        self.comparison(expected, actual)