SDL 3.8!

Signed-off-by: Justin Dickow <jjdickow@gmail.com>

19 files changed, 4239 insertions, 0 deletions

diff --git a/tools/InterfaceGenerator/test/__init__.py b/tools/InterfaceGenerator/test/__init__.py
new file mode 100755
index 0000000000..e69de29bb2
--- /dev/null
+++ b/tools/InterfaceGenerator/test/__init__.py
diff --git a/tools/InterfaceGenerator/test/generator/__init__.py b/tools/InterfaceGenerator/test/generator/__init__.py
new file mode 100755
index 0000000000..e69de29bb2
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/__init__.py
diff --git a/tools/InterfaceGenerator/test/generator/generators/__init__.py b/tools/InterfaceGenerator/test/generator/generators/__init__.py
new file mode 100755
index 0000000000..e69de29bb2
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/__init__.py
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryBase.py b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryBase.py
new file mode 100755
index 0000000000..aea91f4a45
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryBase.py
@@ -0,0 +1,283 @@
+"""Test for SmartFactory generator base.
+
+Verifies common helper functions and produced source code.
+
+"""
+import collections
+import unittest
+
+from generator.generators import SmartFactoryBase
+from generator import Model
+
+
+EXPECTED_RESULT_FULL_COMMENT = u"""/**
+ * @brief Enumeration Test Name.
+ *
+ * Description Line1
+ * Description Line2
+ *
+ * Design Line1
+ *
+ * @note Issue1
+ * @note Issue2
+ * @note Issue3
+ *
+ * @todo Do1
+ * @todo Do2
+ */"""
+
+EXPECTED_RESULT_ENUM_ELEMENT1 = u"""/**
+ * @brief InternalName.
+ */
+InternalName = 10"""
+
+EXPECTED_RESULT_ENUM_ELEMENT2 = u"""/**
+ * @brief NO_VALUE_ELEMENT.
+ *
+ * Description Line1
+ * Description Line2
+ *
+ * Design Line1
+ */
+NO_VALUE_ELEMENT"""
+
+EXPECTED_RESULT_ENUM_ELEMENTS1 = u"""/**
+ * @brief name1.
+ *
+ * Design Line1
+ *
+ * @todo Do1
+ * @todo Do2
+ */
+name1 = 1,
+
+/**
+ * @brief internal_name2.
+ *
+ * Description Line1
+ * Description Line2
+ *
+ * @note Issue1
+ * @note Issue2
+ * @note Issue3
+ */
+internal_name2"""
+
+EXPECTED_RESULT_ENUM1 = u"""namespace Enum1 {
+/**
+ * @brief Enumeration Enum1.
+ *
+ * @todo Do1
+ * @todo Do2
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief name1.
+   *
+   * Design Line1
+   *
+   * @todo Do1
+   * @todo Do2
+   */
+  name1 = 1,
+
+  /**
+   * @brief internal_name2.
+   *
+   * Description Line1
+   * Description Line2
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  internal_name2
+};
+} // Enum1
+"""
+
+EXPECTED_RESULT_ENUM2 = u"""namespace E2 {
+/**
+ * @brief Enumeration E2.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief val_1.
+   */
+  val_1,
+
+  /**
+   * @brief val_2.
+   */
+  val_2 = 100,
+
+  /**
+   * @brief val_3.
+   */
+  val_3
+};
+} // E2
+"""
+
+DESCRIPTION = [u"Description Line1", u"Description Line2"]
+
+DESIGN_DESCRIPTION = [u"Design Line1"]
+
+ISSUES = [Model.Issue(value=u"Issue1"),
+          Model.Issue(value=u"Issue2"),
+          Model.Issue(value=u"Issue3")]
+
+TODOS = [u"Do1", u"Do2"]
+
+
+class Test(unittest.TestCase):
+
+    """Test for SmartFactory base generator.
+
+    This class holds set of test cases for the SmartFactory base generator.
+
+    """
+
+    def test_gen_comment(self):
+        """Test generation of the source code comments.
+
+        Verifies correct generation of the code comments.
+
+        """
+        generator = SmartFactoryBase.CodeGenerator()
+
+        enum = Model.Enum(name=u"Test Name",
+                          description=DESCRIPTION,
+                          design_description=DESIGN_DESCRIPTION,
+                          issues=ISSUES,
+                          todos=TODOS)
+        self.assertEqual(generator._gen_comment(enum),
+                         EXPECTED_RESULT_FULL_COMMENT,
+                         "Full comment for enum is invalid")
+
+    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 = Model.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 = Model.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_gen_enum_elements(self):
+        """Test generation of the enum elements.
+
+        Verifies correct generation of the enum elements.
+
+        """
+        generator = SmartFactoryBase.CodeGenerator()
+
+        elements = [Model.EnumElement(name=u"name1",
+                                      design_description=DESIGN_DESCRIPTION,
+                                      todos=TODOS,
+                                      value=u"1"),
+                    Model.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_gen_enum(self):
+        """Test generation of the enum.
+
+        Verifies correct generation of the enum.
+
+        """
+        generator = SmartFactoryBase.CodeGenerator()
+
+        elements1 = collections.OrderedDict()
+        elements1[u"name1"] = Model.EnumElement(
+            name=u"name1",
+            design_description=DESIGN_DESCRIPTION,
+            todos=TODOS,
+            value=u"1")
+        elements1[u"name2"] = Model.EnumElement(
+            name=u"name2",
+            description=DESCRIPTION,
+            issues=ISSUES,
+            internal_name=u"internal_name2")
+
+        enum1 = Model.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"] = Model.EnumElement(name=u"xxx",
+                                              internal_name=u"val_1")
+        elements2[u"yyy"] = Model.EnumElement(name=u"yyy",
+                                              internal_name=u"val_2",
+                                              value=u"100")
+        elements2[u"zzz"] = Model.EnumElement(name=u"val_3")
+
+        enum2 = Model.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_normalize_multiline_comments(self):
+        """Test normalization of the multiline comments.
+
+        Verifies correct normalization of the multiline comments.
+
+        """
+        generator = SmartFactoryBase.CodeGenerator()
+
+        self.assertEqual(generator._normalize_multiline_comments([]), [])
+
+        self.assertEqual(generator._normalize_multiline_comments(["aaa",
+                                                                  "bbb",
+                                                                  "ccc ccc",
+                                                                  "ddd\tddd"]),
+                         ["aaa", "bbb", "ccc ccc", "ddd\tddd"])
+        self.assertEqual(generator._normalize_multiline_comments(["aaa\n1",
+                                                                  "bbb\r\n2",
+                                                                  "ccc\r3",
+                                                                  "aaa aaa"]),
+                         ["aaa", "1", "bbb", "2", "ccc", "3", "aaa aaa"])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py
new file mode 100755
index 0000000000..b21e320038
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py
@@ -0,0 +1,482 @@
+"""Test for JSONRPC SmartFactory generator.
+
+Verifies format specific functions and produced source code.
+
+"""
+import collections
+import codecs
+import os
+import unittest
+import uuid
+
+from mock import MagicMock
+from mock import call
+
+from generator.generators import SmartFactoryJSONRPC
+from generator import Model
+
+
+EXPECTED_RESULT_REQUEST = (
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<FunctionID::eType>::create("""
+    u"""function_id_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<messageType::eType>::create("""
+    u"""message_type_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+)
+
+EXPECTED_RESULT_RESPONSE = (
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<FunctionID::eType>::create("""
+    u"""function_id_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<messageType::eType>::create("""
+    u"""message_type_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::kCode] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+)
+
+EXPECTED_RESULT_NOTIFICATION = (
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<FunctionID::eType>::create("""
+    u"""function_id_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<messageType::eType>::create("""
+    u"""message_type_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+)
+
+EXPECTED_PRE_FUNCTION_CODE = (
+    u"""  std::map<std::string, CObjectSchemaItem::SMember> """
+    u"""params_members;\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<FunctionID::eType>::create("""
+    u"""function_id_items), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<messageType::eType>::create("""
+    u"""message_type_items), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler"""
+    u"""::strings::kCode] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::kMessage] = CObjectSchemaItem::SMember("""
+    u"""CStringSchemaItem::create(), true);\n"""
+    u"""\n"""
+    u"""  std::map<std::string, CObjectSchemaItem::SMember> """
+    u"""root_members_map;\n"""
+    u"""  root_members_map[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PARAMS] = CObjectSchemaItem::SMember("""
+    u"""CObjectSchemaItem::create(params_members), true);\n"""
+    u"""\n"""
+    u"""  CSmartSchema error_response_schema(CObjectSchemaItem::create("""
+    u"""root_members_map));\n"""
+    u"""\n"""
+    u"""  functions_schemes_.insert(std::make_pair("""
+    u"""NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<"""
+    u"""FunctionID::eType, messageType::eType>("""
+    u"""FunctionID::request, messageType::error_response)"""
+    u""", error_response_schema));\n"""
+    u"""\n"""
+)
+
+DESCRIPTION = [u"Description Line1", u"Description Line2"]
+
+DESIGN_DESCRIPTION = [u"Design Line1"]
+
+ISSUES = [Model.Issue(value=u"Issue1"),
+          Model.Issue(value=u"Issue2"),
+          Model.Issue(value=u"Issue3")]
+
+TODOS = [u"Do1", u"Do2"]
+
+
+class Test(unittest.TestCase):
+
+    """Test for JSONRPC SmartFactory generator.
+
+    This class holds set of test cases for the JSONRPC SmartFactory generator.
+
+    """
+
+    def test_gen_schema_params_fill(self):
+        """Test feature that allows to create format specific PARAMS.
+
+        Verifies JSONRPC implementation of the _gen_schema_params_fill
+        method.
+
+        """
+        generator = SmartFactoryJSONRPC.CodeGenerator()
+
+        self.assertEqual(generator._gen_schema_params_fill("request"),
+                         EXPECTED_RESULT_REQUEST,
+                         "Invalid code generation for request")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"request"),
+                         EXPECTED_RESULT_REQUEST,
+                         "Invalid code generation for request")
+
+        self.assertEqual(generator._gen_schema_params_fill("response"),
+                         EXPECTED_RESULT_RESPONSE,
+                         "Invalid code generation for response")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"response"),
+                         EXPECTED_RESULT_RESPONSE,
+                         "Invalid code generation for response")
+
+        self.assertEqual(generator._gen_schema_params_fill("notification"),
+                         EXPECTED_RESULT_NOTIFICATION,
+                         "Invalid code generation for notification")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"notification"),
+                         EXPECTED_RESULT_NOTIFICATION,
+                         "Invalid code generation for notification")
+
+    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"] = Model.EnumElement(name=u"request")
+        message_type_elements[u"response"] = Model.EnumElement(
+            name=u"response")
+        message_type_elements[u"notification"] = Model.EnumElement(
+            name=u"notification")
+
+        message_type = Model.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"] = Model.EnumElement(name=u"request")
+        message_type_elements[u"notification"] = Model.EnumElement(
+            name=u"notification")
+
+        message_type = Model.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_gen_pre_function_schemas(self):
+        """Test code that goes before schema initialization.
+
+        Verifies JSONPRC implementation of the _gen_pre_function_schemas
+        function.
+
+        """
+
+        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"] = Model.EnumElement(name=u"request")
+        message_type_elements[u"response"] = Model.EnumElement(
+            name=u"response")
+        message_type_elements[u"notification"] = Model.EnumElement(
+            name=u"notification")
+
+        message_type = Model.Enum(name=u"messageType",
+                                  elements=message_type_elements)
+
+        function1 = Model.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 = Model.Function(
+            "func2", function_id=message_type.elements[u"request"],
+            message_type=message_type.elements[u"response"])
+
+        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")
+
+    def test_full_generation(self):
+        """Test full generation using JSONRPC SmartSchema generator.
+
+        Creates output files which is captured by the mock and compare them
+        with sample files with correct code. This test requires valid
+        test_expected_jsonrpc.h and test_expected_jsonrpc.cc in the same
+        directory as this module.
+
+        """
+
+        expected_h_file_content = open("test_expected_jsonrpc.h", "r").read()
+        expected_cc_file_content = open("test_expected_jsonrpc.cc", "r").read()
+
+        generator = SmartFactoryJSONRPC.CodeGenerator()
+
+        message_type_elements = collections.OrderedDict()
+        message_type_elements[u"request"] = Model.EnumElement(name=u"request")
+        message_type_elements[u"response"] = Model.EnumElement(
+            name=u"response")
+        message_type_elements[u"notification"] = Model.EnumElement(
+            name=u"notification")
+
+        message_type = Model.Enum(name=u"messageType",
+                                  elements=message_type_elements)
+
+        elements1 = collections.OrderedDict()
+        elements1[u"name1"] = Model.EnumElement(
+            name=u"name1",
+            design_description=DESIGN_DESCRIPTION,
+            todos=TODOS,
+            value=u"1")
+        elements1[u"name2"] = Model.EnumElement(
+            name="name2",
+            description=DESCRIPTION,
+            issues=ISSUES,
+            internal_name=u"internal_name2")
+
+        enum1 = Model.Enum(name=u"Enum1",
+                           todos=TODOS,
+                           elements=elements1)
+
+        elements2 = collections.OrderedDict()
+        elements2[u"xxx"] = Model.EnumElement(name=u"xxx",
+                                              internal_name=u"val_1")
+        elements2[u"yyy"] = Model.EnumElement(name=u"yyy",
+                                              internal_name=u"val_2",
+                                              value=u"100")
+        elements2[u"zzz"] = Model.EnumElement(name=u"val_3")
+
+        enum2 = Model.Enum(name=u"E2",
+                           elements=elements2)
+
+        elements3 = collections.OrderedDict()
+        elements3["1"] = Model.EnumElement(name="xxx",
+                                           internal_name="_1")
+        elements3["2"] = Model.EnumElement(name="xxx",
+                                           internal_name="_2")
+        elements3["3"] = Model.EnumElement(name="xxx",
+                                           internal_name="_3")
+        enum3 = Model.Enum(name="Enum_new2",
+                           elements=elements3)
+
+        elements4 = collections.OrderedDict()
+        elements4["name1"] = Model.EnumElement(name="xxx",
+                                               internal_name="_11")
+        elements4["name2"] = Model.EnumElement(name="xxx",
+                                               internal_name="_22")
+        enum4 = Model.Enum(name="Enum_new4",
+                           elements=elements4)
+
+        enums = collections.OrderedDict()
+        enums["Enum1"] = enum1
+        enums["Enum2"] = enum2
+        enums["Enum3"] = enum3
+        enums["Enum4"] = enum4
+        enums["messageType"] = message_type
+
+        params1 = collections.OrderedDict()
+        params1["1"] = Model.FunctionParam(
+            name="param1",
+            design_description=DESIGN_DESCRIPTION,
+            description=DESCRIPTION,
+            issues=ISSUES,
+            todos=TODOS,
+            param_type=enum4,
+            default_value=elements4["name1"])
+        params1["2"] = Model.FunctionParam(
+            name="param2",
+            param_type=Model.EnumSubset(
+                name="sub1",
+                enum=enum1,
+                allowed_elements={"e1": elements1["name1"]}),
+            default_value=elements1["name1"])
+
+        functions = collections.OrderedDict()
+        functions["Function1"] = Model.Function(
+            name="Function1",
+            function_id=elements1["name1"],
+            message_type=message_type_elements["request"],
+            params=params1)
+        functions["Function2"] = Model.Function(
+            name="Function2",
+            function_id=elements2["xxx"],
+            message_type=message_type_elements["response"])
+        functions["Function3"] = Model.Function(
+            name="Function2",
+            function_id=elements2["yyy"],
+            message_type=message_type_elements["notification"])
+
+        members1 = collections.OrderedDict()
+        members1["m1"] = Model.Param(name="intParam",
+                                     param_type=Model.Integer(max_value=2))
+        members1["m11"] = Model.Param(name="doubleParam",
+                                      param_type=Model.Double(min_value=0.333),
+                                      is_mandatory=False)
+        members1["m222"] = Model.Param(name="boolParam",
+                                       param_type=Model.Boolean())
+        members1["m2"] = Model.Param(name="structParam",
+                                     param_type=Model.Struct(name="Struct2"))
+        members1["aaa"] = Model.Param(name="enumParam",
+                                      param_type=enum1)
+        members1["bbb"] = Model.Param(name="enumParam1",
+                                      param_type=enum1)
+        members1["xxx"] = Model.Param(
+            name="enumSubset1",
+            param_type=Model.EnumSubset(
+                name="sub",
+                enum=enum1,
+                allowed_elements={"e1": elements1["name1"]}),
+            is_mandatory=False)
+        members1["1"] = Model.Param(
+            name="arrayOfInt",
+            param_type=Model.Array(min_size=0,
+                                   max_size=20,
+                                   element_type=Model.Boolean()),
+            is_mandatory=False)
+        members1["2"] = Model.Param(
+            name="arrayOfEnum1",
+            param_type=Model.Array(min_size=0,
+                                   max_size=20,
+                                   element_type=enum1),
+            is_mandatory=False)
+        members1["3"] = Model.Param(
+            name="arrayOfEnum3",
+            param_type=Model.Array(min_size=10,
+                                   max_size=40,
+                                   element_type=enum3),
+            is_mandatory=True)
+        members1["4"] = Model.Param(
+            name="arrayOfEnum4",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=41,
+                element_type=Model.EnumSubset(
+                    name="sub1",
+                    enum=enum1,
+                    allowed_elements={"e1": elements1["name1"]})))
+        members1["5"] = Model.Param(
+            name="arrayOfEnum5",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=42,
+                element_type=Model.EnumSubset(
+                    name="sub2",
+                    enum=enum1,
+                    allowed_elements={"e1": elements1["name2"]})))
+        members1["6"] = Model.Param(
+            name="arrayOfEnum6",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=43,
+                element_type=Model.EnumSubset(
+                    name="sub3",
+                    enum=enum4,
+                    allowed_elements={"e1": elements4["name2"]})))
+
+        structs = collections.OrderedDict()
+        structs["Struct1"] = Model.Struct(
+            name="Struct1",
+            design_description=DESIGN_DESCRIPTION,
+            issues=ISSUES,
+            members=members1)
+        structs["Struct2"] = Model.Struct(name="Struct2",
+                                          issues=ISSUES)
+
+        interface = Model.Interface(enums=enums,
+                                    structs=structs,
+                                    functions=functions,
+                                    params={"param1": "value1",
+                                            "param2": "value2"})
+
+        os.path.exists = MagicMock(return_value=True)
+        uuid.uuid1 = MagicMock(
+            return_value=uuid.UUID("12345678123456781234567812345678"))
+        codecs.open = MagicMock()
+
+        generator.generate(interface=interface,
+                           filename="Test.xml",
+                           namespace="XXX::YYY::ZZZ",
+                           destination_dir="/some/test/dir")
+
+        os.path.exists.assert_has_calls([call('/some/test/dir')])
+
+        open_result = codecs.open
+        mock_calls = open_result.mock_calls
+
+        self.assertEqual(mock_calls[0],
+                         call('/some/test/dir/Test.h',
+                              mode='w',
+                              encoding='utf-8'),
+                         "Invalid header file creation")
+
+        self.assertEqual(mock_calls[4],
+                         call('/some/test/dir/Test.cc',
+                              mode='w',
+                              encoding='utf-8'),
+                         "Invalid source file creation")
+
+        self.assertEqual(str(mock_calls[2])[27:-2].replace("\\n", "\n"),
+                         expected_h_file_content,
+                         "Invalid header file content")
+
+        self.assertEqual(str(mock_calls[6])[27:-2].replace("\\n", "\n"),
+                         expected_cc_file_content,
+                         "Invalid source file content")
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py
new file mode 100755
index 0000000000..111ffb3cbc
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py
@@ -0,0 +1,325 @@
+"""Test for SDLRPC SmartFactory generator.
+
+Verifies format specific functions and produced source code.
+
+"""
+import collections
+import codecs
+import os
+import unittest
+import uuid
+
+from mock import MagicMock
+from mock import call
+
+from generator.generators import SmartFactorySDLRPC
+from generator import Model
+
+
+EXPECTED_NOTIFICATION_RESULT = (
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<FunctionID::eType>::create("""
+    u"""function_id_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<messageType::eType>::create("""
+    u"""message_type_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n""")
+
+EXPECTED_REQ_RESP_RESULT = "".join([EXPECTED_NOTIFICATION_RESULT, (
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n""")])
+
+DESCRIPTION = [u"Description Line1", u"Description Line2"]
+
+DESIGN_DESCRIPTION = [u"Design Line1"]
+
+ISSUES = [Model.Issue(value=u"Issue1"),
+          Model.Issue(value=u"Issue2"),
+          Model.Issue(value=u"Issue3")]
+
+TODOS = [u"Do1", u"Do2"]
+
+
+class Test(unittest.TestCase):
+
+    """Test for SLDRPC SmartFactory generator.
+
+    This class holds set of test cases for the SDLRPC SmartFactory generator.
+
+    """
+
+    def test_gen_schema_params_fill(self):
+        """Test feature that allows to create format specific PARAMS.
+
+        Verifies SDLRPC implementation of the _gen_schema_params_fill
+        method.
+
+        """
+
+        generator = SmartFactorySDLRPC.CodeGenerator()
+
+        self.assertEqual(generator._gen_schema_params_fill("request"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation for request")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"request"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation for request")
+
+        self.assertEqual(generator._gen_schema_params_fill("response"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation for response")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"response"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation for response")
+
+        self.assertEqual(generator._gen_schema_params_fill("notification"),
+                         EXPECTED_NOTIFICATION_RESULT,
+                         "Invalid code generation for notification")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"notification"),
+                         EXPECTED_NOTIFICATION_RESULT,
+                         "Invalid code generation for notification")
+
+        self.assertEqual(generator._gen_schema_params_fill("some text"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"some text"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation")
+
+    def test_full_generation(self):
+        """Test full generation using SDLPRC SmartSchema generator.
+
+        Creates output files which is captured by the mock and compare them
+        with sample files with correct code. This test requires valid
+        test_expected_sdlrpc.h and test_expected_sdlrpc.cc in the same as
+        this module.
+
+        """
+
+        expected_h_file_content = open("test_expected_sdlrpc.h", "r").read()
+        expected_cc_file_content = open("test_expected_sdlrpc.cc", "r").read()
+
+        generator = SmartFactorySDLRPC.CodeGenerator()
+
+        message_type_elements = collections.OrderedDict()
+        message_type_elements[u"request"] = Model.EnumElement(name=u"request")
+        message_type_elements[u"response"] = Model.EnumElement(
+            name=u"response")
+        message_type_elements[u"notification"] = Model.EnumElement(
+            name=u"notification")
+
+        message_type = Model.Enum(name=u"messageType",
+                                  elements=message_type_elements)
+
+        elements1 = collections.OrderedDict()
+        elements1[u"name1"] = Model.EnumElement(
+            name=u"name1",
+            design_description=DESIGN_DESCRIPTION,
+            todos=TODOS,
+            value=u"1")
+        elements1[u"name2"] = Model.EnumElement(
+            name="name2",
+            description=DESCRIPTION,
+            issues=ISSUES,
+            internal_name=u"internal_name2")
+
+        enum1 = Model.Enum(name=u"Enum1",
+                           todos=TODOS,
+                           elements=elements1)
+
+        elements2 = collections.OrderedDict()
+        elements2[u"xxx"] = Model.EnumElement(name=u"xxx",
+                                              internal_name=u"val_1")
+        elements2[u"yyy"] = Model.EnumElement(name=u"yyy",
+                                              internal_name=u"val_2",
+                                              value=u"100")
+        elements2[u"zzz"] = Model.EnumElement(name=u"val_3")
+
+        enum2 = Model.Enum(name=u"E2",
+                           elements=elements2)
+
+        elements3 = collections.OrderedDict()
+        elements3["1"] = Model.EnumElement(name="xxx",
+                                           internal_name="_1")
+        elements3["2"] = Model.EnumElement(name="xxx",
+                                           internal_name="_2")
+        elements3["3"] = Model.EnumElement(name="xxx",
+                                           internal_name="_3")
+        enum3 = Model.Enum(name="Enum_new2",
+                           elements=elements3)
+
+        elements4 = collections.OrderedDict()
+        elements4["name1"] = Model.EnumElement(name="xxx",
+                                               internal_name="_11")
+        elements4["name2"] = Model.EnumElement(name="xxx",
+                                               internal_name="_22")
+        enum4 = Model.Enum(name="Enum_new4",
+                           elements=elements4)
+
+        enums = collections.OrderedDict()
+        enums["Enum1"] = enum1
+        enums["Enum2"] = enum2
+        enums["Enum3"] = enum3
+        enums["Enum4"] = enum4
+        enums["messageType"] = message_type
+
+        params1 = collections.OrderedDict()
+        params1["1"] = Model.FunctionParam(
+            name="param1",
+            design_description=DESIGN_DESCRIPTION,
+            description=DESCRIPTION,
+            issues=ISSUES,
+            todos=TODOS,
+            param_type=enum4,
+            default_value=elements4["name1"])
+        params1["2"] = Model.FunctionParam(
+            name="param2",
+            param_type=Model.EnumSubset(
+                name="sub1",
+                enum=enum1,
+                allowed_elements={"e1": elements1["name1"]}),
+            default_value=elements1["name1"])
+
+        functions = collections.OrderedDict()
+        functions["Function1"] = Model.Function(
+            name="Function1",
+            function_id=elements1["name1"],
+            message_type=message_type_elements["request"],
+            params=params1)
+        functions["Function2"] = Model.Function(
+            name="Function2",
+            function_id=elements2["xxx"],
+            message_type=message_type_elements["response"])
+        functions["Function3"] = Model.Function(
+            name="Function2",
+            function_id=elements2["yyy"],
+            message_type=message_type_elements["notification"])
+
+        members1 = collections.OrderedDict()
+        members1["m1"] = Model.Param(name="intParam",
+                                     param_type=Model.Integer(max_value=2))
+        members1["m11"] = Model.Param(name="doubleParam",
+                                      param_type=Model.Double(min_value=0.333),
+                                      is_mandatory=False)
+        members1["m222"] = Model.Param(name="boolParam",
+                                       param_type=Model.Boolean())
+        members1["m2"] = Model.Param(name="structParam",
+                                     param_type=Model.Struct(name="Struct2"))
+        members1["aaa"] = Model.Param(name="enumParam",
+                                      param_type=enum1)
+        members1["bbb"] = Model.Param(name="enumParam1",
+                                      param_type=enum1)
+        members1["xxx"] = Model.Param(
+            name="enumSubset1",
+            param_type=Model.EnumSubset(
+                name="sub",
+                enum=enum1,
+                allowed_elements={"e1": elements1["name1"]}),
+            is_mandatory=False)
+        members1["1"] = Model.Param(
+            name="arrayOfInt",
+            param_type=Model.Array(min_size=0,
+                                   max_size=20,
+                                   element_type=Model.Boolean()),
+            is_mandatory=False)
+        members1["2"] = Model.Param(
+            name="arrayOfEnum1",
+            param_type=Model.Array(min_size=0,
+                                   max_size=20,
+                                   element_type=enum1),
+            is_mandatory=False)
+        members1["3"] = Model.Param(
+            name="arrayOfEnum3",
+            param_type=Model.Array(min_size=10,
+                                   max_size=40,
+                                   element_type=enum3),
+            is_mandatory=True)
+        members1["4"] = Model.Param(
+            name="arrayOfEnum4",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=41,
+                element_type=Model.EnumSubset(
+                    name="sub1",
+                    enum=enum1,
+                    allowed_elements={"e1": elements1["name1"]})))
+        members1["5"] = Model.Param(
+            name="arrayOfEnum5",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=42,
+                element_type=Model.EnumSubset(
+                    name="sub2",
+                    enum=enum1,
+                    allowed_elements={"e1": elements1["name2"]})))
+        members1["6"] = Model.Param(
+            name="arrayOfEnum6",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=43,
+                element_type=Model.EnumSubset(
+                    name="sub3",
+                    enum=enum4,
+                    allowed_elements={"e1": elements4["name2"]})))
+
+        structs = collections.OrderedDict()
+        structs["Struct1"] = Model.Struct(
+            name="Struct1",
+            design_description=DESIGN_DESCRIPTION,
+            issues=ISSUES,
+            members=members1)
+        structs["Struct2"] = Model.Struct(name="Struct2",
+                                          issues=ISSUES)
+
+        interface = Model.Interface(enums=enums,
+                                    structs=structs,
+                                    functions=functions,
+                                    params={"param1": "value1",
+                                            "param2": "value2"})
+
+        os.path.exists = MagicMock(return_value=True)
+        uuid.uuid1 = MagicMock(
+            return_value=uuid.UUID("12345678123456781234567812345678"))
+        codecs.open = MagicMock()
+
+        generator.generate(interface=interface,
+                           filename="Test.xml",
+                           namespace="XXX::YYY::ZZZ",
+                           destination_dir="/some/test/dir")
+
+        os.path.exists.assert_has_calls([call('/some/test/dir')])
+
+        open_result = codecs.open
+        mock_calls = open_result.mock_calls
+
+        self.assertEqual(mock_calls[0],
+                         call('/some/test/dir/Test.h',
+                              mode='w',
+                              encoding='utf-8'),
+                         "Invalid header file creation")
+
+        self.assertEqual(mock_calls[4],
+                         call('/some/test/dir/Test.cc',
+                              mode='w',
+                              encoding='utf-8'),
+                         "Invalid source file creation")
+
+        self.assertEqual(str(mock_calls[2])[27:-2].replace("\\n", "\n"),
+                         expected_h_file_content,
+                         "Invalid header file content")
+
+        self.assertEqual(str(mock_calls[6])[27:-2].replace("\\n", "\n"),
+                         expected_cc_file_content,
+                         "Invalid source file content")
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.cc b/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.cc
new file mode 100644
index 0000000000..458c27543b
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.cc
@@ -0,0 +1,385 @@
+/**
+ * @file Test.cc
+ * @brief Generated class Test source file.
+ *
+ * This class is a part of SmartObjects solution. It provides
+ * factory functionallity which allows client to use SmartSchemas
+ * in accordance with definitions from Test.xml file
+ */
+// Copyright (c) 2013, Ford Motor Company
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+//
+// Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following
+// disclaimer in the documentation and/or other materials provided with the
+// distribution.
+//
+// Neither the name of the Ford Motor Company nor the names of its contributors
+// may be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#include <map>
+#include <set>
+
+#include "Test.h"
+#include "SmartObjects/CAlwaysTrueSchemaItem.hpp"
+#include "SmartObjects/CAlwaysFalseSchemaItem.hpp"
+#include "SmartObjects/CArraySchemaItem.hpp"
+#include "SmartObjects/CBoolSchemaItem.hpp"
+#include "SmartObjects/CObjectSchemaItem.hpp"
+#include "SmartObjects/CStringSchemaItem.hpp"
+#include "SmartObjects/TEnumSchemaItem.hpp"
+#include "SmartObjects/TNumberSchemaItem.hpp"
+#include "SmartObjects/TSchemaItemParameter.hpp"
+
+using namespace NsSmartDeviceLink::NsSmartObjects;
+
+XXX::YYY::ZZZ::Test::Test()
+ : CSmartFactory<FunctionID::eType, messageType::eType, StructIdentifiers::eType>() {
+  TStructsSchemaItems struct_schema_items;
+  InitStructSchemes(struct_schema_items);
+
+  std::set<FunctionID::eType> function_id_items;
+
+
+  std::set<messageType::eType> message_type_items;
+  message_type_items.insert(messageType::request);
+  message_type_items.insert(messageType::response);
+  message_type_items.insert(messageType::notification);
+  message_type_items.insert(messageType::error_response);
+
+  InitFunctionSchemes(struct_schema_items, function_id_items, message_type_items);
+}
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::ProvideObjectSchemaItemForStruct(
+    const TStructsSchemaItems &struct_schema_items,
+    const StructIdentifiers::eType struct_id) {
+  const TStructsSchemaItems::const_iterator it = struct_schema_items.find(struct_id);
+  if (it != struct_schema_items.end()) {
+    return it->second;
+  }
+
+  return NsSmartDeviceLink::NsSmartObjects::CAlwaysFalseSchemaItem::create();
+}
+
+void XXX::YYY::ZZZ::Test::InitStructSchemes(
+    TStructsSchemaItems &struct_schema_items) {
+  TSharedPtr<ISchemaItem> struct_schema_item_Struct2 = InitStructSchemaItem_Struct2(struct_schema_items);
+  struct_schema_items.insert(std::make_pair(StructIdentifiers::Struct2, struct_schema_item_Struct2));
+  structs_schemes_.insert(std::make_pair(StructIdentifiers::Struct2, CSmartSchema(struct_schema_item_Struct2)));
+
+  TSharedPtr<ISchemaItem> struct_schema_item_Struct1 = InitStructSchemaItem_Struct1(struct_schema_items);
+  struct_schema_items.insert(std::make_pair(StructIdentifiers::Struct1, struct_schema_item_Struct1));
+  structs_schemes_.insert(std::make_pair(StructIdentifiers::Struct1, CSmartSchema(struct_schema_item_Struct1)));
+}
+
+void XXX::YYY::ZZZ::Test::InitFunctionSchemes(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::kCode] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::kMessage] = CObjectSchemaItem::SMember(CStringSchemaItem::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  CSmartSchema error_response_schema(CObjectSchemaItem::create(root_members_map));
+
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::val_1, messageType::error_response), error_response_schema));
+
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::name1, messageType::request), InitFunction_name1_request(struct_schema_items, function_id_items, message_type_items)));
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::val_1, messageType::response), InitFunction_val_1_response(struct_schema_items, function_id_items, message_type_items)));
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::val_2, messageType::notification), InitFunction_val_2_notification(struct_schema_items, function_id_items, message_type_items)));
+}
+
+//------------- Functions schemes initialization -------------
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_name1_request(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::set<Enum_new4::eType> Enum_new4_all_enum_values;
+  Enum_new4_all_enum_values.insert(Enum_new4::_11);
+  Enum_new4_all_enum_values.insert(Enum_new4::_22);
+
+  std::set<Enum1::eType> param2_allowed_enum_subset_values;
+  param2_allowed_enum_subset_values.insert(Enum1::name1);
+
+  // Function parameter param1.
+  //
+  // Description Line1
+  // Description Line2
+  //
+  // Design Line1
+  //
+  // Note: Issue1
+  // Note: Issue2
+  // Note: Issue3
+  //
+  // ToDo: Do1
+  // ToDo: Do2
+  TSharedPtr<ISchemaItem> param1_SchemaItem = TEnumSchemaItem<Enum_new4::eType>::create(Enum_new4_all_enum_values, TSchemaItemParameter<Enum_new4::eType>(Enum_new4::_11));
+
+  // Function parameter param2.
+  TSharedPtr<ISchemaItem> param2_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(param2_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>(name1));
+
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  schema_members["param1"] = CObjectSchemaItem::SMember(param1_SchemaItem, true);
+  schema_members["param2"] = CObjectSchemaItem::SMember(param2_SchemaItem, true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_1_response(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::kCode] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_2_notification(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+//----------- Structs schema items initialization ------------
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct1(
+    const TStructsSchemaItems &struct_schema_items) {
+  std::set<Enum1::eType> Enum1_all_enum_values;
+  Enum1_all_enum_values.insert(Enum1::name1);
+  Enum1_all_enum_values.insert(Enum1::internal_name2);
+
+  std::set<Enum1::eType> enumSubset1_allowed_enum_subset_values;
+  enumSubset1_allowed_enum_subset_values.insert(Enum1::name1);
+
+  std::set<Enum_new2::eType> Enum_new2_all_enum_values;
+  Enum_new2_all_enum_values.insert(Enum_new2::_1);
+  Enum_new2_all_enum_values.insert(Enum_new2::_2);
+  Enum_new2_all_enum_values.insert(Enum_new2::_3);
+
+  std::set<Enum1::eType> sub1_allowed_enum_subset_values;
+  sub1_allowed_enum_subset_values.insert(Enum1::name1);
+
+  std::set<Enum1::eType> sub2_allowed_enum_subset_values;
+  sub2_allowed_enum_subset_values.insert(Enum1::internal_name2);
+
+  std::set<Enum_new4::eType> sub3_allowed_enum_subset_values;
+  sub3_allowed_enum_subset_values.insert(Enum_new4::_22);
+
+  // Struct member intParam.
+  TSharedPtr<ISchemaItem> intParam_SchemaItem = TNumberSchemaItem<int>::create(TSchemaItemParameter<int>(), TSchemaItemParameter<int>(2), TSchemaItemParameter<int>());
+
+  // Struct member doubleParam.
+  TSharedPtr<ISchemaItem> doubleParam_SchemaItem = TNumberSchemaItem<double>::create(TSchemaItemParameter<double>(0.333), TSchemaItemParameter<double>(), TSchemaItemParameter<double>());
+
+  // Struct member boolParam.
+  TSharedPtr<ISchemaItem> boolParam_SchemaItem = CBoolSchemaItem::create(TSchemaItemParameter<bool>());
+
+  // Struct member structParam.
+  TSharedPtr<ISchemaItem> structParam_SchemaItem = ProvideObjectSchemaItemForStruct(struct_schema_items, StructIdentifiers::Struct2);
+
+  // Struct member enumParam.
+  TSharedPtr<ISchemaItem> enumParam_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member enumParam1.
+  TSharedPtr<ISchemaItem> enumParam1_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member enumSubset1.
+  TSharedPtr<ISchemaItem> enumSubset1_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(enumSubset1_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member arrayOfInt.
+  TSharedPtr<ISchemaItem> arrayOfInt_SchemaItem = CArraySchemaItem::create(CBoolSchemaItem::create(TSchemaItemParameter<bool>()), TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(20));
+
+  // Struct member arrayOfEnum1.
+  TSharedPtr<ISchemaItem> arrayOfEnum1_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(20));
+
+  // Struct member arrayOfEnum3.
+  TSharedPtr<ISchemaItem> arrayOfEnum3_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum_new2::eType>::create(Enum_new2_all_enum_values, TSchemaItemParameter<Enum_new2::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(40));
+
+  // Struct member arrayOfEnum4.
+  TSharedPtr<ISchemaItem> arrayOfEnum4_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(sub1_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(41));
+
+  // Struct member arrayOfEnum5.
+  TSharedPtr<ISchemaItem> arrayOfEnum5_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(sub2_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(42));
+
+  // Struct member arrayOfEnum6.
+  TSharedPtr<ISchemaItem> arrayOfEnum6_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum_new4::eType>::create(sub3_allowed_enum_subset_values, TSchemaItemParameter<Enum_new4::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(43));
+
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  schema_members["intParam"] = CObjectSchemaItem::SMember(intParam_SchemaItem, true);
+  schema_members["doubleParam"] = CObjectSchemaItem::SMember(doubleParam_SchemaItem, false);
+  schema_members["boolParam"] = CObjectSchemaItem::SMember(boolParam_SchemaItem, true);
+  schema_members["structParam"] = CObjectSchemaItem::SMember(structParam_SchemaItem, true);
+  schema_members["enumParam"] = CObjectSchemaItem::SMember(enumParam_SchemaItem, true);
+  schema_members["enumParam1"] = CObjectSchemaItem::SMember(enumParam1_SchemaItem, true);
+  schema_members["enumSubset1"] = CObjectSchemaItem::SMember(enumSubset1_SchemaItem, false);
+  schema_members["arrayOfInt"] = CObjectSchemaItem::SMember(arrayOfInt_SchemaItem, false);
+  schema_members["arrayOfEnum1"] = CObjectSchemaItem::SMember(arrayOfEnum1_SchemaItem, false);
+  schema_members["arrayOfEnum3"] = CObjectSchemaItem::SMember(arrayOfEnum3_SchemaItem, true);
+  schema_members["arrayOfEnum4"] = CObjectSchemaItem::SMember(arrayOfEnum4_SchemaItem, true);
+  schema_members["arrayOfEnum5"] = CObjectSchemaItem::SMember(arrayOfEnum5_SchemaItem, true);
+  schema_members["arrayOfEnum6"] = CObjectSchemaItem::SMember(arrayOfEnum6_SchemaItem, true);
+
+  return CObjectSchemaItem::create(schema_members);
+}
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct2(
+    const TStructsSchemaItems &struct_schema_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  return CObjectSchemaItem::create(schema_members);
+}
+
+//-------------- String to value enum mapping ----------------
+
+namespace NsSmartDeviceLink {
+namespace NsSmartObjects {
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum1::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum1::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum1::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum1::name1, "name1"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum1::internal_name2, "name2"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::E2::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::E2::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::E2::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_1, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_2, "yyy"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_3, "val_3"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum_new2::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum_new2::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum_new2::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_1, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_2, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_3, "xxx"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum_new4::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum_new4::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum_new4::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new4::_11, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new4::_22, "xxx"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::messageType::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::messageType::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::messageType::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::request, "request"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::response, "response"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::notification, "notification"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::error_response, "error_response"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+} // NsSmartObjects
+} // NsSmartDeviceLink
+
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.h b/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.h
new file mode 100644
index 0000000000..b265603480
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.h
@@ -0,0 +1,326 @@
+/**
+ * @file Test.h
+ * @brief Generated class Test header file.
+ *
+ * This class is a part of SmartObjects solution. It provides
+ * factory functionallity which allows client to use SmartSchemas
+ * in accordance with definitions from Test.xml file
+ */
+// Copyright (c) 2013, Ford Motor Company
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+//
+// Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following
+// disclaimer in the documentation and/or other materials provided with the
+// distribution.
+//
+// Neither the name of the Ford Motor Company nor the names of its contributors
+// may be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef __CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+#define __CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+
+#include "JSONHandler/CSmartFactory.hpp"
+#include "SmartObjects/CSmartSchema.hpp"
+#include "SmartObjects/ISchemaItem.hpp"
+#include "SmartObjects/TSharedPtr.hpp"
+
+namespace XXX {
+namespace YYY {
+namespace ZZZ {
+
+namespace StructIdentifiers {
+/**
+ * @brief Enumeration StructIdentifiers.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief Struct1.
+   */
+  Struct1,
+
+  /**
+   * @brief Struct2.
+   */
+  Struct2
+};
+} // StructIdentifiers
+
+namespace Enum1 {
+/**
+ * @brief Enumeration Enum1.
+ *
+ * @todo Do1
+ * @todo Do2
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief name1.
+   *
+   * Design Line1
+   *
+   * @todo Do1
+   * @todo Do2
+   */
+  name1 = 1,
+
+  /**
+   * @brief internal_name2.
+   *
+   * Description Line1
+   * Description Line2
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  internal_name2
+};
+} // Enum1
+
+namespace E2 {
+/**
+ * @brief Enumeration E2.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief val_1.
+   */
+  val_1,
+
+  /**
+   * @brief val_2.
+   */
+  val_2 = 100,
+
+  /**
+   * @brief val_3.
+   */
+  val_3
+};
+} // E2
+
+namespace Enum_new2 {
+/**
+ * @brief Enumeration Enum_new2.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief _1.
+   */
+  _1,
+
+  /**
+   * @brief _2.
+   */
+  _2,
+
+  /**
+   * @brief _3.
+   */
+  _3
+};
+} // Enum_new2
+
+namespace Enum_new4 {
+/**
+ * @brief Enumeration Enum_new4.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief _11.
+   */
+  _11,
+
+  /**
+   * @brief _22.
+   */
+  _22
+};
+} // Enum_new4
+
+namespace messageType {
+/**
+ * @brief Enumeration messageType.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief request.
+   */
+  request,
+
+  /**
+   * @brief response.
+   */
+  response,
+
+  /**
+   * @brief notification.
+   */
+  notification,
+
+  /**
+   * @brief error_response.
+   */
+  error_response
+};
+} // messageType
+
+
+/**
+ * @brief Class Test.
+ *
+ * Params:
+ *     param2 - value2
+ *     param1 - value1
+ */
+class Test : public NsSmartDeviceLink::NsJSONHandler::CSmartFactory<FunctionID::eType, messageType::eType, StructIdentifiers::eType> {
+ public:
+  /**
+   * @brief Constructor.
+   */
+  Test();
+
+ protected:
+  /**
+   * @brief Type that maps of struct IDs to schema items.
+   */
+  typedef std::map<const StructIdentifiers::eType, NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> > TStructsSchemaItems;
+
+  /**
+   * @brief Helper that allows to make reference to struct
+   *
+   * @param struct_schema_items Struct schema items.
+   * @param struct_id ID of structure to provide.
+   *
+   * @return TSharedPtr of strucute
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> ProvideObjectSchemaItemForStruct(
+        const TStructsSchemaItems &struct_schema_items,
+        const StructIdentifiers::eType struct_id);
+
+  /**
+   * @brief Initializes all struct schemes.
+   */
+  void InitStructSchemes(TStructsSchemaItems &struct_schema_items);
+
+  /**
+   * @brief Initializes all function schemes.
+   *
+   * @param struct_schema_items Struct schema items.
+   * @param function_id_items Set of all elements of FunctionID enum.
+   * @param message_type_items Set of all elements of messageType enum.
+   */
+  void InitFunctionSchemes(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function1.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_name1_request(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function2.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_val_1_response(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function2.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_val_2_notification(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema item for structure Struct1.
+   *
+   * Design Line1
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> InitStructSchemaItem_Struct1(
+      const TStructsSchemaItems &struct_schema_items);
+
+  /**
+   * @brief Method that generates schema item for structure Struct2.
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> InitStructSchemaItem_Struct2(
+      const TStructsSchemaItems &struct_schema_items);
+};
+
+} // XXX
+} // YYY
+} // ZZZ
+
+#endif //__CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.cc b/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.cc
new file mode 100644
index 0000000000..53e5b7f78a
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.cc
@@ -0,0 +1,366 @@
+/**
+ * @file Test.cc
+ * @brief Generated class Test source file.
+ *
+ * This class is a part of SmartObjects solution. It provides
+ * factory functionallity which allows client to use SmartSchemas
+ * in accordance with definitions from Test.xml file
+ */
+// Copyright (c) 2013, Ford Motor Company
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+//
+// Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following
+// disclaimer in the documentation and/or other materials provided with the
+// distribution.
+//
+// Neither the name of the Ford Motor Company nor the names of its contributors
+// may be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#include <map>
+#include <set>
+
+#include "Test.h"
+#include "SmartObjects/CAlwaysTrueSchemaItem.hpp"
+#include "SmartObjects/CAlwaysFalseSchemaItem.hpp"
+#include "SmartObjects/CArraySchemaItem.hpp"
+#include "SmartObjects/CBoolSchemaItem.hpp"
+#include "SmartObjects/CObjectSchemaItem.hpp"
+#include "SmartObjects/CStringSchemaItem.hpp"
+#include "SmartObjects/TEnumSchemaItem.hpp"
+#include "SmartObjects/TNumberSchemaItem.hpp"
+#include "SmartObjects/TSchemaItemParameter.hpp"
+
+using namespace NsSmartDeviceLink::NsSmartObjects;
+
+XXX::YYY::ZZZ::Test::Test()
+ : CSmartFactory<FunctionID::eType, messageType::eType, StructIdentifiers::eType>() {
+  TStructsSchemaItems struct_schema_items;
+  InitStructSchemes(struct_schema_items);
+
+  std::set<FunctionID::eType> function_id_items;
+
+
+  std::set<messageType::eType> message_type_items;
+  message_type_items.insert(messageType::request);
+  message_type_items.insert(messageType::response);
+  message_type_items.insert(messageType::notification);
+
+  InitFunctionSchemes(struct_schema_items, function_id_items, message_type_items);
+}
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::ProvideObjectSchemaItemForStruct(
+    const TStructsSchemaItems &struct_schema_items,
+    const StructIdentifiers::eType struct_id) {
+  const TStructsSchemaItems::const_iterator it = struct_schema_items.find(struct_id);
+  if (it != struct_schema_items.end()) {
+    return it->second;
+  }
+
+  return NsSmartDeviceLink::NsSmartObjects::CAlwaysFalseSchemaItem::create();
+}
+
+void XXX::YYY::ZZZ::Test::InitStructSchemes(
+    TStructsSchemaItems &struct_schema_items) {
+  TSharedPtr<ISchemaItem> struct_schema_item_Struct2 = InitStructSchemaItem_Struct2(struct_schema_items);
+  struct_schema_items.insert(std::make_pair(StructIdentifiers::Struct2, struct_schema_item_Struct2));
+  structs_schemes_.insert(std::make_pair(StructIdentifiers::Struct2, CSmartSchema(struct_schema_item_Struct2)));
+
+  TSharedPtr<ISchemaItem> struct_schema_item_Struct1 = InitStructSchemaItem_Struct1(struct_schema_items);
+  struct_schema_items.insert(std::make_pair(StructIdentifiers::Struct1, struct_schema_item_Struct1));
+  structs_schemes_.insert(std::make_pair(StructIdentifiers::Struct1, CSmartSchema(struct_schema_item_Struct1)));
+}
+
+void XXX::YYY::ZZZ::Test::InitFunctionSchemes(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::name1, messageType::request), InitFunction_name1_request(struct_schema_items, function_id_items, message_type_items)));
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::val_1, messageType::response), InitFunction_val_1_response(struct_schema_items, function_id_items, message_type_items)));
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::val_2, messageType::notification), InitFunction_val_2_notification(struct_schema_items, function_id_items, message_type_items)));
+}
+
+//------------- Functions schemes initialization -------------
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_name1_request(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::set<Enum_new4::eType> Enum_new4_all_enum_values;
+  Enum_new4_all_enum_values.insert(Enum_new4::_11);
+  Enum_new4_all_enum_values.insert(Enum_new4::_22);
+
+  std::set<Enum1::eType> param2_allowed_enum_subset_values;
+  param2_allowed_enum_subset_values.insert(Enum1::name1);
+
+  // Function parameter param1.
+  //
+  // Description Line1
+  // Description Line2
+  //
+  // Design Line1
+  //
+  // Note: Issue1
+  // Note: Issue2
+  // Note: Issue3
+  //
+  // ToDo: Do1
+  // ToDo: Do2
+  TSharedPtr<ISchemaItem> param1_SchemaItem = TEnumSchemaItem<Enum_new4::eType>::create(Enum_new4_all_enum_values, TSchemaItemParameter<Enum_new4::eType>(Enum_new4::_11));
+
+  // Function parameter param2.
+  TSharedPtr<ISchemaItem> param2_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(param2_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>(name1));
+
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  schema_members["param1"] = CObjectSchemaItem::SMember(param1_SchemaItem, true);
+  schema_members["param2"] = CObjectSchemaItem::SMember(param2_SchemaItem, true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_1_response(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_2_notification(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+//----------- Structs schema items initialization ------------
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct1(
+    const TStructsSchemaItems &struct_schema_items) {
+  std::set<Enum1::eType> Enum1_all_enum_values;
+  Enum1_all_enum_values.insert(Enum1::name1);
+  Enum1_all_enum_values.insert(Enum1::internal_name2);
+
+  std::set<Enum1::eType> enumSubset1_allowed_enum_subset_values;
+  enumSubset1_allowed_enum_subset_values.insert(Enum1::name1);
+
+  std::set<Enum_new2::eType> Enum_new2_all_enum_values;
+  Enum_new2_all_enum_values.insert(Enum_new2::_1);
+  Enum_new2_all_enum_values.insert(Enum_new2::_2);
+  Enum_new2_all_enum_values.insert(Enum_new2::_3);
+
+  std::set<Enum1::eType> sub1_allowed_enum_subset_values;
+  sub1_allowed_enum_subset_values.insert(Enum1::name1);
+
+  std::set<Enum1::eType> sub2_allowed_enum_subset_values;
+  sub2_allowed_enum_subset_values.insert(Enum1::internal_name2);
+
+  std::set<Enum_new4::eType> sub3_allowed_enum_subset_values;
+  sub3_allowed_enum_subset_values.insert(Enum_new4::_22);
+
+  // Struct member intParam.
+  TSharedPtr<ISchemaItem> intParam_SchemaItem = TNumberSchemaItem<int>::create(TSchemaItemParameter<int>(), TSchemaItemParameter<int>(2), TSchemaItemParameter<int>());
+
+  // Struct member doubleParam.
+  TSharedPtr<ISchemaItem> doubleParam_SchemaItem = TNumberSchemaItem<double>::create(TSchemaItemParameter<double>(0.333), TSchemaItemParameter<double>(), TSchemaItemParameter<double>());
+
+  // Struct member boolParam.
+  TSharedPtr<ISchemaItem> boolParam_SchemaItem = CBoolSchemaItem::create(TSchemaItemParameter<bool>());
+
+  // Struct member structParam.
+  TSharedPtr<ISchemaItem> structParam_SchemaItem = ProvideObjectSchemaItemForStruct(struct_schema_items, StructIdentifiers::Struct2);
+
+  // Struct member enumParam.
+  TSharedPtr<ISchemaItem> enumParam_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member enumParam1.
+  TSharedPtr<ISchemaItem> enumParam1_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member enumSubset1.
+  TSharedPtr<ISchemaItem> enumSubset1_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(enumSubset1_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member arrayOfInt.
+  TSharedPtr<ISchemaItem> arrayOfInt_SchemaItem = CArraySchemaItem::create(CBoolSchemaItem::create(TSchemaItemParameter<bool>()), TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(20));
+
+  // Struct member arrayOfEnum1.
+  TSharedPtr<ISchemaItem> arrayOfEnum1_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(20));
+
+  // Struct member arrayOfEnum3.
+  TSharedPtr<ISchemaItem> arrayOfEnum3_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum_new2::eType>::create(Enum_new2_all_enum_values, TSchemaItemParameter<Enum_new2::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(40));
+
+  // Struct member arrayOfEnum4.
+  TSharedPtr<ISchemaItem> arrayOfEnum4_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(sub1_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(41));
+
+  // Struct member arrayOfEnum5.
+  TSharedPtr<ISchemaItem> arrayOfEnum5_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(sub2_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(42));
+
+  // Struct member arrayOfEnum6.
+  TSharedPtr<ISchemaItem> arrayOfEnum6_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum_new4::eType>::create(sub3_allowed_enum_subset_values, TSchemaItemParameter<Enum_new4::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(43));
+
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  schema_members["intParam"] = CObjectSchemaItem::SMember(intParam_SchemaItem, true);
+  schema_members["doubleParam"] = CObjectSchemaItem::SMember(doubleParam_SchemaItem, false);
+  schema_members["boolParam"] = CObjectSchemaItem::SMember(boolParam_SchemaItem, true);
+  schema_members["structParam"] = CObjectSchemaItem::SMember(structParam_SchemaItem, true);
+  schema_members["enumParam"] = CObjectSchemaItem::SMember(enumParam_SchemaItem, true);
+  schema_members["enumParam1"] = CObjectSchemaItem::SMember(enumParam1_SchemaItem, true);
+  schema_members["enumSubset1"] = CObjectSchemaItem::SMember(enumSubset1_SchemaItem, false);
+  schema_members["arrayOfInt"] = CObjectSchemaItem::SMember(arrayOfInt_SchemaItem, false);
+  schema_members["arrayOfEnum1"] = CObjectSchemaItem::SMember(arrayOfEnum1_SchemaItem, false);
+  schema_members["arrayOfEnum3"] = CObjectSchemaItem::SMember(arrayOfEnum3_SchemaItem, true);
+  schema_members["arrayOfEnum4"] = CObjectSchemaItem::SMember(arrayOfEnum4_SchemaItem, true);
+  schema_members["arrayOfEnum5"] = CObjectSchemaItem::SMember(arrayOfEnum5_SchemaItem, true);
+  schema_members["arrayOfEnum6"] = CObjectSchemaItem::SMember(arrayOfEnum6_SchemaItem, true);
+
+  return CObjectSchemaItem::create(schema_members);
+}
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct2(
+    const TStructsSchemaItems &struct_schema_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  return CObjectSchemaItem::create(schema_members);
+}
+
+//-------------- String to value enum mapping ----------------
+
+namespace NsSmartDeviceLink {
+namespace NsSmartObjects {
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum1::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum1::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum1::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum1::name1, "name1"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum1::internal_name2, "name2"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::E2::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::E2::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::E2::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_1, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_2, "yyy"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_3, "val_3"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum_new2::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum_new2::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum_new2::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_1, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_2, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_3, "xxx"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum_new4::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum_new4::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum_new4::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new4::_11, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new4::_22, "xxx"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::messageType::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::messageType::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::messageType::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::request, "request"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::response, "response"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::notification, "notification"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+} // NsSmartObjects
+} // NsSmartDeviceLink
+
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.h b/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.h
new file mode 100644
index 0000000000..826ea55ce1
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.h
@@ -0,0 +1,321 @@
+/**
+ * @file Test.h
+ * @brief Generated class Test header file.
+ *
+ * This class is a part of SmartObjects solution. It provides
+ * factory functionallity which allows client to use SmartSchemas
+ * in accordance with definitions from Test.xml file
+ */
+// Copyright (c) 2013, Ford Motor Company
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+//
+// Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following
+// disclaimer in the documentation and/or other materials provided with the
+// distribution.
+//
+// Neither the name of the Ford Motor Company nor the names of its contributors
+// may be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef __CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+#define __CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+
+#include "JSONHandler/CSmartFactory.hpp"
+#include "SmartObjects/CSmartSchema.hpp"
+#include "SmartObjects/ISchemaItem.hpp"
+#include "SmartObjects/TSharedPtr.hpp"
+
+namespace XXX {
+namespace YYY {
+namespace ZZZ {
+
+namespace StructIdentifiers {
+/**
+ * @brief Enumeration StructIdentifiers.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief Struct1.
+   */
+  Struct1,
+
+  /**
+   * @brief Struct2.
+   */
+  Struct2
+};
+} // StructIdentifiers
+
+namespace Enum1 {
+/**
+ * @brief Enumeration Enum1.
+ *
+ * @todo Do1
+ * @todo Do2
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief name1.
+   *
+   * Design Line1
+   *
+   * @todo Do1
+   * @todo Do2
+   */
+  name1 = 1,
+
+  /**
+   * @brief internal_name2.
+   *
+   * Description Line1
+   * Description Line2
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  internal_name2
+};
+} // Enum1
+
+namespace E2 {
+/**
+ * @brief Enumeration E2.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief val_1.
+   */
+  val_1,
+
+  /**
+   * @brief val_2.
+   */
+  val_2 = 100,
+
+  /**
+   * @brief val_3.
+   */
+  val_3
+};
+} // E2
+
+namespace Enum_new2 {
+/**
+ * @brief Enumeration Enum_new2.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief _1.
+   */
+  _1,
+
+  /**
+   * @brief _2.
+   */
+  _2,
+
+  /**
+   * @brief _3.
+   */
+  _3
+};
+} // Enum_new2
+
+namespace Enum_new4 {
+/**
+ * @brief Enumeration Enum_new4.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief _11.
+   */
+  _11,
+
+  /**
+   * @brief _22.
+   */
+  _22
+};
+} // Enum_new4
+
+namespace messageType {
+/**
+ * @brief Enumeration messageType.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief request.
+   */
+  request,
+
+  /**
+   * @brief response.
+   */
+  response,
+
+  /**
+   * @brief notification.
+   */
+  notification
+};
+} // messageType
+
+
+/**
+ * @brief Class Test.
+ *
+ * Params:
+ *     param2 - value2
+ *     param1 - value1
+ */
+class Test : public NsSmartDeviceLink::NsJSONHandler::CSmartFactory<FunctionID::eType, messageType::eType, StructIdentifiers::eType> {
+ public:
+  /**
+   * @brief Constructor.
+   */
+  Test();
+
+ protected:
+  /**
+   * @brief Type that maps of struct IDs to schema items.
+   */
+  typedef std::map<const StructIdentifiers::eType, NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> > TStructsSchemaItems;
+
+  /**
+   * @brief Helper that allows to make reference to struct
+   *
+   * @param struct_schema_items Struct schema items.
+   * @param struct_id ID of structure to provide.
+   *
+   * @return TSharedPtr of strucute
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> ProvideObjectSchemaItemForStruct(
+        const TStructsSchemaItems &struct_schema_items,
+        const StructIdentifiers::eType struct_id);
+
+  /**
+   * @brief Initializes all struct schemes.
+   */
+  void InitStructSchemes(TStructsSchemaItems &struct_schema_items);
+
+  /**
+   * @brief Initializes all function schemes.
+   *
+   * @param struct_schema_items Struct schema items.
+   * @param function_id_items Set of all elements of FunctionID enum.
+   * @param message_type_items Set of all elements of messageType enum.
+   */
+  void InitFunctionSchemes(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function1.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_name1_request(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function2.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_val_1_response(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function2.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_val_2_notification(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema item for structure Struct1.
+   *
+   * Design Line1
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> InitStructSchemaItem_Struct1(
+      const TStructsSchemaItems &struct_schema_items);
+
+  /**
+   * @brief Method that generates schema item for structure Struct2.
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> InitStructSchemaItem_Struct2(
+      const TStructsSchemaItems &struct_schema_items);
+};
+
+} // XXX
+} // YYY
+} // ZZZ
+
+#endif //__CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+
diff --git a/tools/InterfaceGenerator/test/generator/parsers/__init__.py b/tools/InterfaceGenerator/test/generator/parsers/__init__.py
new file mode 100755
index 0000000000..e69de29bb2
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/__init__.py
diff --git a/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py b/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py
new file mode 100755
index 0000000000..f2fecdb901
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py
@@ -0,0 +1,595 @@
+"""JSONRPC XML parser unit test."""
+import os
+import unittest
+
+import generator.Model
+import generator.parsers.JSONRPC
+
+
+class TestJSONRPCVParser(unittest.TestCase):
+
+    """Test for JSONRPC xml parser."""
+
+    class _Issue:
+        def __init__(self, creator, value):
+            self.creator = creator
+            self.value = value
+
+        def __eq__(self, other):
+            return self.creator == other.creator and self.value == other.value
+
+    def setUp(self):
+        """Test initialization."""
+        self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \
+            "/valid_JSONRPC.xml"
+        self.parser = generator.parsers.JSONRPC.Parser()
+
+    def test_valid_xml(self):
+        """Test parsing of valid xml."""
+        interface = self.parser.parse(self.valid_xml_name)
+
+        self.assertEqual(9, len(interface.params))
+        self.assertDictEqual({"attr1": "v1",
+                              "attr2": "v2",
+                              "interface1_attribute1": "value1",
+                              "interface1_attribute2": "value2",
+                              "interface1_issues": "Issue1\nIssue2",
+                              "interface1_design_description": "dd",
+                              "interface2_attribute": "value",
+                              "interface2_description":
+                              "Description of interface2",
+                              "interface2_todos": "i2 todo"},
+                             interface.params)
+
+        # Enumerations
+
+        self.assertEqual(5, len(interface.enums))
+
+        # Enumeration "FunctionID"
+
+        self.assertIn("FunctionID", interface.enums)
+        enum = interface.enums["FunctionID"]
+        self.verify_base_item(item=enum,
+                              name="FunctionID")
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("interface1.Function1", enum.elements)
+        element = enum.elements["interface1.Function1"]
+        self.verify_base_item(
+            item=element,
+            name="interface1.Function1")
+        self.assertEqual("interface1_Function1", element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("interface1.Function2", enum.elements)
+        element = enum.elements["interface1.Function2"]
+        self.verify_base_item(
+            item=element,
+            name="interface1.Function2")
+        self.assertEqual("interface1_Function2", element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("interface2.Function1", enum.elements)
+        element = enum.elements["interface2.Function1"]
+        self.verify_base_item(
+            item=element,
+            name="interface2.Function1")
+        self.assertEqual("interface2_Function1", element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "messageType"
+
+        self.assertIn("messageType", interface.enums)
+        enum = interface.enums["messageType"]
+        self.verify_base_item(
+            item=enum,
+            name="messageType")
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("request", enum.elements)
+        element = enum.elements["request"]
+        self.verify_base_item(item=element,
+                              name="request")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("response", enum.elements)
+        element = enum.elements["response"]
+        self.verify_base_item(item=element, name="response")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("notification", enum.elements)
+        element = enum.elements["notification"]
+        self.verify_base_item(item=element, name="notification")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "interface1_enum1"
+
+        self.assertIn("interface1_enum1", interface.enums)
+        enum = interface.enums["interface1_enum1"]
+        self.verify_base_item(item=enum, name="interface1_enum1",
+                              platform="enum1 platform")
+        self.assertEqual("scope", enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("element1", enum.elements)
+        element = enum.elements["element1"]
+        self.verify_base_item(item=element, name="element1")
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(10, element.value)
+
+        self.assertIn("element2", enum.elements)
+        element = enum.elements["element2"]
+        self.verify_base_item(item=element, name="element2")
+        self.assertEqual("element2_internal", element.internal_name)
+        self.assertEqual(11, element.value)
+
+        self.assertIn("element3", enum.elements)
+        element = enum.elements["element3"]
+        self.verify_base_item(
+            item=element,
+            name="element3",
+            design_description=["Element design description"],
+            platform="element3 platform")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "interface2_enum1"
+
+        self.assertIn("interface2_enum1", interface.enums)
+        enum = interface.enums["interface2_enum1"]
+        self.verify_base_item(item=enum, name="interface2_enum1",
+                              description=["Interface2 enum1 description"])
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(2, len(enum.elements))
+
+        self.assertIn("e1", enum.elements)
+        element = enum.elements["e1"]
+        self.verify_base_item(item=element, name="e1")
+        self.assertEqual("int_e1", element.internal_name)
+        self.assertEqual(0, element.value)
+
+        self.assertIn("e2", enum.elements)
+        element = enum.elements["e2"]
+        self.verify_base_item(item=element, name="e2")
+        self.assertEqual("int_e2", element.internal_name)
+        self.assertEqual(10, element.value)
+
+        # Enumeration "interface2_enum2"
+
+        self.assertIn("interface2_enum2", interface.enums)
+        enum = interface.enums["interface2_enum2"]
+        self.verify_base_item(item=enum, name="interface2_enum2",
+                              platform="e2 platform")
+        self.assertEqual("e2 scope", enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("element1", enum.elements)
+        element = enum.elements["element1"]
+        self.verify_base_item(item=element, name="element1")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("element2", enum.elements)
+        element = enum.elements["element2"]
+        self.verify_base_item(item=element, name="element2")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("element3", enum.elements)
+        element = enum.elements["element3"]
+        self.verify_base_item(item=element, name="element3")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Structures
+
+        self.assertEqual(3, len(interface.structs))
+
+        # Structure "interface1_struct1"
+
+        self.assertIn("interface1_struct1", interface.structs)
+        struct = interface.structs["interface1_struct1"]
+        self.verify_base_item(
+            item=struct,
+            name="interface1_struct1",
+            description=["Struct description"],
+            issues=[TestJSONRPCVParser._Issue(creator="creator1",
+                                              value="Issue1"),
+                    TestJSONRPCVParser._Issue(creator="creator2",
+                                              value="Issue2")])
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("member1", struct.members)
+        member = struct.members["member1"]
+        self.verify_base_item(
+            item=member,
+            name="member1",
+            description=["Param1 description"])
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Integer)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertIsNone(member.param_type.max_value)
+
+        self.assertIn("member2", struct.members)
+        member = struct.members["member2"]
+        self.verify_base_item(item=member, name="member2",
+                              platform="member2 platform")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Boolean)
+
+        self.assertIn("member3", struct.members)
+        member = struct.members["member3"]
+        self.verify_base_item(item=member, name="member3")
+        self.assertEqual(False, member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Double)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertAlmostEqual(20.5, member.param_type.max_value)
+
+        self.assertIn("member4", struct.members)
+        member = struct.members["member4"]
+        self.verify_base_item(item=member, name="member4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertIsNone(member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.Integer)
+        self.assertEqual(11, member.param_type.element_type.min_value)
+        self.assertEqual(100, member.param_type.element_type.max_value)
+
+        # Structure "interface1_struct2"
+
+        self.assertIn("interface1_struct2", interface.structs)
+        struct = interface.structs["interface1_struct2"]
+        self.verify_base_item(item=struct,
+                              name="interface1_struct2",
+                              description=["Description of struct2"],
+                              platform="struct2 platform")
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("m1", struct.members)
+        member = struct.members["m1"]
+        self.verify_base_item(item=member, name="m1")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.String)
+        self.assertIsNone(member.param_type.max_length)
+
+        self.assertIn("m2", struct.members)
+        member = struct.members["m2"]
+        self.verify_base_item(item=member, name="m2")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertEqual(1, member.param_type.min_size)
+        self.assertEqual(50, member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.String)
+        self.assertEqual(100, member.param_type.element_type.max_length)
+
+        self.assertIn("m3", struct.members)
+        member = struct.members["m3"]
+        self.verify_base_item(item=member, name="m3")
+        self.assertTrue(member.is_mandatory)
+        self.assertIs(member.param_type, interface.enums["interface1_enum1"])
+
+        self.assertIn("m4", struct.members)
+        member = struct.members["m4"]
+        self.verify_base_item(item=member, name="m4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertEqual(10, member.param_type.max_size)
+        self.assertIs(member.param_type.element_type,
+                      interface.structs["interface1_struct1"])
+
+        # Structure "interface2_struct1"
+
+        self.assertIn("interface2_struct1", interface.structs)
+        struct = interface.structs["interface2_struct1"]
+        self.verify_base_item(item=struct, name="interface2_struct1")
+
+        self.assertEqual(3, len(struct.members))
+
+        self.assertIn("m_1", struct.members)
+        member = struct.members["m_1"]
+        self.verify_base_item(item=member, name="m_1")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertEqual(1, member.param_type.min_size)
+        self.assertEqual(10, member.param_type.max_size)
+        self.assertIs(member.param_type.element_type,
+                      interface.enums["interface2_enum1"])
+
+        self.assertIn("m_2", struct.members)
+        member = struct.members["m_2"]
+        self.verify_base_item(item=member, name="m_2")
+        self.assertTrue(member.is_mandatory)
+        self.assertIs(member.param_type, interface.enums["interface2_enum2"])
+
+        self.assertIn("m_3", struct.members)
+        member = struct.members["m_3"]
+        self.verify_base_item(item=member, name="m_3")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.String)
+        self.assertEqual(20, member.param_type.max_length)
+
+        # Functions
+
+        self.assertEqual(5, len(interface.functions))
+
+        # Function request "interface1_Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["interface1.Function1"],
+             interface.enums["messageType"].elements["request"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["interface1.Function1"],
+             interface.enums["messageType"].elements["request"])]
+        self.verify_base_item(
+            item=function,
+            name="interface1_Function1",
+            description=["Description of request Function1"],
+            todos=["Function1 request todo"])
+        self.assertIs(
+            function.function_id,
+            interface.enums["FunctionID"].elements["interface1.Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["request"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("param1", function.params)
+        param = function.params["param1"]
+        self.verify_base_item(
+            item=param,
+            name="param1",
+            issues=[TestJSONRPCVParser._Issue(creator="", value="")])
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.String)
+        self.assertIsNone(param.param_type.max_length)
+        self.assertEqual("String default value", param.default_value)
+
+        self.assertIn("param2", function.params)
+        param = function.params["param2"]
+        self.verify_base_item(
+            item=param,
+            name="param2",
+            description=["Param2 description", ""],
+            todos=["Param2 todo"],
+            platform="param2 platform")
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Integer)
+        self.assertIsNone(param.param_type.min_value)
+        self.assertIsNone(param.param_type.max_value)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("param3", function.params)
+        param = function.params["param3"]
+        self.verify_base_item(item=param, name="param3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type,
+                      interface.structs["interface1_struct1"])
+        self.assertIsNone(param.default_value)
+
+        # Function response "interface1_Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["interface1.Function1"],
+             interface.enums["messageType"].elements["response"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["interface1.Function1"],
+             interface.enums["messageType"].elements["response"])]
+        self.verify_base_item(
+            item=function,
+            name="interface1_Function1",
+            issues=[TestJSONRPCVParser._Issue(creator="c1", value=""),
+                    TestJSONRPCVParser._Issue(creator="c2", value="")],
+            platform="")
+        self.assertIs(
+            function.function_id,
+            interface.enums["FunctionID"].elements["interface1.Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["response"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("p1", function.params)
+        param = function.params["p1"]
+        self.verify_base_item(item=param, name="p1")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["interface1_enum1"])
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("p2", function.params)
+        param = function.params["p2"]
+        self.verify_base_item(item=param, name="p2")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["interface1_enum1"])
+        self.assertIs(
+            param.default_value,
+            interface.enums["interface1_enum1"].elements["element2"])
+
+        self.assertIn("p3", function.params)
+        param = function.params["p3"]
+        self.verify_base_item(item=param, name="p3", design_description=[""])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Boolean)
+        self.assertEqual(False, param.default_value)
+
+        # Function notification "interface1_Function2"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["interface1.Function2"],
+             interface.enums["messageType"].elements["notification"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["interface1.Function2"],
+             interface.enums["messageType"].elements["notification"])]
+        self.verify_base_item(item=function,
+                              name="interface1_Function2",
+                              description=["Function2 description"],
+                              platform="function2 platform")
+        self.assertIs(
+            function.function_id,
+            interface.enums["FunctionID"].elements["interface1.Function2"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["notification"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("n1", function.params)
+        param = function.params["n1"]
+        self.verify_base_item(item=param, name="n1", todos=["n1 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.EnumSubset)
+        self.assertIs(param.param_type.enum,
+                      interface.enums["interface1_enum1"])
+        self.assertDictEqual(
+            {"element2":
+                interface.enums["interface1_enum1"].elements["element2"],
+             "element3":
+                interface.enums["interface1_enum1"].elements["element3"]},
+            param.param_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n2", function.params)
+        param = function.params["n2"]
+        self.verify_base_item(item=param, name="n2", todos=["n2 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Array)
+        self.assertEqual(1, param.param_type.min_size)
+        self.assertEqual(100, param.param_type.max_size)
+        self.assertIsInstance(param.param_type.element_type,
+                              generator.Model.EnumSubset)
+        self.assertIs(param.param_type.element_type.enum,
+                      interface.enums["interface1_enum1"])
+        self.assertDictEqual(
+            {"element1":
+                interface.enums["interface1_enum1"].elements["element1"],
+             "element3":
+                interface.enums["interface1_enum1"].elements["element3"]},
+            param.param_type.element_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n3", function.params)
+        param = function.params["n3"]
+        self.verify_base_item(item=param, name="n3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type,
+                      interface.structs["interface1_struct2"])
+        self.assertIsNone(param.default_value)
+
+        # Function request "interface2_Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["interface2.Function1"],
+             interface.enums["messageType"].elements["request"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["interface2.Function1"],
+             interface.enums["messageType"].elements["request"])]
+        self.verify_base_item(item=function, name="interface2_Function1")
+        self.assertIs(
+            function.function_id,
+            interface.enums["FunctionID"].elements["interface2.Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["request"])
+
+        self.assertEqual(2, len(function.params))
+
+        self.assertIn("param1", function.params)
+        param = function.params["param1"]
+        self.verify_base_item(item=param, name="param1")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["interface2_enum1"])
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("param2", function.params)
+        param = function.params["param2"]
+        self.verify_base_item(item=param, name="param2")
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Array)
+        self.assertEqual(5, param.param_type.min_size)
+        self.assertEqual(25, param.param_type.max_size)
+        self.assertIs(param.param_type.element_type,
+                      interface.structs["interface2_struct1"])
+        self.assertIsNone(param.default_value)
+
+        # Function notification "interface2_Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["interface2.Function1"],
+             interface.enums["messageType"].elements["notification"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["interface2.Function1"],
+             interface.enums["messageType"].elements["notification"])]
+        self.verify_base_item(
+            item=function,
+            name="interface2_Function1",
+            issues=[
+                TestJSONRPCVParser._Issue(creator="c", value="Issue text")],
+            platform="platform")
+        self.assertIs(
+            function.function_id,
+            interface.enums["FunctionID"].elements["interface2.Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["notification"])
+
+        self.assertEqual(2, len(function.params))
+
+        self.assertIn("param", function.params)
+        param = function.params["param"]
+        self.verify_base_item(item=param, name="param")
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.EnumSubset)
+        self.assertIs(param.param_type.enum,
+                      interface.enums["interface2_enum2"])
+        self.assertDictEqual(
+            {"element2":
+                interface.enums["interface2_enum2"].elements["element2"],
+             "element3":
+                interface.enums["interface2_enum2"].elements["element3"]},
+            param.param_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("i1", function.params)
+        param = function.params["i1"]
+        self.verify_base_item(item=param, name="i1")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type,
+                      interface.structs["interface1_struct2"])
+        self.assertIsNone(param.default_value)
+
+    def verify_base_item(self, item, name, description=None,
+                         design_description=None, issues=None, todos=None,
+                         platform=None):
+        """Verify base interface item variables."""
+        self.assertEqual(name, item.name)
+        self.assertSequenceEqual(self.get_list(description), item.description)
+        self.assertSequenceEqual(self.get_list(design_description),
+                                 item.design_description)
+        self.assertSequenceEqual(self.get_list(issues), item.issues)
+        self.assertSequenceEqual(self.get_list(todos), item.todos)
+        self.assertEqual(platform, item.platform)
+
+    @staticmethod
+    def get_list(list=None):
+        """Return provided list or empty list if None is provided."""
+        return list if list is not None else []
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV1.py b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV1.py
new file mode 100755
index 0000000000..1464658ff4
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV1.py
@@ -0,0 +1,404 @@
+"""SDLRPCV1 XML parser unit test."""
+import os
+import unittest
+
+import generator.Model
+import generator.parsers.SDLRPCV1
+
+
+class TestSDLRPCV1Parser(unittest.TestCase):
+
+    """Test for SDLRPCV1 xml parser."""
+
+    class _Issue:
+        def __init__(self, creator, value):
+            self.creator = creator
+            self.value = value
+
+        def __eq__(self, other):
+            return self.creator == other.creator and self.value == other.value
+
+    def setUp(self):
+        """Test initialization."""
+        self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \
+            "/valid_SDLRPCV1.xml"
+        self.parser = generator.parsers.SDLRPCV1.Parser()
+
+    def test_valid_xml(self):
+        """Test parsing of valid xml."""
+        interface = self.parser.parse(self.valid_xml_name)
+
+        self.assertEqual(2, len(interface.params))
+        self.assertDictEqual({"attribute1": "value1", "attribute2": "value2"},
+                             interface.params)
+
+        # Enumerations
+
+        self.assertEqual(3, len(interface.enums))
+
+        # Enumeration "FunctionID"
+
+        self.assertIn("FunctionID", interface.enums)
+        enum = interface.enums["FunctionID"]
+        self.verify_base_item(item=enum,
+                              name="FunctionID")
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(2, len(enum.elements))
+
+        self.assertIn("Function1", enum.elements)
+        element = enum.elements["Function1"]
+        self.verify_base_item(
+            item=element,
+            name="Function1")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("Function2", enum.elements)
+        element = enum.elements["Function2"]
+        self.verify_base_item(
+            item=element,
+            name="Function2")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "messageType"
+
+        self.assertIn("messageType", interface.enums)
+        enum = interface.enums["messageType"]
+        self.verify_base_item(
+            item=enum,
+            name="messageType")
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("request", enum.elements)
+        element = enum.elements["request"]
+        self.verify_base_item(item=element,
+                              name="request")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("response", enum.elements)
+        element = enum.elements["response"]
+        self.verify_base_item(item=element, name="response")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("notification", enum.elements)
+        element = enum.elements["notification"]
+        self.verify_base_item(item=element, name="notification")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "enum1"
+
+        self.assertIn("enum1", interface.enums)
+        enum = interface.enums["enum1"]
+        self.verify_base_item(item=enum, name="enum1",
+                              platform="enum1 platform")
+        self.assertEqual("scope", enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("element1", enum.elements)
+        element = enum.elements["element1"]
+        self.verify_base_item(item=element, name="element1")
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(10, element.value)
+
+        self.assertIn("element2", enum.elements)
+        element = enum.elements["element2"]
+        self.verify_base_item(item=element, name="element2")
+        self.assertEqual("element2_internal", element.internal_name)
+        self.assertEqual(11, element.value)
+
+        self.assertIn("element3", enum.elements)
+        element = enum.elements["element3"]
+        self.verify_base_item(
+            item=element,
+            name="element3",
+            design_description=["Element design description"],
+            platform="element3 platform")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Structures
+
+        self.assertEqual(2, len(interface.structs))
+
+        # Structure "struct1"
+
+        self.assertIn("struct1", interface.structs)
+        struct = interface.structs["struct1"]
+        self.verify_base_item(
+            item=struct,
+            name="struct1",
+            description=["Struct description"],
+            issues=[TestSDLRPCV1Parser._Issue(creator="creator1",
+                                              value="Issue1"),
+                    TestSDLRPCV1Parser._Issue(creator="creator2",
+                                              value="Issue2")])
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("member1", struct.members)
+        member = struct.members["member1"]
+        self.verify_base_item(
+            item=member,
+            name="member1",
+            description=["Param1 description"])
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Integer)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertIsNone(member.param_type.max_value)
+
+        self.assertIn("member2", struct.members)
+        member = struct.members["member2"]
+        self.verify_base_item(item=member, name="member2",
+                              platform="member2 platform")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Boolean)
+
+        self.assertIn("member3", struct.members)
+        member = struct.members["member3"]
+        self.verify_base_item(item=member, name="member3")
+        self.assertEqual(False, member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Double)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertAlmostEqual(20.5, member.param_type.max_value)
+
+        self.assertIn("member4", struct.members)
+        member = struct.members["member4"]
+        self.verify_base_item(item=member, name="member4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertIsNone(member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.Integer)
+        self.assertEqual(11, member.param_type.element_type.min_value)
+        self.assertEqual(100, member.param_type.element_type.max_value)
+
+        # Structure "struct2"
+
+        self.assertIn("struct2", interface.structs)
+        struct = interface.structs["struct2"]
+        self.verify_base_item(item=struct,
+                              name="struct2",
+                              description=["Description of struct2"],
+                              platform="struct2 platform")
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("m1", struct.members)
+        member = struct.members["m1"]
+        self.verify_base_item(item=member, name="m1")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.String)
+        self.assertIsNone(member.param_type.max_length)
+
+        self.assertIn("m2", struct.members)
+        member = struct.members["m2"]
+        self.verify_base_item(item=member, name="m2")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertEqual(1, member.param_type.min_size)
+        self.assertEqual(50, member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.String)
+        self.assertEqual(100, member.param_type.element_type.max_length)
+
+        self.assertIn("m3", struct.members)
+        member = struct.members["m3"]
+        self.verify_base_item(item=member, name="m3")
+        self.assertTrue(member.is_mandatory)
+        self.assertIs(member.param_type, interface.enums["enum1"])
+
+        self.assertIn("m4", struct.members)
+        member = struct.members["m4"]
+        self.verify_base_item(item=member, name="m4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertEqual(10, member.param_type.max_size)
+        self.assertIs(member.param_type.element_type,
+                      interface.structs["struct1"])
+
+        # Functions
+
+        self.assertEqual(3, len(interface.functions))
+
+        # Function request "Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function1"],
+             interface.enums["messageType"].elements["request"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function1"],
+             interface.enums["messageType"].elements["request"])]
+        self.verify_base_item(
+            item=function,
+            name="Function1",
+            description=["Description of request Function1"],
+            todos=["Function1 request todo"])
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["request"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("param1", function.params)
+        param = function.params["param1"]
+        self.verify_base_item(
+            item=param,
+            name="param1",
+            issues=[TestSDLRPCV1Parser._Issue(creator="", value="")])
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.String)
+        self.assertIsNone(param.param_type.max_length)
+        self.assertEqual("String default value", param.default_value)
+
+        self.assertIn("param2", function.params)
+        param = function.params["param2"]
+        self.verify_base_item(
+            item=param,
+            name="param2",
+            description=["Param2 description", ""],
+            todos=["Param2 todo"],
+            platform="param2 platform")
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Integer)
+        self.assertIsNone(param.param_type.min_value)
+        self.assertIsNone(param.param_type.max_value)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("param3", function.params)
+        param = function.params["param3"]
+        self.verify_base_item(item=param, name="param3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type, interface.structs["struct1"])
+        self.assertIsNone(param.default_value)
+
+        # Function response "Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function1"],
+             interface.enums["messageType"].elements["response"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function1"],
+             interface.enums["messageType"].elements["response"])]
+        self.verify_base_item(
+            item=function,
+            name="Function1",
+            issues=[TestSDLRPCV1Parser._Issue(creator="c1", value=""),
+                    TestSDLRPCV1Parser._Issue(creator="c2", value="")],
+            platform="")
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["response"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("p1", function.params)
+        param = function.params["p1"]
+        self.verify_base_item(item=param, name="p1")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["enum1"])
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("p2", function.params)
+        param = function.params["p2"]
+        self.verify_base_item(item=param, name="p2")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["enum1"])
+        self.assertIs(param.default_value,
+                      interface.enums["enum1"].elements["element2"])
+
+        self.assertIn("p3", function.params)
+        param = function.params["p3"]
+        self.verify_base_item(item=param, name="p3", design_description=[""])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Boolean)
+        self.assertEqual(False, param.default_value)
+
+        # Function notification "Function2"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function2"],
+             interface.enums["messageType"].elements["notification"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function2"],
+             interface.enums["messageType"].elements["notification"])]
+        self.verify_base_item(item=function,
+                              name="Function2",
+                              description=["Function2 description"],
+                              platform="function2 platform")
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function2"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["notification"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("n1", function.params)
+        param = function.params["n1"]
+        self.verify_base_item(item=param, name="n1", todos=["n1 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.EnumSubset)
+        self.assertIs(param.param_type.enum, interface.enums["enum1"])
+        self.assertDictEqual(
+            {"element2": interface.enums["enum1"].elements["element2"],
+             "element3": interface.enums["enum1"].elements["element3"]},
+            param.param_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n2", function.params)
+        param = function.params["n2"]
+        self.verify_base_item(item=param, name="n2", todos=["n2 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Array)
+        self.assertEqual(1, param.param_type.min_size)
+        self.assertEqual(100, param.param_type.max_size)
+        self.assertIsInstance(param.param_type.element_type,
+                              generator.Model.EnumSubset)
+        self.assertIs(param.param_type.element_type.enum,
+                      interface.enums["enum1"])
+        self.assertDictEqual(
+            {"element1": interface.enums["enum1"].elements["element1"],
+             "element3": interface.enums["enum1"].elements["element3"]},
+            param.param_type.element_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n3", function.params)
+        param = function.params["n3"]
+        self.verify_base_item(item=param, name="n3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type, interface.structs["struct2"])
+        self.assertIsNone(param.default_value)
+
+    def verify_base_item(self, item, name, description=None,
+                         design_description=None, issues=None, todos=None,
+                         platform=None):
+        """Verify base interface item variables."""
+        self.assertEqual(name, item.name)
+        self.assertSequenceEqual(self.get_list(description), item.description)
+        self.assertSequenceEqual(self.get_list(design_description),
+                                 item.design_description)
+        self.assertSequenceEqual(self.get_list(issues), item.issues)
+        self.assertSequenceEqual(self.get_list(todos), item.todos)
+        self.assertEqual(platform, item.platform)
+
+    @staticmethod
+    def get_list(list=None):
+        """Return provided list or empty list if None is provided."""
+        return list if list is not None else []
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV2.py b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV2.py
new file mode 100755
index 0000000000..c37962cfe6
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV2.py
@@ -0,0 +1,417 @@
+"""SDLRPCV2 XML parser unit test."""
+import os
+import unittest
+
+import generator.Model
+import generator.parsers.SDLRPCV2
+
+
+class TestSDLRPCV2Parser(unittest.TestCase):
+
+    """Test for SDLRPCV2 xml parser."""
+
+    class _Issue:
+        def __init__(self, creator, value):
+            self.creator = creator
+            self.value = value
+
+        def __eq__(self, other):
+            return self.creator == other.creator and self.value == other.value
+
+    def setUp(self):
+        """Test initialization."""
+        self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \
+            "/valid_SDLRPCV2.xml"
+        self.parser = generator.parsers.SDLRPCV2.Parser()
+
+    def test_valid_xml(self):
+        """Test parsing of valid xml."""
+        interface = self.parser.parse(self.valid_xml_name)
+
+        self.assertEqual(2, len(interface.params))
+        self.assertDictEqual({"attribute1": "value1", "attribute2": "value2"},
+                             interface.params)
+
+        # Enumerations
+
+        self.assertEqual(3, len(interface.enums))
+
+        # Enumeration "FunctionID"
+
+        self.assertIn("FunctionID", interface.enums)
+        enum = interface.enums["FunctionID"]
+        self.verify_base_item(item=enum,
+                              name="FunctionID",
+                              description=["Description string 1",
+                                           "Description string 2"],
+                              todos=['Function id todo'])
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(2, len(enum.elements))
+
+        self.assertIn("Function1_id", enum.elements)
+        element = enum.elements["Function1_id"]
+        self.verify_base_item(
+            item=element,
+            name="Function1_id",
+            design_description=["Function1 element design description"])
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(10, element.value)
+
+        self.assertIn("Function2_id", enum.elements)
+        element = enum.elements["Function2_id"]
+        self.verify_base_item(
+            item=element,
+            name="Function2_id")
+        self.assertEqual("Function2_internal", element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "messageType"
+
+        self.assertIn("messageType", interface.enums)
+        enum = interface.enums["messageType"]
+        self.verify_base_item(
+            item=enum,
+            name="messageType",
+            design_description=["messageType design description",
+                                "messageType design description 2"],
+            issues=[TestSDLRPCV2Parser._Issue(
+                creator="messageType issue creator",
+                value="Issue text")])
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("request", enum.elements)
+        element = enum.elements["request"]
+        self.verify_base_item(item=element,
+                              name="request",
+                              todos=["request todo 1", "request todo 2"],
+                              issues=[TestSDLRPCV2Parser._Issue(
+                                  creator="issue creator",
+                                  value="request issue")])
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(0, element.value)
+
+        self.assertIn("response", enum.elements)
+        element = enum.elements["response"]
+        self.verify_base_item(item=element, name="response")
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(1, element.value)
+
+        self.assertIn("notification", enum.elements)
+        element = enum.elements["notification"]
+        self.verify_base_item(item=element, name="notification")
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(2, element.value)
+
+        # Enumeration "enum1"
+
+        self.assertIn("enum1", interface.enums)
+        enum = interface.enums["enum1"]
+        self.verify_base_item(item=enum, name="enum1",
+                              platform="enum1 platform")
+        self.assertEqual("scope", enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("element1", enum.elements)
+        element = enum.elements["element1"]
+        self.verify_base_item(item=element, name="element1")
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(10, element.value)
+
+        self.assertIn("element2", enum.elements)
+        element = enum.elements["element2"]
+        self.verify_base_item(item=element, name="element2")
+        self.assertEqual("element2_internal", element.internal_name)
+        self.assertEqual(11, element.value)
+
+        self.assertIn("element3", enum.elements)
+        element = enum.elements["element3"]
+        self.verify_base_item(
+            item=element,
+            name="element3",
+            design_description=["Element design description"],
+            platform="element3 platform")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Structures
+
+        self.assertEqual(2, len(interface.structs))
+
+        # Structure "struct1"
+
+        self.assertIn("struct1", interface.structs)
+        struct = interface.structs["struct1"]
+        self.verify_base_item(
+            item=struct,
+            name="struct1",
+            description=["Struct description"],
+            issues=[TestSDLRPCV2Parser._Issue(creator="creator1",
+                                              value="Issue1"),
+                    TestSDLRPCV2Parser._Issue(creator="creator2",
+                                              value="Issue2")])
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("member1", struct.members)
+        member = struct.members["member1"]
+        self.verify_base_item(
+            item=member,
+            name="member1",
+            description=["Param1 description"])
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Integer)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertIsNone(member.param_type.max_value)
+
+        self.assertIn("member2", struct.members)
+        member = struct.members["member2"]
+        self.verify_base_item(item=member, name="member2",
+                              platform="member2 platform")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Boolean)
+
+        self.assertIn("member3", struct.members)
+        member = struct.members["member3"]
+        self.verify_base_item(item=member, name="member3")
+        self.assertEqual(False, member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Double)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertAlmostEqual(20.5, member.param_type.max_value)
+
+        self.assertIn("member4", struct.members)
+        member = struct.members["member4"]
+        self.verify_base_item(item=member, name="member4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertIsNone(member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.Integer)
+        self.assertEqual(11, member.param_type.element_type.min_value)
+        self.assertEqual(100, member.param_type.element_type.max_value)
+
+        # Structure "struct2"
+
+        self.assertIn("struct2", interface.structs)
+        struct = interface.structs["struct2"]
+        self.verify_base_item(item=struct,
+                              name="struct2",
+                              description=["Description of struct2"],
+                              platform="struct2 platform")
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("m1", struct.members)
+        member = struct.members["m1"]
+        self.verify_base_item(item=member, name="m1")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.String)
+        self.assertIsNone(member.param_type.max_length)
+
+        self.assertIn("m2", struct.members)
+        member = struct.members["m2"]
+        self.verify_base_item(item=member, name="m2")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertEqual(1, member.param_type.min_size)
+        self.assertEqual(50, member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.String)
+        self.assertEqual(100, member.param_type.element_type.max_length)
+
+        self.assertIn("m3", struct.members)
+        member = struct.members["m3"]
+        self.verify_base_item(item=member, name="m3")
+        self.assertTrue(member.is_mandatory)
+        self.assertIs(member.param_type, interface.enums["enum1"])
+
+        self.assertIn("m4", struct.members)
+        member = struct.members["m4"]
+        self.verify_base_item(item=member, name="m4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertEqual(10, member.param_type.max_size)
+        self.assertIs(member.param_type.element_type,
+                      interface.structs["struct1"])
+
+        # Functions
+
+        self.assertEqual(3, len(interface.functions))
+
+        # Function request "Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function1_id"],
+             interface.enums["messageType"].elements["request"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function1_id"],
+             interface.enums["messageType"].elements["request"])]
+        self.verify_base_item(
+            item=function,
+            name="Function1",
+            description=["Description of request Function1"],
+            todos=["Function1 request todo"])
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function1_id"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["request"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("param1", function.params)
+        param = function.params["param1"]
+        self.verify_base_item(
+            item=param,
+            name="param1",
+            issues=[TestSDLRPCV2Parser._Issue(creator="", value="")])
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.String)
+        self.assertIsNone(param.param_type.max_length)
+        self.assertEqual("String default value", param.default_value)
+
+        self.assertIn("param2", function.params)
+        param = function.params["param2"]
+        self.verify_base_item(
+            item=param,
+            name="param2",
+            description=["Param2 description", ""],
+            todos=["Param2 todo"],
+            platform="param2 platform")
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Integer)
+        self.assertIsNone(param.param_type.min_value)
+        self.assertIsNone(param.param_type.max_value)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("param3", function.params)
+        param = function.params["param3"]
+        self.verify_base_item(item=param, name="param3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type, interface.structs["struct1"])
+        self.assertIsNone(param.default_value)
+
+        # Function response "Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function1_id"],
+             interface.enums["messageType"].elements["response"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function1_id"],
+             interface.enums["messageType"].elements["response"])]
+        self.verify_base_item(
+            item=function,
+            name="Function1",
+            issues=[TestSDLRPCV2Parser._Issue(creator="c1", value=""),
+                    TestSDLRPCV2Parser._Issue(creator="c2", value="")],
+            platform="")
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function1_id"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["response"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("p1", function.params)
+        param = function.params["p1"]
+        self.verify_base_item(item=param, name="p1")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["enum1"])
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("p2", function.params)
+        param = function.params["p2"]
+        self.verify_base_item(item=param, name="p2")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["enum1"])
+        self.assertIs(param.default_value,
+                      interface.enums["enum1"].elements["element2"])
+
+        self.assertIn("p3", function.params)
+        param = function.params["p3"]
+        self.verify_base_item(item=param, name="p3", design_description=[""])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Boolean)
+        self.assertEqual(False, param.default_value)
+
+        # Function notification "Function2"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function2_id"],
+             interface.enums["messageType"].elements["notification"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function2_id"],
+             interface.enums["messageType"].elements["notification"])]
+        self.verify_base_item(item=function,
+                              name="Function2",
+                              description=["Function2 description"],
+                              platform="function2 platform")
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function2_id"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["notification"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("n1", function.params)
+        param = function.params["n1"]
+        self.verify_base_item(item=param, name="n1", todos=["n1 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.EnumSubset)
+        self.assertIs(param.param_type.enum, interface.enums["enum1"])
+        self.assertDictEqual(
+            {"element2": interface.enums["enum1"].elements["element2"],
+             "element3": interface.enums["enum1"].elements["element3"]},
+            param.param_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n2", function.params)
+        param = function.params["n2"]
+        self.verify_base_item(item=param, name="n2", todos=["n2 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Array)
+        self.assertEqual(1, param.param_type.min_size)
+        self.assertEqual(100, param.param_type.max_size)
+        self.assertIsInstance(param.param_type.element_type,
+                              generator.Model.EnumSubset)
+        self.assertIs(param.param_type.element_type.enum,
+                      interface.enums["enum1"])
+        self.assertDictEqual(
+            {"element1": interface.enums["enum1"].elements["element1"],
+             "element3": interface.enums["enum1"].elements["element3"]},
+            param.param_type.element_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n3", function.params)
+        param = function.params["n3"]
+        self.verify_base_item(item=param, name="n3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type, interface.structs["struct2"])
+        self.assertIsNone(param.default_value)
+
+    def verify_base_item(self, item, name, description=None,
+                         design_description=None, issues=None, todos=None,
+                         platform=None):
+        """Verify base interface item variables."""
+        self.assertEqual(name, item.name)
+        self.assertSequenceEqual(self.get_list(description), item.description)
+        self.assertSequenceEqual(self.get_list(design_description),
+                                 item.design_description)
+        self.assertSequenceEqual(self.get_list(issues), item.issues)
+        self.assertSequenceEqual(self.get_list(todos), item.todos)
+        self.assertEqual(platform, item.platform)
+
+    @staticmethod
+    def get_list(list=None):
+        """Return provided list or empty list if None is provided."""
+        return list if list is not None else []
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/InterfaceGenerator/test/generator/parsers/valid_JSONRPC.xml b/tools/InterfaceGenerator/test/generator/parsers/valid_JSONRPC.xml
new file mode 100644
index 0000000000..a754e5714e
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/valid_JSONRPC.xml
@@ -0,0 +1,100 @@
+<?xml version="1.0"?>
+<interfaces attr1="v1" attr2="v2">
+    <interface name="interface1" attribute1="value1" attribute2="value2">
+        <struct name="struct1">
+            <param name="member1" type="Integer">
+                <description>Param1 description</description>
+            </param>
+            <issue creator="creator1">Issue1</issue>
+            <param name="member2" type="Boolean" mandatory="true" platform="member2 platform"/>
+            <param name="member3" type="Float" maxvalue="20.5" mandatory="false"/>
+            <description>Struct description</description>
+            <issue creator="creator2">Issue2</issue>
+            <param name="member4" type="Integer" minvalue="11" maxvalue="100" array="true"/>
+        </struct>
+        <issue creator="c">Issue1</issue>
+        <function name="Function1" messagetype="request">
+            <description>Description of request Function1</description>
+            <param name="param1" type="String" mandatory="false" defvalue="String default value">
+                <issue creator=""/>
+            </param>
+            <param name="param2" type="Integer" platform="param2 platform">
+                <description>Param2 description</description>
+                <todo>Param2 todo</todo>
+                <description/>
+            </param>
+            <todo>Function1 request todo</todo>
+            <param name="param3" type="struct1" mandatory="false"/>
+        </function>
+        <enum name="enum1" internal_scope="scope" platform="enum1 platform">
+            <element name="element1" value="10"/>
+            <element name="element2" internal_name="element2_internal" value="11"/>
+            <element name="element3" platform="element3 platform">
+                <designdescription>Element design description</designdescription>
+            </element>
+        </enum>
+        <designdescription>dd</designdescription>
+        <issue creator="c">Issue2</issue>
+        <function name="Function1" messagetype="response" platform="">
+            <param name="p1" type="enum1"/>
+            <issue creator="c1"/>
+            <issue creator="c2"></issue>
+            <param name="p2" type="enum1" defvalue="element2"/>
+            <param name="p3" type="Boolean" defvalue="false">
+                <designdescription/>
+            </param>
+        </function>
+        <struct name="struct2" platform="struct2 platform">
+            <description>Description of struct2</description>
+            <param name="m1" type="String"/>
+            <param name="m2" type="String" maxlength="100" array="true" minsize="1" maxsize="50"/>
+            <param name="m3" type="enum1"/>
+            <param name="m4" type="struct1" array="true" maxsize="10"/>
+        </struct>
+        <function name="Function2" messagetype="notification" platform="function2 platform">
+            <description>Function2 description</description>
+            <param name="n1" type="enum1">
+                <element name="element2"/>
+                <element name="element3"/>
+                <todo>n1 todo</todo>
+            </param>
+            <param name="n2" type="enum1" array="true" minsize="1" maxsize="100">
+                <element name="element3"/>
+                <todo>n2 todo</todo>
+                <element name="element1"/>
+            </param>
+            <param name="n3" type="struct2" mandatory="false"/>
+        </function>
+    </interface>
+    <interface name="interface2" attribute="value">
+        <description>Description of interface2</description>
+        <enum name="enum1">
+            <description>Interface2 enum1 description</description>
+            <element name="e1" internal_name="int_e1" value="0"/>
+            <element name="e2" internal_name="int_e2" value="10"/>
+        </enum>
+        <enum name="enum2" internal_scope="e2 scope" platform="e2 platform">
+            <element name="element1"/>
+            <element name="element2"/>
+            <element name="element3"/>
+        </enum>
+        <struct name="struct1">
+            <param name="m_1" type="enum1" minsize="1" maxsize="10" array="true"/>
+            <param name="m_2" type="enum2"/>
+            <param name="m_3" type="String" maxlength="20"/>
+        </struct>
+        <function name="Function1" messagetype="request">
+            <param name="param1" type="enum1" mandatory="false"/>
+            <param name="param2" type="struct1" array="true" minsize="5" maxsize="25"/>
+        </function>
+        <todo>i2 todo</todo>
+        <function name="Function1" messagetype="notification" platform="platform">
+            <issue creator="c">Issue text</issue>
+            <param name="param" type="enum2">
+                <element name="element2"/>
+                <element name="element3"/>
+            </param>
+            <param name="i1" type="interface1.struct2"/>
+        </function>
+    </interface>
+</interfaces>
\ No newline at end of file
diff --git a/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV1.xml b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV1.xml
new file mode 100644
index 0000000000..37ebf39d3a
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV1.xml
@@ -0,0 +1,64 @@
+<?xml version="1.0"?>
+<interface name="test_interface" attribute1="value1" attribute2="value2">
+    <struct name="struct1">
+        <param name="member1" type="Integer">
+            <description>Param1 description</description>
+        </param>
+        <issue creator="creator1">Issue1</issue>
+        <param name="member2" type="Boolean" mandatory="true" platform="member2 platform"/>
+        <param name="member3" type="Float" maxvalue="20.5" mandatory="false"/>
+        <description>Struct description</description>
+        <issue creator="creator2">Issue2</issue>
+        <param name="member4" type="Integer" minvalue="11" maxvalue="100" array="true"/>
+    </struct>
+    <function name="Function1" messagetype="request">
+        <description>Description of request Function1</description>
+        <param name="param1" type="String" mandatory="false" defvalue="String default value">
+            <issue creator=""/>
+        </param>
+        <param name="param2" type="Integer" platform="param2 platform">
+            <description>Param2 description</description>
+            <todo>Param2 todo</todo>
+            <description/>
+        </param>
+        <todo>Function1 request todo</todo>
+        <param name="param3" type="struct1" mandatory="false"/>
+    </function>
+    <enum name="enum1" internal_scope="scope" platform="enum1 platform">
+        <element name="element1" value="10"/>
+        <element name="element2" internal_name="element2_internal" value="11"/>
+        <element name="element3" platform="element3 platform">
+            <designdescription>Element design description</designdescription>
+        </element>
+    </enum>
+    <function name="Function1" messagetype="response" platform="">
+        <param name="p1" type="enum1"/>
+        <issue creator="c1"/>
+        <issue creator="c2"></issue>
+        <param name="p2" type="enum1" defvalue="element2"/>
+        <param name="p3" type="Boolean" defvalue="false">
+            <designdescription/>
+        </param>
+    </function>
+    <struct name="struct2" platform="struct2 platform">
+        <description>Description of struct2</description>
+        <param name="m1" type="String"/>
+        <param name="m2" type="String" maxlength="100" array="true" minsize="1" maxsize="50"/>
+        <param name="m3" type="enum1"/>
+        <param name="m4" type="struct1" array="true" maxsize="10"/>
+    </struct>
+    <function name="Function2" messagetype="notification" platform="function2 platform">
+        <description>Function2 description</description>
+        <param name="n1" type="enum1">
+            <element name="element2"/>
+            <element name="element3"/>
+            <todo>n1 todo</todo>
+        </param>
+        <param name="n2" type="enum1" array="true" minsize="1" maxsize="100">
+            <element name="element3"/>
+            <todo>n2 todo</todo>
+            <element name="element1"/>
+        </param>
+        <param name="n3" type="struct2" mandatory="false"/>
+    </function>
+</interface>
diff --git a/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml
new file mode 100644
index 0000000000..cdc5f1ae85
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml
@@ -0,0 +1,85 @@
+<?xml version="1.0"?>
+<interface name="test_interface" attribute1="value1" attribute2="value2">
+    <enum name="FunctionID">
+        <description>Description string 1</description>
+        <element name="Function1_id" value="10">
+            <designdescription>Function1 element design description</designdescription>
+        </element>
+        <description>Description string 2</description>
+        <todo>Function id todo</todo>
+        <element name="Function2_id" internal_name="Function2_internal"/>
+    </enum>
+    <enum name="messageType">
+        <element name="request" value="0">
+            <todo>request todo 1</todo>
+            <issue creator="issue creator">request issue</issue>
+            <todo>request todo 2</todo>
+        </element>
+        <designdescription>messageType design description</designdescription>
+        <issue creator="messageType issue creator">Issue text</issue>
+        <element name="response" value="1"/>
+        <element name="notification" value="2"/>
+        <designdescription>messageType design description 2</designdescription>
+    </enum>
+    <struct name="struct1">
+        <param name="member1" type="Integer">
+            <description>Param1 description</description>
+        </param>
+        <issue creator="creator1">Issue1</issue>
+        <param name="member2" type="Boolean" mandatory="true" platform="member2 platform"/>
+        <param name="member3" type="Float" maxvalue="20.5" mandatory="false"/>
+        <description>Struct description</description>
+        <issue creator="creator2">Issue2</issue>
+        <param name="member4" type="Integer" minvalue="11" maxvalue="100" array="true"/>
+    </struct>
+    <function name="Function1" functionID="Function1_id" messagetype="request">
+        <description>Description of request Function1</description>
+        <param name="param1" type="String" mandatory="false" defvalue="String default value">
+            <issue creator=""/>
+        </param>
+        <param name="param2" type="Integer" platform="param2 platform">
+            <description>Param2 description</description>
+            <todo>Param2 todo</todo>
+            <description/>
+        </param>
+        <todo>Function1 request todo</todo>
+        <param name="param3" type="struct1" mandatory="false"/>
+    </function>
+    <enum name="enum1" internal_scope="scope" platform="enum1 platform">
+        <element name="element1" value="10"/>
+        <element name="element2" internal_name="element2_internal" value="11"/>
+        <element name="element3" platform="element3 platform">
+            <designdescription>Element design description</designdescription>
+        </element>
+    </enum>
+    <function name="Function1" functionID="Function1_id" messagetype="response" platform="">
+        <param name="p1" type="enum1"/>
+        <issue creator="c1"/>
+        <issue creator="c2"></issue>
+        <param name="p2" type="enum1" defvalue="element2"/>
+        <param name="p3" type="Boolean" defvalue="false">
+            <designdescription/>
+        </param>
+    </function>
+    <struct name="struct2" platform="struct2 platform">
+        <description>Description of struct2</description>
+        <param name="m1" type="String"/>
+        <param name="m2" type="String" maxlength="100" array="true" minsize="1" maxsize="50"/>
+        <param name="m3" type="enum1"/>
+        <param name="m4" type="struct1" array="true" maxsize="10"/>
+    </struct>
+    <function name="Function2" functionID="Function2_id" messagetype="notification" platform="function2 platform">
+        <description>Function2 description</description>
+        <param name="n1" type="enum1">
+            <element name="element2"/>
+            <element name="element3"/>
+            <todo>n1 todo</todo>
+        </param>
+        <param name="n2" type="enum1" array="true" minsize="1" maxsize="100">
+            <element name="element3"/>
+            <todo>n2 todo</todo>
+            <element name="element1"/>
+        </param>
+        <param name="n3" type="struct2" mandatory="false"/>
+    </function>
+</interface>
diff --git a/tools/InterfaceGenerator/test/generator/test_Model.py b/tools/InterfaceGenerator/test/generator/test_Model.py
new file mode 100755
index 0000000000..55f6a54705
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/test_Model.py
@@ -0,0 +1,27 @@
+"""Interface model unit test"""
+import unittest
+
+import generator.Model
+
+
+class TestInterfaceModel(unittest.TestCase):
+
+    """Test for interface model."""
+
+    def test_enum_element_primary_name(self):
+        """Test property primary_name of EnumElement."""
+        element = generator.Model.EnumElement(name="name1")
+        self.assertEqual("name1", element.primary_name)
+
+        element = generator.Model.EnumElement(name="name2",
+                                              internal_name="internal_name1")
+        self.assertEqual("internal_name1", element.primary_name)
+
+        element.internal_name = None
+        self.assertEqual("name2", element.primary_name)
+
+        element.internal_name = "internal_name2"
+        self.assertEqual("internal_name2", element.primary_name)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/InterfaceGenerator/test/test_CodeFormatAndQuality.py b/tools/InterfaceGenerator/test/test_CodeFormatAndQuality.py
new file mode 100755
index 0000000000..3ce56e0fae
--- /dev/null
+++ b/tools/InterfaceGenerator/test/test_CodeFormatAndQuality.py
@@ -0,0 +1,59 @@
+import subprocess
+import unittest
+import flake8.main
+import pep257
+import os.path
+import fnmatch
+import os
+import pylint.lint
+import sys
+
+class TestCodeFormatAndQuality(unittest.TestCase):
+
+    def setUp(self):
+        self.projectRootDir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+        projectTestsDir = os.path.join(self.projectRootDir, "test")
+        self.filesToAnalyze = []
+        for root, dirnames, filenames in os.walk(self.projectRootDir):
+            if root.startswith(projectTestsDir):
+                continue # Currently we skipping test files
+            for filename in fnmatch.filter(filenames, '*.py'):
+                fullFileName = os.path.join(root, filename)
+                relativeFileName = os.path.relpath(fullFileName, self.projectRootDir)
+                self.filesToAnalyze.append(relativeFileName)
+
+    def test_pep8_conformance(self):
+        maxCyclomaticComplexity = 10
+        errors = 0
+        for file in self.filesToAnalyze:
+            errors = errors + flake8.main.check_file(file, None, maxCyclomaticComplexity)
+
+        self.assertEqual(errors, 0, "Found code style errors or warnings.")
+
+    def test_pep257_conformance(self):
+        errors = []
+
+        for filePath in self.filesToAnalyze:
+            print("Processing file: {0}".format(filePath))
+            result = pep257.check_files([filePath])
+            if result:
+                errors.extend(result)
+                for error in result:
+                    print(error)
+                print
+        self.assertEqual(len(errors), 0, "Found Docstring Conventions violations.")
+
+    def test_pylint_conformance(self):
+        print
+        self.assertEqual(0,
+                         subprocess.call(
+                             ["pylint",
+                              '--rcfile=pylint.cfg',
+                              'generator',
+                              'Generator.py']
+                         ), "Found Pylint violations")
+        return
+
+if __name__ == '__main__':
+    unittest.main()
+