Bug Fixes and ImprovementsSynchronizationCommit

Fix Empty perform iteration request
Fix type of name from string to enum
SendLocation implemented on HTML5 HMI
Fixed PI response on VR rejection due to high priority.
Fix Apps not responsive/not able to start app/apps remain listed on SYNC even after USB disconnect
Mobile API change and processing capabilities
Change perform interaction request conditions.
Fix SDL must always start 3sec timer before resuming the HMILevel of the app
Remove redundant StartSavePersistentDataTimer() call.
Change wrong predicate name to right.
Added stream request handling feature
Made streaming timeout in media manager configurable
Put navi app in LIMITED in case of phone call
Handling of audio state for applications
Add stop streaming timeout into ini file
Implement HMILevel resumption for job-1
Fix result code ABORTED when interrupts it by Voice recognition activation
Fix incorrect value parameter unexpectedDisconnect in BCOnAppUnregistered
Fix SDL send BC.OnAppUnregistered with "unexpectedDisconnect" set to "true" in case received from HMI OnExitAllApplications {"reason":"MASTER_RESET"}
Fix Update ini file for iAP1 support
Current working directory added to image path
Fix helpers to make it workable with more then 2 parameters
DCHECK() for ManageMobileCommand() replaced with log message because the latter returns false in some regular situations (e.g. TOO_MANY_PENDING_REQUESTS, see SDLAQ-CRS-10)
Remove connection after closing.

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

21 files changed, 5226 insertions, 19 deletions

diff --git a/src/components/smart_objects/CMakeLists.txt b/src/components/smart_objects/CMakeLists.txt
index 89f0dbdce5..c1d599db67 100644
--- a/src/components/smart_objects/CMakeLists.txt
+++ b/src/components/smart_objects/CMakeLists.txt
@@ -1,21 +1,54 @@
+# Copyright (c) 2014, 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.
+
+
+set(SMART_OBJECTS_SRC_DIR ${COMPONENTS_DIR}/smart_objects/src)
+
 include_directories (
-  ./include
-  ../utils/include/
+  include
+  ${COMPONENTS_DIR}/utils/include/
 )
 
 set (SOURCES
-    ./src/smart_object.cc
-    ./src/smart_schema.cc
-    ./src/schema_item.cc
-    ./src/always_false_schema_item.cc
-    ./src/always_true_schema_item.cc
-    ./src/default_shema_item.cc
-    ./src/bool_schema_item.cc
-    ./src/number_schema_item.cc
-    ./src/enum_schema_item.cc
-    ./src/string_schema_item.cc
-    ./src/object_schema_item.cc
-    ./src/array_schema_item.cc
+    ${SMART_OBJECTS_SRC_DIR}/smart_object.cc
+    ${SMART_OBJECTS_SRC_DIR}/smart_schema.cc
+    ${SMART_OBJECTS_SRC_DIR}/schema_item.cc
+    ${SMART_OBJECTS_SRC_DIR}/always_false_schema_item.cc
+    ${SMART_OBJECTS_SRC_DIR}/always_true_schema_item.cc
+    ${SMART_OBJECTS_SRC_DIR}/default_shema_item.cc
+    ${SMART_OBJECTS_SRC_DIR}/bool_schema_item.cc
+    ${SMART_OBJECTS_SRC_DIR}/number_schema_item.cc
+    ${SMART_OBJECTS_SRC_DIR}/enum_schema_item.cc
+    ${SMART_OBJECTS_SRC_DIR}/string_schema_item.cc
+    ${SMART_OBJECTS_SRC_DIR}/object_schema_item.cc
+    ${SMART_OBJECTS_SRC_DIR}/array_schema_item.cc
 )
 
 add_library("SmartObjects" ${SOURCES})
@@ -24,3 +57,7 @@ if(ENABLE_LOG)
   target_link_libraries("SmartObjects" log4cxx -L${LOG4CXX_LIBS_DIRECTORY})
 endif()
 
+if(BUILD_TESTS)
+  add_subdirectory(test)
+endif()
+
diff --git a/src/components/smart_objects/include/smart_objects/number_schema_item.h b/src/components/smart_objects/include/smart_objects/number_schema_item.h
index f5dd8ba42b..fb4d287fe4 100644
--- a/src/components/smart_objects/include/smart_objects/number_schema_item.h
+++ b/src/components/smart_objects/include/smart_objects/number_schema_item.h
@@ -85,7 +85,10 @@ class TNumberSchemaItem : public CDefaultSchemaItem<NumberType> {
   TNumberSchemaItem(const TSchemaItemParameter<NumberType>& MinValue,
                     const TSchemaItemParameter<NumberType>& MaxValue,
                     const TSchemaItemParameter<NumberType>& DefaultValue);
-  bool isNumberType(SmartType type);
+  /**
+   * @brief Compares if param value type is correct
+   **/
+  bool isValidNumberType(SmartType type);
 
   /**
    * @brief Minimum and Maximum allowed values.
@@ -105,16 +108,27 @@ TNumberSchemaItem<NumberType>::create(
 }
 
 template<typename NumberType>
-bool TNumberSchemaItem<NumberType>::isNumberType(SmartType type) {
-  return SmartType_Integer == type || SmartType_Double == type;
+bool TNumberSchemaItem<NumberType>::isValidNumberType(SmartType type) {
+  NumberType value(0);
+  if ((SmartType_Double == type) &&
+	  (typeid(double) == typeid(value))) {
+	  return true;
+  } else if ((SmartType_Integer == type) &&
+		     (typeid(int32_t) == typeid(value)  ||
+		      typeid(uint32_t) == typeid(value) ||
+		      typeid(int64_t) == typeid(value))) {
+	  return true;
+  } else {
+	  return false;
+  }
 }
 
 template<typename NumberType>
 Errors::eType TNumberSchemaItem<NumberType>::validate(const SmartObject& Object) {
-  if (!isNumberType(Object.getType())) {
+  if (!isValidNumberType(Object.getType())) {
     return Errors::INVALID_VALUE;
   }
-  NumberType value;
+  NumberType value(0);
   if (typeid(int32_t) == typeid(value)) {
     value = Object.asInt();
   } else if (typeid(uint32_t) == typeid(value)) {
diff --git a/src/components/smart_objects/include/smart_objects/smart_object.h b/src/components/smart_objects/include/smart_objects/smart_object.h
index 6a2b7b7f4e..bd70b7ea11 100644
--- a/src/components/smart_objects/include/smart_objects/smart_object.h
+++ b/src/components/smart_objects/include/smart_objects/smart_object.h
@@ -114,6 +114,13 @@ typedef std::map<std::string, SmartObject> SmartMap;
  **/
 typedef std::vector<uint8_t> SmartBinary;
 
+typedef utils::SharedPtr<SmartObject> SmartObjectSPtr;
+
+/**
+ * @brief List of SmartObjects
+ */
+typedef std::vector<SmartObjectSPtr> SmartObjectList;
+
 /**
  * @brief Main SmartObject class
  *
diff --git a/src/components/smart_objects/test/AlwaysFalseSchemaItem_test.cc b/src/components/smart_objects/test/AlwaysFalseSchemaItem_test.cc
new file mode 100644
index 0000000000..cf1d107ba2
--- /dev/null
+++ b/src/components/smart_objects/test/AlwaysFalseSchemaItem_test.cc
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2014, 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 <string>
+
+#include "gmock/gmock.h"
+
+#include "smart_objects/smart_object.h"
+#include "smart_objects/always_false_schema_item.h"
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SchemaItem {
+using namespace NsSmartDeviceLink::NsSmartObjects;
+
+/**
+ * Test AlwaysFalseSchemaItem
+ **/
+TEST(test_AlwaysFalseSchemaItemTest, simple_test) {
+  SmartObject obj;
+
+  ISchemaItemPtr item = CAlwaysFalseSchemaItem::create();
+
+  obj = 5;
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::ERROR, resultType);
+  EXPECT_EQ(5, obj.asInt());
+
+  obj = true;
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::ERROR, resultType);
+  EXPECT_TRUE(obj.asBool());
+
+  obj = "Test";
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::ERROR, resultType);
+  EXPECT_EQ(std::string("Test"), obj.asString());
+
+  obj["First"] = "Some string";
+  obj["Second"] = 555;
+  resultType = item->validate(obj["First"]);
+  EXPECT_EQ(Errors::ERROR, resultType);
+  resultType = item->validate(obj["Second"]);
+  EXPECT_EQ(Errors::ERROR, resultType);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::ERROR, resultType);
+  EXPECT_EQ(std::string("Some string"), obj["First"].asString());
+  EXPECT_EQ(555, obj["Second"].asInt());
+
+  obj[0] = true;
+  obj[1] = false;
+  resultType = item->validate(obj[0]);
+  EXPECT_EQ(Errors::ERROR, resultType);
+  resultType = item->validate(obj[1]);
+  EXPECT_EQ(Errors::ERROR, resultType);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::ERROR, resultType);
+  EXPECT_TRUE(obj[0].asBool());
+  EXPECT_FALSE(obj[1].asBool());
+}
+}  // namespace SchemaItem
+}  // namespace SmartObjects
+}  // namespace components
+}  // namespace test
diff --git a/src/components/smart_objects/test/AlwaysTrueSchemaItem_test.cc b/src/components/smart_objects/test/AlwaysTrueSchemaItem_test.cc
new file mode 100644
index 0000000000..a29567293d
--- /dev/null
+++ b/src/components/smart_objects/test/AlwaysTrueSchemaItem_test.cc
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2014, 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 <string>
+
+#include "gmock/gmock.h"
+
+#include "smart_objects/smart_object.h"
+#include "smart_objects/always_true_schema_item.h"
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SchemaItem {
+
+using namespace NsSmartDeviceLink::NsSmartObjects;
+
+/**
+ * Test AlwaysTrueSchemaItem
+ **/
+TEST(test_AlwaysTrueSchemaItemTest, simple_test) {
+  SmartObject obj;
+
+  ISchemaItemPtr item = CAlwaysTrueSchemaItem::create();
+
+  obj = 5;
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_EQ(5, obj.asInt());
+
+  obj = true;
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_TRUE(obj.asBool());
+
+  obj = "Test";
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_EQ(std::string("Test"), obj.asString());
+
+  obj["First"] = "Some string";
+  obj["Second"] = 555;
+  resultType = item->validate(obj["First"]);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj["Second"]);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_EQ(std::string("Some string"), obj["First"].asString());
+  EXPECT_EQ(555, obj["Second"].asInt());
+
+  obj[0] = true;
+  obj[1] = false;
+  resultType = item->validate(obj[0]);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj[1]);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_TRUE(obj[0].asBool());
+  EXPECT_FALSE(obj[1].asBool());
+}
+}  // namespace SchemaItem
+}  // namespace SmartObjects
+}  // namespace components
+}  // namespace test
diff --git a/src/components/smart_objects/test/ArraySchemaItem_test.cc b/src/components/smart_objects/test/ArraySchemaItem_test.cc
new file mode 100644
index 0000000000..e8cad40126
--- /dev/null
+++ b/src/components/smart_objects/test/ArraySchemaItem_test.cc
@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) 2014, 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 <string>
+
+#include "gmock/gmock.h"
+
+#include "smart_objects/smart_object.h"
+#include "smart_objects/array_schema_item.h"
+#include "smart_objects/string_schema_item.h"
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SchemaItem {
+
+/**
+ * Test ArraySchemaItem no schema item, no min and max size
+ **/
+TEST(test_no_default_value, test_ArraySchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+  SmartObject obj;
+
+  ISchemaItemPtr item = CArraySchemaItem::create();  // No schema item, no min and max size
+
+  obj[0] = 38;
+  obj[1] = true;
+  obj[2] = "New String";
+  obj[3][0] = 39;
+  obj[3][1] = false;
+  obj[3][2] = "Another String";
+
+  EXPECT_EQ(38, obj[0].asInt());
+  EXPECT_TRUE(obj[1].asBool());
+  EXPECT_EQ(std::string("New String"), obj[2].asString());
+  EXPECT_EQ(39, obj[3][0].asInt());
+  EXPECT_FALSE(obj[3][1].asBool());
+  EXPECT_EQ(std::string("Another String"), obj[3][2].asString());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj[0]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resultType = item->validate(obj[1]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resultType = item->validate(obj[2]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resultType = item->validate(obj[3]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  item->applySchema(obj);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj[0]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resultType = item->validate(obj[1]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resultType = item->validate(obj[2]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resultType = item->validate(obj[3]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  EXPECT_EQ(38, obj[0].asInt());
+  EXPECT_TRUE(obj[1].asBool());
+  EXPECT_EQ(std::string("New String"), obj[2].asString());
+  EXPECT_EQ(39, obj[3][0].asInt());
+  EXPECT_FALSE(obj[3][1].asBool());
+  EXPECT_EQ(std::string("Another String"), obj[3][2].asString());
+
+  //Object - valid string
+  obj = "New valid string";
+  ASSERT_EQ(std::string("New valid string"), obj.asString());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  //Obj - bool
+  obj = true;
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  //Object - number
+  obj = 3.1415926;
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+}
+
+/**
+ * Test ArraySchemaItem with schema item
+ *
+ * Create ArraySchemaItem with schema item. Method validate should return true
+ * only if all array elements are valid schema item objects
+ **/
+TEST(test_item_with_default_value, test_ArraySchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+  SmartObject obj;
+
+  ISchemaItemPtr item = CArraySchemaItem::create();  // No min and max size
+
+  obj[0] = "Some String";
+  obj[1] = "true";
+  obj[2] = "New String";
+
+  EXPECT_EQ(std::string("Some String"), obj[0].asString());
+  EXPECT_EQ(std::string("true"), obj[1].asString());
+  EXPECT_EQ(std::string("New String"), obj[2].asString());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj[0]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resultType = item->validate(obj[1]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resultType = item->validate(obj[2]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  item->applySchema(obj);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj[0]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resultType = item->validate(obj[1]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resultType = item->validate(obj[2]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  EXPECT_EQ(std::string("Some String"), obj[0].asString());
+  EXPECT_EQ(std::string("true"), obj[1].asString());
+  EXPECT_EQ(std::string("New String"), obj[2].asString());
+
+  obj[3][0] = "39";
+  obj[3][1] = "false";
+  obj[3][2] = "Another String";
+
+  EXPECT_EQ(std::string("39"), obj[3][0].asString());
+  EXPECT_EQ(std::string("false"), obj[3][1].asString());
+  EXPECT_EQ(std::string("Another String"), obj[3][2].asString());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj[3]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  obj[3][3] = "Another very very loooooong String";
+
+  resultType = item->validate(obj[3]);
+  EXPECT_EQ(Errors::OK, resultType);
+}
+
+/**
+ * Test ArraySchemaItem with min size
+ **/
+TEST(test_array_with_min_size, test_ArraySchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+  SmartObject obj;
+
+  ISchemaItemPtr item = CArraySchemaItem::create(
+      CStringSchemaItem::create(TSchemaItemParameter<size_t>(25)),
+      TSchemaItemParameter<size_t>(3));
+
+  obj[0] = "Some String";
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  obj[1] = "true";
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  obj[2] = "New String";
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  EXPECT_EQ(std::string("Some String"), obj[0].asString());
+  EXPECT_EQ(std::string("true"), obj[1].asString());
+  EXPECT_EQ(std::string("New String"), obj[2].asString());
+}
+
+/**
+ * Test ArraySchemaItem with min size
+ **/
+TEST(test_array_with_max_size, test_ArraySchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+  SmartObject obj;
+
+  ISchemaItemPtr item = CArraySchemaItem::create(
+      CStringSchemaItem::create(TSchemaItemParameter<size_t>(),
+                                TSchemaItemParameter<size_t>(25)),
+      TSchemaItemParameter<size_t>(), TSchemaItemParameter<size_t>(3));  // No min size
+
+  obj[0] = "Some String";
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  obj[1] = "true";
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  obj[2] = "New String";
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  obj[3] = "Another String";
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  EXPECT_EQ(std::string("Some String"), obj[0].asString());
+  EXPECT_EQ(std::string("true"), obj[1].asString());
+  EXPECT_EQ(std::string("New String"), obj[2].asString());
+  EXPECT_EQ(std::string("Another String"), obj[3].asString());
+}
+
+/**
+ * Test ArraySchemaItem with min and max size
+ **/
+TEST(test_array_with_min_and_max_size, test_ArraySchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+  SmartObject obj;
+
+  ISchemaItemPtr item = CArraySchemaItem::create(
+      CStringSchemaItem::create(TSchemaItemParameter<size_t>(),
+                                TSchemaItemParameter<size_t>(25)),
+      TSchemaItemParameter<size_t>(2), TSchemaItemParameter<size_t>(4));
+
+  obj[0] = "Some String";
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  obj[1] = "true";
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  obj[2] = "New String";
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  obj[3] = "Another String";
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  obj[4] = "Out of array";
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  EXPECT_EQ(std::string("Some String"), obj[0].asString());
+  EXPECT_EQ(std::string("true"), obj[1].asString());
+  EXPECT_EQ(std::string("New String"), obj[2].asString());
+  EXPECT_EQ(std::string("Another String"), obj[3].asString());
+  EXPECT_EQ(std::string("Out of array"), obj[4].asString());
+}
+
+TEST(test_map_validate, test_ArraySchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+  SmartObject obj;
+
+  ISchemaItemPtr item = CArraySchemaItem::create(
+      CStringSchemaItem::create(TSchemaItemParameter<size_t>(),
+                                TSchemaItemParameter<size_t>(25)),
+      TSchemaItemParameter<size_t>(2), TSchemaItemParameter<size_t>(4));
+
+  obj["array"][0] = "Some String";
+
+  int resultType = item->validate(obj["array"]);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  obj["array"][1] = "true";
+
+  resultType = item->validate(obj["array"]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  obj["array"][2] = "New String";
+
+  resultType = item->validate(obj["array"]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  obj["array"][3] = "Another String";
+
+  resultType = item->validate(obj["array"]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  obj["array"][4] = "Out of array";
+
+  resultType = item->validate(obj["array"]);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  EXPECT_EQ(std::string("Some String"), obj["array"][0].asString());
+  EXPECT_EQ(std::string("true"), obj["array"][1].asString());
+  EXPECT_EQ(std::string("New String"), obj["array"][2].asString());
+  EXPECT_EQ(std::string("Another String"), obj["array"][3].asString());
+  EXPECT_EQ(std::string("Out of array"), obj["array"][4].asString());
+}
+}  // namespace SchemaItem
+}  // namespace SmartObjects
+}  // namespace components
+}  // namespace test
+
diff --git a/src/components/smart_objects/test/BoolSchemaItem_test.cc b/src/components/smart_objects/test/BoolSchemaItem_test.cc
new file mode 100644
index 0000000000..c56dd9aa2d
--- /dev/null
+++ b/src/components/smart_objects/test/BoolSchemaItem_test.cc
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2014, 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 <string>
+
+#include "gmock/gmock.h"
+
+#include "utils/shared_ptr.h"
+
+#include "smart_objects/smart_object.h"
+#include "smart_objects/bool_schema_item.h"
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SchemaItem {
+using NsSmartDeviceLink::NsSmartObjects::ISchemaItemPtr;
+
+/**
+ * Test BoolSchemaItem no default value
+ *
+ * Create SchemaItem without default value. Method setDefaultValue should always return false
+ * and leave SmartObject in previous state.
+ **/
+TEST(test_no_default_value, test_BoolSchemaItemTest) {
+  NsSmartDeviceLink::NsSmartObjects::SmartObject obj;
+
+  ISchemaItemPtr item =
+      NsSmartDeviceLink::NsSmartObjects::CBoolSchemaItem::create();  // No default value
+
+  obj = 5;
+  ASSERT_EQ(5, obj.asInt());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+
+  obj = true;
+  ASSERT_TRUE(obj.asBool());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  EXPECT_TRUE(obj.asBool());
+
+  obj = "Test";
+  ASSERT_EQ(std::string("Test"), obj.asString());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+}
+
+/**
+ * Test BoolSchemaItem with default value
+ *
+ * Create SchemaItem with default value. Method setDefaultValue should return true,
+ * Bool SmartObject should contain default value.
+ * Not bool SmartObject should converted to BoolObject and setted up by default value.
+ **/
+TEST(test_item_with_default_value, test_BoolSchemaItemTest) {
+  NsSmartDeviceLink::NsSmartObjects::SmartObject obj;
+
+  ISchemaItemPtr item =
+      NsSmartDeviceLink::NsSmartObjects::CBoolSchemaItem::create(
+          NsSmartDeviceLink::NsSmartObjects::TSchemaItemParameter<bool>(false));  // Default value = false
+
+  obj = 5;
+  ASSERT_EQ(5, obj.asInt());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+
+  obj = true;
+  ASSERT_TRUE(obj.asBool());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_FALSE(obj.asBool());
+
+  obj = "Test";
+  ASSERT_EQ(std::string("Test"), obj.asString());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_FALSE(obj.asBool());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+  EXPECT_FALSE(obj.asBool());
+}
+
+TEST(test_map_validate, test_BoolSchemaItemTest) {
+  NsSmartDeviceLink::NsSmartObjects::SmartObject obj;
+  ISchemaItemPtr item =
+      NsSmartDeviceLink::NsSmartObjects::CBoolSchemaItem::create(
+          NsSmartDeviceLink::NsSmartObjects::TSchemaItemParameter<bool>(false));  // Default value = false
+
+  obj["aa"] = true;
+  ASSERT_TRUE(obj["aa"].asBool());
+
+  int resultType = item->validate(obj["aa"]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+
+  bool resDefault = item->setDefaultValue(obj["aa"]);
+  EXPECT_TRUE(resDefault);
+  EXPECT_FALSE(obj["aa"].asBool());
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_FALSE(obj.asBool());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+
+  obj["ind"] = true;
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+}
+
+TEST(test_array_validate, test_BoolSchemaItemTest) {
+  NsSmartDeviceLink::NsSmartObjects::SmartObject obj;
+  ISchemaItemPtr item =
+      NsSmartDeviceLink::NsSmartObjects::CBoolSchemaItem::create();
+
+  obj[0] = true;
+  obj[1] = false;
+
+  ASSERT_TRUE(obj[0].asBool());
+  ASSERT_FALSE(obj[1].asBool());
+
+  int resultType = item->validate(obj[0]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+
+  resultType = item->validate(obj[1]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+
+  bool resDefault = item->setDefaultValue(obj[0]);
+  EXPECT_FALSE(resDefault);
+  EXPECT_TRUE(obj[0].asBool());
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  EXPECT_FALSE(obj[1].asBool());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+
+  obj = false;
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+}
+}  // namespace SchemaItem"
+}  // namespace SmartObjects"
+}  // namespace components"
+}  // namespace test"
diff --git a/src/components/smart_objects/test/CMakeLists.txt b/src/components/smart_objects/test/CMakeLists.txt
new file mode 100644
index 0000000000..fbcd78cdc1
--- /dev/null
+++ b/src/components/smart_objects/test/CMakeLists.txt
@@ -0,0 +1,68 @@
+# Copyright (c) 2014, 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.
+
+if(BUILD_TESTS)
+add_definitions(-DUNIT_TESTS)
+
+include_directories (
+  ${GMOCK_INCLUDE_DIRECTORY}
+  ${COMPONENTS_DIR}/smart_objects/include
+  ${COMPONENTS_DIR}/formatters/include/
+  ${JSONCPP_INCLUDE_DIRECTORY}
+)
+
+set(LIBRARIES
+    gmock_main
+    SmartObjects
+    formatters
+    jsoncpp   
+)
+
+set(SOURCES
+  ${COMPONENTS_DIR}/smart_objects/test/SmartObjectDraft_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/SmartObjectInvalid_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/SmartObjectStress_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/SmartObjectUnit_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/TSharedPtr_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/smart_object_performance_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/map_performance_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/main.cc
+  ${COMPONENTS_DIR}/smart_objects/test/BoolSchemaItem_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/NumberSchemaItem_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/StringSchemaItem_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/ArraySchemaItem_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/CObjectSchemaItem_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/AlwaysTrueSchemaItem_test.cc
+  ${COMPONENTS_DIR}/smart_objects/test/AlwaysFalseSchemaItem_test.cc
+)
+
+create_test("smart_object_test" "${SOURCES}" "${LIBRARIES}")
+
+endif()
diff --git a/src/components/smart_objects/test/CObjectSchemaItem_test.cc b/src/components/smart_objects/test/CObjectSchemaItem_test.cc
new file mode 100644
index 0000000000..56f365e5c4
--- /dev/null
+++ b/src/components/smart_objects/test/CObjectSchemaItem_test.cc
@@ -0,0 +1,453 @@
+/*
+ * Copyright (c) 2014, 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 <string>
+
+#include "gmock/gmock.h"
+#include "smart_objects/smart_object.h"
+#include "smart_objects/smart_schema.h"
+#include "smart_objects/array_schema_item.h"
+#include "smart_objects/bool_schema_item.h"
+#include "smart_objects/string_schema_item.h"
+#include "smart_objects/enum_schema_item.h"
+#include "smart_objects/number_schema_item.h"
+#include "smart_objects/schema_item_parameter.h"
+#include "smart_objects/object_schema_item.h"
+#include "formatters/generic_json_formatter.h"
+#include "formatters/CSmartFactory.hpp"
+
+namespace formatters = NsSmartDeviceLink::NsJSONHandler::Formatters;
+namespace smartobj = NsSmartDeviceLink::NsSmartObjects;
+
+using namespace NsSmartDeviceLink::NsSmartObjects;
+using namespace NsSmartDeviceLink::NsJSONHandler::strings;
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SchemaItem {
+
+namespace FunctionID {
+enum eType {
+  INVALID_ENUM = -1,
+  Function0 = 0,
+  Function1,
+  Function2,
+  Function3,
+  Function4,
+  Function5,
+  Function6
+};
+}  // namespace FunctionID
+
+namespace ResultType {
+enum eType {
+  INVALID_ENUM = -1,
+  APPLICATION_NOT_REGISTERED = 0,
+  SUCCESS,
+  TOO_MANY_PENDING_REQUESTS,
+  REJECTED,
+  INVALID_DATA,
+  OUT_OF_MEMORY,
+  ABORTED,
+  USER_DISALLOWED,
+  GENERIC_ERROR,
+  DISALLOWED
+};
+}  // namespace ResultType
+
+namespace Keys {
+const char RESULT_CODE[] = "resultCode";
+const char INFO[] = "info";
+const char SUCCESS[] = "success";
+}
+
+class ObjectSchemaItemTest : public ::testing::Test {
+ protected:
+  ISchemaItemPtr schema_item;
+  // Create SmartObjectSchema for test object
+  void SetUp() {
+    std::set<FunctionID::eType> function_values;
+    function_values.insert(FunctionID::Function0);
+    function_values.insert(FunctionID::Function1);
+    function_values.insert(FunctionID::Function2);
+    function_values.insert(FunctionID::Function3);
+    function_values.insert(FunctionID::Function4);
+    function_values.insert(FunctionID::Function5);
+    function_values.insert(FunctionID::Function6);
+
+    std::set<ResultType::eType> resultCode_values;
+    resultCode_values.insert(ResultType::APPLICATION_NOT_REGISTERED);
+    resultCode_values.insert(ResultType::SUCCESS);
+    resultCode_values.insert(ResultType::TOO_MANY_PENDING_REQUESTS);
+    resultCode_values.insert(ResultType::REJECTED);
+    resultCode_values.insert(ResultType::INVALID_DATA);
+    resultCode_values.insert(ResultType::OUT_OF_MEMORY);
+    resultCode_values.insert(ResultType::ABORTED);
+    resultCode_values.insert(ResultType::USER_DISALLOWED);
+    resultCode_values.insert(ResultType::GENERIC_ERROR);
+    resultCode_values.insert(ResultType::DISALLOWED);
+
+    CObjectSchemaItem::Members paramsMembersMap;
+    paramsMembersMap[S_FUNCTION_ID] = CObjectSchemaItem::SMember(
+        TEnumSchemaItem<FunctionID::eType>::create(function_values), true);
+    paramsMembersMap[S_CORRELATION_ID] = CObjectSchemaItem::SMember(
+        TNumberSchemaItem<int>::create(), true);
+    paramsMembersMap[S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(
+        TNumberSchemaItem<int>::create(TSchemaItemParameter<int>(1),
+                                       TSchemaItemParameter<int>(2)),
+        true);
+
+    CObjectSchemaItem::Members schemaMembersMap;
+    schemaMembersMap[Keys::RESULT_CODE] = CObjectSchemaItem::SMember(
+        TEnumSchemaItem<ResultType::eType>::create(resultCode_values), false);
+    schemaMembersMap[Keys::INFO] = CObjectSchemaItem::SMember(
+        CStringSchemaItem::create(TSchemaItemParameter<size_t>(0),
+                                  TSchemaItemParameter<size_t>(10)),
+        false);
+    schemaMembersMap[Keys::SUCCESS] = CObjectSchemaItem::SMember(
+        CBoolSchemaItem::create(), false);
+
+    CObjectSchemaItem::Members rootMembersMap;
+    rootMembersMap[S_PARAMS] = CObjectSchemaItem::SMember(
+        CObjectSchemaItem::create(paramsMembersMap), true);
+    rootMembersMap[S_MSG_PARAMS] = CObjectSchemaItem::SMember(
+        CObjectSchemaItem::create(schemaMembersMap), true);
+
+    schema_item = CObjectSchemaItem::create(rootMembersMap);
+  }
+};
+
+TEST_F(ObjectSchemaItemTest, validation_correct) {
+  SmartObject obj;
+  obj[S_PARAMS][S_FUNCTION_ID] = 0;
+  obj[S_PARAMS][S_CORRELATION_ID] = 0XFF0;
+  obj[S_PARAMS][S_PROTOCOL_VERSION] = 1;
+  obj[S_MSG_PARAMS][Keys::RESULT_CODE] = 0;
+  obj[S_MSG_PARAMS][Keys::INFO] = "0123456789";
+  obj[S_MSG_PARAMS][Keys::SUCCESS] = true;
+
+  EXPECT_EQ(Errors::OK, schema_item->validate(obj));
+}
+
+TEST_F(ObjectSchemaItemTest, validation_correct_skip_not_mandatory) {
+  SmartObject obj;
+  obj[S_PARAMS][S_FUNCTION_ID] = 1;
+  obj[S_PARAMS][S_CORRELATION_ID] = -0xFF1;
+  obj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  obj[S_MSG_PARAMS][Keys::RESULT_CODE] = 1;
+  // skip non-mandatory obj[S_MSG_PARAMS][Keys::INFO]
+  obj[S_MSG_PARAMS][Keys::SUCCESS] = false;
+
+  EXPECT_EQ(Errors::OK, schema_item->validate(obj));
+}
+
+TEST_F(ObjectSchemaItemTest, validation_invalid_param) {
+  SmartObject obj;
+  obj[S_PARAMS] = "some parameters";
+  obj[S_MSG_PARAMS] = "some message parameters";
+
+  EXPECT_EQ(Errors::INVALID_VALUE, schema_item->validate(obj));
+
+  obj[S_PARAMS][S_FUNCTION_ID] = "some function";
+  obj[S_PARAMS][S_CORRELATION_ID] = "some correlation id";
+  obj[S_PARAMS][S_PROTOCOL_VERSION] = 3;
+  obj[S_MSG_PARAMS][Keys::RESULT_CODE] = "some result";
+  obj[S_MSG_PARAMS][Keys::SUCCESS] = 0xABC;
+
+  EXPECT_EQ(Errors::INVALID_VALUE, schema_item->validate(obj));
+
+  obj[S_PARAMS][S_FUNCTION_ID] = 1;
+  EXPECT_EQ(Errors::INVALID_VALUE, schema_item->validate(obj));
+
+  obj[S_PARAMS][S_CORRELATION_ID] = -0xFF1;
+  EXPECT_EQ(Errors::INVALID_VALUE, schema_item->validate(obj));
+
+  obj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  EXPECT_EQ(Errors::INVALID_VALUE, schema_item->validate(obj));
+
+  obj[S_MSG_PARAMS][Keys::RESULT_CODE] = 1;
+  EXPECT_EQ(Errors::INVALID_VALUE, schema_item->validate(obj));
+
+  obj[S_MSG_PARAMS][Keys::SUCCESS] = false;
+
+  EXPECT_EQ(Errors::OK, schema_item->validate(obj));
+}
+TEST_F(ObjectSchemaItemTest, validation_invalid_not_mandatory_param) {
+  SmartObject obj;
+  obj[S_PARAMS][S_FUNCTION_ID] = 0;
+  obj[S_PARAMS][S_CORRELATION_ID] = 0XFF0;
+  obj[S_PARAMS][S_PROTOCOL_VERSION] = 1;
+  obj[S_MSG_PARAMS][Keys::RESULT_CODE] = 0;
+  obj[S_MSG_PARAMS][Keys::SUCCESS] = true;
+
+  // invalid non-mandatory obj[S_MSG_PARAMS][Keys::INFO]
+  obj[S_MSG_PARAMS][Keys::INFO] = 0x10;
+  EXPECT_EQ(Errors::INVALID_VALUE, schema_item->validate(obj));
+
+  // invalid non-mandatory obj[S_MSG_PARAMS][Keys::INFO]
+  obj[S_MSG_PARAMS][Keys::INFO] = true;
+  EXPECT_EQ(Errors::INVALID_VALUE, schema_item->validate(obj));
+
+  // invalid non-mandatory obj[S_MSG_PARAMS][Keys::INFO]
+  obj[S_MSG_PARAMS][Keys::INFO] = SmartObject();
+  EXPECT_EQ(Errors::INVALID_VALUE, schema_item->validate(obj));
+
+  obj[S_MSG_PARAMS][Keys::INFO] = "info";
+  EXPECT_EQ(Errors::OK, schema_item->validate(obj));
+}
+
+TEST_F(ObjectSchemaItemTest, validation_missing_mandatory) {
+  SmartObject obj;
+  // missed obj[S_PARAMS][S_FUNCTION_ID]
+  // missed obj[S_PARAMS][S_CORRELATION_ID]
+  // missed obj[S_PARAMS][S_PROTOCOL_VERSION]
+  obj[S_MSG_PARAMS][Keys::RESULT_CODE] = 2;
+  obj[S_MSG_PARAMS][Keys::INFO] = "123";
+  obj[S_MSG_PARAMS][Keys::SUCCESS] = false;
+
+  EXPECT_EQ(Errors::MISSING_MANDATORY_PARAMETER, schema_item->validate(obj));
+
+  obj[S_PARAMS][S_FUNCTION_ID] = 2;
+  // S_CORRELATION_ID and S_PROTOCOL_VERSION is still missed
+  EXPECT_EQ(Errors::MISSING_MANDATORY_PARAMETER, schema_item->validate(obj));
+
+  obj[S_PARAMS][S_CORRELATION_ID] = 0XFF2;
+  // S_PROTOCOL_VERSION is still missed
+  EXPECT_EQ(Errors::MISSING_MANDATORY_PARAMETER, schema_item->validate(obj));
+
+  obj[S_PARAMS][S_PROTOCOL_VERSION] = 1;
+  EXPECT_EQ(Errors::OK, schema_item->validate(obj));
+}
+
+TEST_F(ObjectSchemaItemTest, validation_unexpected_param) {
+  const char* fake1 = "FAKE_PARAM1";
+  const char* fake2 = "FAKE_PARAM2";
+  const char* fake3 = "FAKE_PARAM3";
+
+  SmartObject obj;
+  obj[S_PARAMS][S_FUNCTION_ID] = 0;
+  obj[S_PARAMS][S_CORRELATION_ID] = 0XFF;
+  obj[S_PARAMS][S_PROTOCOL_VERSION] = 1;
+  obj[S_MSG_PARAMS][Keys::RESULT_CODE] = 2;
+  obj[S_MSG_PARAMS][Keys::INFO] = "123";
+  obj[S_MSG_PARAMS][Keys::SUCCESS] = true;
+
+  obj[fake1] = SmartObject(static_cast<int64_t>(0));
+  // any fake parameter is OK
+  EXPECT_EQ(Errors::OK, schema_item->validate(obj));
+
+  obj[S_PARAMS][fake2] = SmartObject("123");
+  // any fake parameters are OK
+  EXPECT_EQ(Errors::OK, schema_item->validate(obj));
+
+  obj[S_MSG_PARAMS][fake3] = true;
+  // any fake parameters are OK
+  EXPECT_EQ(Errors::OK, schema_item->validate(obj));
+}
+
+TEST_F(ObjectSchemaItemTest, validation_unexpected_param_remove) {
+  const char* fake1 = "FAKE_PARAM1";
+  const char* fake2 = "FAKE_PARAM2";
+  const char* fake3 = "FAKE_PARAM3";
+
+  SmartObject obj = SmartObject(SmartType::SmartType_Map);
+  obj[S_PARAMS][S_FUNCTION_ID] = 0;
+  obj[S_PARAMS][S_CORRELATION_ID] = 0XFF;
+  obj[S_PARAMS][S_PROTOCOL_VERSION] = 1;
+  obj[S_MSG_PARAMS][Keys::RESULT_CODE] = 2;
+  obj[S_MSG_PARAMS][Keys::INFO] = "123";
+  obj[S_MSG_PARAMS][Keys::SUCCESS] = true;
+
+  obj[fake1] = SmartObject(static_cast<int64_t>(0));
+  obj[S_PARAMS][fake2] = SmartObject("123");
+  obj[S_MSG_PARAMS][fake3] = true;
+
+  // Check apply schema
+  schema_item->applySchema(obj);
+
+  EXPECT_TRUE(obj.keyExists(fake1));
+  EXPECT_TRUE(obj[S_PARAMS].keyExists(fake2));
+  EXPECT_TRUE(obj[S_MSG_PARAMS].keyExists(fake3));
+  EXPECT_EQ(Errors::OK, schema_item->validate(obj));
+
+  // all fake parameters are removed on unapply schema
+  schema_item->unapplySchema(obj);
+
+  EXPECT_FALSE(obj.keyExists(fake1));
+  EXPECT_FALSE(obj[S_PARAMS].keyExists(fake2));
+  EXPECT_FALSE(obj[S_MSG_PARAMS].keyExists(fake3));
+
+  obj[fake1] = SmartObject(static_cast<int64_t>(0));
+  obj[S_PARAMS][fake2] = SmartObject("123");
+  obj[S_MSG_PARAMS][fake3] = true;
+
+  // Check unapply schema
+  schema_item->unapplySchema(obj);
+  // all fake parameters are removed on apply schema
+  EXPECT_FALSE(obj.keyExists(fake1));
+  EXPECT_FALSE(obj[S_PARAMS].keyExists(fake2));
+  EXPECT_FALSE(obj[S_MSG_PARAMS].keyExists(fake3));
+  // Invalide state after enum convertion
+  EXPECT_EQ(Errors::INVALID_VALUE, schema_item->validate(obj));
+}
+
+TEST_F(ObjectSchemaItemTest, validation_empty_params) {
+  SmartObject obj;
+  obj[S_PARAMS][S_FUNCTION_ID] = 1;
+  obj[S_PARAMS][S_CORRELATION_ID] = 0xFF;
+  obj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  obj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  // S_MSG_PARAMS has only fake parameter
+  obj[S_MSG_PARAMS]["FAKE_PARAM1"] = SmartObject();
+  obj[S_MSG_PARAMS]["FAKE_PARAM2"] = SmartObject(0x1);
+  obj[S_MSG_PARAMS]["FAKE_PARAM3"] = SmartObject("2");
+
+  EXPECT_EQ(Errors::OK, schema_item->validate(obj));
+
+  schema_item->applySchema(obj);
+  EXPECT_EQ(Errors::OK, schema_item->validate(obj));
+
+  schema_item->unapplySchema(obj);
+  // Invalide state after enum convertion
+  EXPECT_EQ(Errors::INVALID_VALUE, schema_item->validate(obj));
+}
+
+TEST_F(ObjectSchemaItemTest, test_strings_to_enum_conversion) {
+  SmartObject object;
+  object[S_PARAMS][S_FUNCTION_ID] = SmartObject();
+  object[S_PARAMS][S_CORRELATION_ID] = 0XFF0;
+  object[S_PARAMS][S_PROTOCOL_VERSION] = 1;
+  object[S_MSG_PARAMS][Keys::RESULT_CODE] = SmartObject();
+  object[S_MSG_PARAMS][Keys::INFO] = "0123456789";
+  object[S_MSG_PARAMS][Keys::SUCCESS] = true;
+
+  typedef EnumConversionHelper<ResultType::eType>::CStringToEnumMap Results;
+  const Results results =
+      EnumConversionHelper<ResultType::eType>::cstring_to_enum_map();
+
+  typedef EnumConversionHelper<FunctionID::eType>::CStringToEnumMap Functions;
+  const Functions functions =
+      EnumConversionHelper<FunctionID::eType>::cstring_to_enum_map();
+
+  for (Results::const_iterator res_it = results.begin();
+      res_it != results.end(); ++res_it) {
+    for (Functions::const_iterator func_it = functions.begin();
+        func_it != functions.end(); ++func_it) {
+      const char* const function_str = func_it->first;
+      const char* const result_type_str = res_it->first;
+      const FunctionID::eType function_type = func_it->second;
+      const ResultType::eType result_type = res_it->second;
+
+      object[S_PARAMS][S_FUNCTION_ID] = function_str;
+      object[S_MSG_PARAMS][Keys::RESULT_CODE] = result_type_str;
+
+      // S_FUNCTION_ID and RESULT_CODE are not converted to int
+      EXPECT_NE(Errors::OK, schema_item->validate(object));
+
+      schema_item->applySchema(object);
+      EXPECT_EQ(Errors::OK, schema_item->validate(object));
+
+      // check conversion result
+      EXPECT_EQ(function_type, object[S_PARAMS][S_FUNCTION_ID].asInt());
+      EXPECT_EQ(result_type, object[S_MSG_PARAMS][Keys::RESULT_CODE].asInt());
+
+      schema_item->unapplySchema(object);
+      // S_FUNCTION_ID and RESULT_CODE are string
+      EXPECT_NE(Errors::OK, schema_item->validate(object));
+
+      // check conversion result
+      EXPECT_EQ(function_str, object[S_PARAMS][S_FUNCTION_ID].asString());
+      EXPECT_EQ(result_type_str,
+                object[S_MSG_PARAMS][Keys::RESULT_CODE].asString());
+    }
+  }
+}
+// ----------------------------------------------------------------------------
+}// namespace SchemaItem
+}  // namespace SmartObjects
+}  // namespace components
+}  // namespace test
+
+namespace NsSmartDeviceLink {
+namespace NsSmartObjects {
+
+namespace FunctionID = test::components::SmartObjects::SchemaItem::FunctionID;
+typedef EnumConversionHelper<FunctionID::eType> FunctionConvertor;
+
+template<>
+const FunctionConvertor::EnumToCStringMap FunctionConvertor::enum_to_cstring_map_ =
+    FunctionConvertor::InitEnumToCStringMap();
+
+template<>
+const FunctionConvertor::CStringToEnumMap FunctionConvertor::cstring_to_enum_map_ =
+    FunctionConvertor::InitCStringToEnumMap();
+
+template<>
+const char* const FunctionConvertor::cstring_values_[] =
+    { "Function0", "Function1", "Function2", "Function3", "Function4",
+        "Function5", "Function6" };
+
+template<>
+const FunctionID::eType FunctionConvertor::enum_values_[] = {
+    FunctionID::Function0, FunctionID::Function1, FunctionID::Function2,
+    FunctionID::Function3, FunctionID::Function4, FunctionID::Function5,
+    FunctionID::Function6 };
+
+// ----------------------------------------------------------------------------
+
+namespace ResultType = test::components::SmartObjects::SchemaItem::ResultType;
+typedef EnumConversionHelper<ResultType::eType> ResultTypeConvertor;
+
+template<>
+const ResultTypeConvertor::EnumToCStringMap ResultTypeConvertor::enum_to_cstring_map_ =
+    ResultTypeConvertor::InitEnumToCStringMap();
+
+template<>
+const ResultTypeConvertor::CStringToEnumMap ResultTypeConvertor::cstring_to_enum_map_ =
+    ResultTypeConvertor::InitCStringToEnumMap();
+
+template<>
+const char* const ResultTypeConvertor::cstring_values_[] = {
+    "APPLICATION_NOT_REGISTERED", "SUCCESS", "TOO_MANY_PENDING_REQUESTS",
+    "REJECTED", "INVALID_DATA", "OUT_OF_MEMORY", "ABORTED", "USER_DISALLOWED",
+    "GENERIC_ERROR", "DISALLOWED" };
+
+template<>
+const ResultType::eType ResultTypeConvertor::enum_values_[] = {
+    ResultType::APPLICATION_NOT_REGISTERED, ResultType::SUCCESS,
+    ResultType::TOO_MANY_PENDING_REQUESTS, ResultType::REJECTED,
+    ResultType::INVALID_DATA, ResultType::OUT_OF_MEMORY, ResultType::ABORTED,
+    ResultType::USER_DISALLOWED, ResultType::GENERIC_ERROR,
+    ResultType::DISALLOWED };
+}  // namespace NsSmartObjects
+}  // namespace NsSmartDeviceLink
diff --git a/src/components/smart_objects/test/EnumSchemaItem_test.cc b/src/components/smart_objects/test/EnumSchemaItem_test.cc
new file mode 100644
index 0000000000..e99e2f4e66
--- /dev/null
+++ b/src/components/smart_objects/test/EnumSchemaItem_test.cc
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) 2014, 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 "gmock/gmock.h"
+
+#include "smart_objects/smart_object.h"
+#include "smart_objects/enum_schema_item.h"
+#include "smart_objects/string_schema_item.h"
+
+#include <string>
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SchemaItem {
+
+using namespace NsSmartDeviceLink::NsSmartObjects;
+namespace TestType {
+enum eType {
+  INVALID_ENUM = -1,
+  USER_EXIT = 0,
+  IGNITION_OFF,
+  BLUETOOTH_OFF,
+  USB_DISCONNECTED,
+  TOO_MANY_REQUESTS,
+  MASTER_RESET,
+  FACTORY_DEFAULTS,
+  APP_UNAUTHORIZED
+};
+}
+
+class EnumSchemaItemTest : public ::testing::Test {
+ protected:
+  EnumSchemaItemTest() {
+    testEnum.insert(TestType::USER_EXIT);
+    testEnum.insert(TestType::IGNITION_OFF);
+    testEnum.insert(TestType::BLUETOOTH_OFF);
+    testEnum.insert(TestType::USB_DISCONNECTED);
+    testEnum.insert(TestType::TOO_MANY_REQUESTS);
+    testEnum.insert(TestType::MASTER_RESET);
+    testEnum.insert(TestType::FACTORY_DEFAULTS);
+    testEnum.insert(TestType::APP_UNAUTHORIZED);
+  }
+
+  virtual void SetUp() {
+  }
+
+  std::set<TestType::eType> testEnum;
+};
+
+/**
+ * Test EnumSchemaItem
+ *
+ * Create SchemaItem with default value. Method setDefaultValue should return true,
+ * SmartObject should contain default value.
+ * Not Enum SmartObject should converted to intObject and setted up by the default value.
+ **/
+TEST_F(EnumSchemaItemTest, test_item_with_default_value) {
+  SmartObject obj;
+  ISchemaItemPtr item = TEnumSchemaItem<TestType::eType>::create(
+      testEnum,
+      TSchemaItemParameter<TestType::eType>(TestType::FACTORY_DEFAULTS));
+
+  //Object - valid enum
+  obj = TestType::BLUETOOTH_OFF;
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(TestType::FACTORY_DEFAULTS, obj.asInt());
+
+  //Obj - bool
+  obj = true;
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(TestType::FACTORY_DEFAULTS, obj.asInt());
+
+  //Object - number
+  obj = 3.1415926;
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(TestType::FACTORY_DEFAULTS, obj.asInt());
+
+  //Object - string
+  obj = "Some string";
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(TestType::FACTORY_DEFAULTS, obj.asInt());
+}
+
+/**
+ * Test EnumSchemaItem with default value
+ *
+ * Create SchemaItem without default value. Method setDefaultValue should return false,
+ * SmartObject should contain previous value.
+ **/
+TEST_F(EnumSchemaItemTest, test_item_without_default_value) {
+  SmartObject obj;
+
+  ISchemaItemPtr item = TEnumSchemaItem<TestType::eType>::create(
+      testEnum, TSchemaItemParameter<TestType::eType>());
+
+  //Object - valid enum
+  obj = TestType::BLUETOOTH_OFF;
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  EXPECT_EQ(TestType::BLUETOOTH_OFF, obj.asInt());
+
+  //Obj - bool
+  obj = true;
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  EXPECT_TRUE(obj.asBool());
+
+  //Object - number
+  obj = 3.1415926;
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  EXPECT_EQ(3.1415926, obj.asDouble());
+
+  //Object - string
+  obj = "Some string";
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  EXPECT_EQ(std::string("Some string"), obj.asString());
+
+  //Object - int in range of enum
+  obj = 6;
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object - int out of enum range
+  obj = 15;
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+}
+
+/**
+ * Test apply and unapply EnumSchemaItem
+ **/
+TEST_F(EnumSchemaItemTest, test_apply_unapply_schema) {
+  SmartObject obj;
+
+  ISchemaItemPtr item = TEnumSchemaItem<TestType::eType>::create(
+      testEnum,
+      TSchemaItemParameter<TestType::eType>(TestType::FACTORY_DEFAULTS));
+
+  //Object - valid enum
+  obj = TestType::BLUETOOTH_OFF;
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(TestType::FACTORY_DEFAULTS, obj.asInt());
+
+  item->unapplySchema(obj);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  EXPECT_EQ(std::string("FACTORY_DEFAULTS"), obj.asString());
+
+  item->applySchema(obj);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_EQ(TestType::FACTORY_DEFAULTS, obj.asInt());
+
+  obj = "TOO_MANY_REQUESTS";
+  item->applySchema(obj);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_EQ(TestType::TOO_MANY_REQUESTS, obj.asInt());
+
+  obj = "ENOUGH_REQUESTS";
+  item->applySchema(obj);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  EXPECT_EQ(std::string("ENOUGH_REQUESTS"), obj.asString());
+}
+
+}
+}
+}
+}
+
+namespace NsSmartDeviceLink {
+namespace NsSmartObjects {
+
+template<>
+const EnumConversionHelper<
+    test::components::SmartObjects::SchemaItem::TestType::eType>::EnumToCStringMap EnumConversionHelper<
+    test::components::SmartObjects::SchemaItem::TestType::eType>::enum_to_cstring_map_ =
+    EnumConversionHelper<
+        test::components::SmartObjects::SchemaItem::TestType::eType>::InitEnumToCStringMap();
+
+template<>
+const EnumConversionHelper<
+    test::components::SmartObjects::SchemaItem::TestType::eType>::CStringToEnumMap EnumConversionHelper<
+    test::components::SmartObjects::SchemaItem::TestType::eType>::cstring_to_enum_map_ =
+    EnumConversionHelper<
+        test::components::SmartObjects::SchemaItem::TestType::eType>::InitCStringToEnumMap();
+
+template<>
+const char* const EnumConversionHelper<
+    test::components::SmartObjects::SchemaItem::TestType::eType>::cstring_values_[] =
+    { "USER_EXIT", "IGNITION_OFF", "BLUETOOTH_OFF", "USB_DISCONNECTED",
+        "TOO_MANY_REQUESTS", "MASTER_RESET", "FACTORY_DEFAULTS",
+        "APP_UNAUTHORIZED" };
+
+template<>
+const test::components::SmartObjects::SchemaItem::TestType::eType EnumConversionHelper<
+    test::components::SmartObjects::SchemaItem::TestType::eType>::enum_values_[] =
+    { test::components::SmartObjects::SchemaItem::TestType::USER_EXIT,
+        test::components::SmartObjects::SchemaItem::TestType::IGNITION_OFF,
+        test::components::SmartObjects::SchemaItem::TestType::BLUETOOTH_OFF,
+        test::components::SmartObjects::SchemaItem::TestType::USB_DISCONNECTED,
+        test::components::SmartObjects::SchemaItem::TestType::TOO_MANY_REQUESTS,
+        test::components::SmartObjects::SchemaItem::TestType::MASTER_RESET,
+        test::components::SmartObjects::SchemaItem::TestType::FACTORY_DEFAULTS,
+        test::components::SmartObjects::SchemaItem::TestType::APP_UNAUTHORIZED };
+
+}
+}
diff --git a/src/components/smart_objects/test/NumberSchemaItem_test.cc b/src/components/smart_objects/test/NumberSchemaItem_test.cc
new file mode 100644
index 0000000000..6e372593f9
--- /dev/null
+++ b/src/components/smart_objects/test/NumberSchemaItem_test.cc
@@ -0,0 +1,780 @@
+/*
+ * Copyright (c) 2014, 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 <string>
+
+#include "gmock/gmock.h"
+#include "smart_objects/smart_object.h"
+#include "smart_objects/number_schema_item.h"
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SchemaItem {
+
+using NsSmartDeviceLink::NsSmartObjects::ISchemaItemPtr;
+
+/**
+ * Test NumberSchemaItem as INT with no default value
+ *
+ * Create SchemaItem without default value. Method setDefaultValue should always return false
+ * and leave SmartObject in previous state.
+ **/
+TEST(test_int_no_default_value, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<int>::create();  // No default value, no min, no max
+
+  //Object int
+  obj = 5;
+  ASSERT_EQ(5, obj.asInt());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Obj bool
+  obj = true;
+  ASSERT_TRUE(obj.asBool());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  //Set default value
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  EXPECT_TRUE(obj.asBool());
+
+  //Obj string
+  obj = "Test";
+  ASSERT_EQ(std::string("Test"), obj.asString());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+}
+
+/**
+ * Test NumberSchemaItem as INT with setted min value
+ **/
+TEST(test_int_min_value, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<int>::create(
+      TSchemaItemParameter<int>(10));  // No default value, no max value
+
+  //Object int correct
+  obj = 15;
+  ASSERT_EQ(15, obj.asInt());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object int incorrect
+  obj = 9;
+  ASSERT_EQ(9, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Object int correct
+  obj = 10;
+  ASSERT_EQ(10, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+}
+
+/**
+ * Test NumberSchemaItem as INT with setted max value
+ **/
+TEST(test_int_max_value, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<int>::create(
+      TSchemaItemParameter<int>(), TSchemaItemParameter<int>(749));  // No default value, no min value
+
+  //Object int correct
+  obj = 749;
+  ASSERT_EQ(749, obj.asInt());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object int incorrect
+  obj = 750;
+  ASSERT_EQ(750, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Object int correct
+  obj = -750;
+  ASSERT_EQ(-750, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+}
+
+/**
+ * Test NumberSchemaItem as INT with setted min and max value
+ **/
+TEST(test_int_min_max_value, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<int>::create(
+      TSchemaItemParameter<int>(-949), TSchemaItemParameter<int>(749));  // No default value
+
+  //Object int correct
+  obj = 749;
+  ASSERT_EQ(749, obj.asInt());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object int incorrect
+  obj = 750;
+  ASSERT_EQ(750, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Object int correct
+  obj = -949;
+  ASSERT_EQ(-949, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object int incorrect
+  obj = -950;
+  ASSERT_EQ(-950, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+}
+
+/**
+ * Test NumberSchemaItem as INT with correct default value
+ **/
+TEST(test_int_correct_default_value, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<int>::create(
+      TSchemaItemParameter<int>(-12000), TSchemaItemParameter<int>(100),
+      TSchemaItemParameter<int>(-38));
+
+  //Object int correct
+  obj = -12000;
+  ASSERT_EQ(-12000, obj.asInt());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object int incorrect
+  obj = -12001;
+  ASSERT_EQ(-12001, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Object int correct
+  obj = 100;
+  ASSERT_EQ(100, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object int incorrect
+  obj = 101;
+  ASSERT_EQ(101, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Set default value
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_EQ(-38, obj.asInt());
+
+  //Object string
+  obj = "string";
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_EQ(-38, obj.asInt());
+}
+
+/**
+ * Test NumberSchemaItem as INT with default value out of range
+ **/
+TEST(test_int_default_value_out_of_range, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<int>::create(
+      TSchemaItemParameter<int>(90), TSchemaItemParameter<int>(100),
+      TSchemaItemParameter<int>(50));  // Default value out of range
+
+  //Object int correct
+  obj = 90;
+  ASSERT_EQ(90, obj.asInt());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object int incorrect
+  obj = 89;
+  ASSERT_EQ(89, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Object int correct
+  obj = 100;
+  ASSERT_EQ(100, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object int incorrect
+  obj = 101;
+  ASSERT_EQ(101, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Set default value
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+  EXPECT_EQ(50, obj.asInt());
+
+  //Object string
+  obj = "string";
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+  EXPECT_EQ(50, obj.asInt());
+}
+
+TEST(test_int_map_validate, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<int>::create(
+      TSchemaItemParameter<int>(-120), TSchemaItemParameter<int>(100),
+      TSchemaItemParameter<int>(-38));
+
+  obj["min"] = -120;
+  obj["out_of_min"] = -121;
+  obj["max"] = 100;
+  obj["out_of_max"] = 101;
+
+  int resultType = item->validate(obj["min"]);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj["max"]);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj["out_of_min"]);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+  resultType = item->validate(obj["out_of_max"]);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  //Set default value
+  bool resDefault = item->setDefaultValue(obj["aa"]);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(-38, obj["aa"].asInt());
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(-38, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  resultType = item->validate(obj["min"]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+}
+
+TEST(test_int_array_validate, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<int>::create(
+      TSchemaItemParameter<int>(-120), TSchemaItemParameter<int>(100),
+      TSchemaItemParameter<int>(-38));
+
+  obj[0] = -121;
+  obj[1] = -120;
+  obj[2] = 100;
+  obj[3] = 101;
+
+  int resultType = item->validate(obj[0]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OUT_OF_RANGE,
+            resultType);
+
+  resultType = item->validate(obj[1]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+
+  resultType = item->validate(obj[2]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+
+  resultType = item->validate(obj[3]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OUT_OF_RANGE,
+            resultType);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+
+  bool resDefault = item->setDefaultValue(obj[0]);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(-38, obj[0].asInt());
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(-38, obj.asInt());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+
+  resultType = item->validate(obj[0]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+}
+
+/**
+ * Test NumberSchemaItem as DOUBLE with no default value
+ *
+ * Create SchemaItem without default value. Method setDefaultValue should always return false
+ * and leave SmartObject in previous state.
+ **/
+TEST(test_double_no_default_value, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<double>::create();  // No default value, no min, no max
+
+  //Object int
+  obj = 5.79;
+  ASSERT_EQ(5.79, obj.asDouble());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Obj bool
+  obj = true;
+  ASSERT_TRUE(obj.asBool());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  //Set default value
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  EXPECT_TRUE(obj.asBool());
+
+  //Obj string
+  obj = "Test";
+  ASSERT_EQ(std::string("Test"), obj.asString());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  //Set default value
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+}
+
+/**
+ * Test NumberSchemaItem as DOUBLE with setted min value
+ **/
+TEST(test_double_min_value, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<double>::create(
+      TSchemaItemParameter<double>(10.0));  // No default value, no max value
+
+  //Object double correct
+  obj = 10.000001;
+  ASSERT_EQ(10.000001, obj.asDouble());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object double incorrect
+  obj = 9.999999;
+  ASSERT_EQ(9.999999, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+  /*
+   //Object int
+   obj = 10;
+   ASSERT_EQ(10, obj.asInt());
+
+   resultType = item->validate(obj);
+   EXPECT_EQ(Errors::INVALID_VALUE, resultType);*/
+}
+
+/**
+ * Test NumberSchemaItem as DOUBLE with setted max value
+ **/
+TEST(test_double_max_value, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<double>::create(
+      TSchemaItemParameter<double>(), TSchemaItemParameter<double>(749.0));  // No default value, no min value
+
+  //Object double correct
+  obj = 749.0;
+  ASSERT_EQ(749.0, obj.asDouble());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object double incorrect
+  obj = 749.0001;
+  ASSERT_EQ(749.0001, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Object double correct
+  obj = -750.0;
+  ASSERT_EQ(-750.0, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+}
+
+/**
+ * Test NumberSchemaItem as DOUBLE with setted min and max value
+ **/
+TEST(test_double_min_max_value, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<double>::create(
+      TSchemaItemParameter<double>(-949.0),
+      TSchemaItemParameter<double>(749.0));  // No default value
+
+  //Object double correct
+  obj = 749.0;
+  ASSERT_EQ(749.0, obj.asDouble());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object double incorrect
+  obj = 749.001;
+  ASSERT_EQ(749.001, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Object double correct
+  obj = -949.0;
+  ASSERT_EQ(-949.0, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object double incorrect
+  obj = -949.00001;
+  ASSERT_EQ(-949.00001, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+}
+
+/**
+ * Test NumberSchemaItem as DOUBLE with correct default value
+ **/
+TEST(test_double_correct_default_value, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<double>::create(
+      TSchemaItemParameter<double>(-12000.0),
+      TSchemaItemParameter<double>(100.0), TSchemaItemParameter<double>(-38.0));
+
+  //Object double correct
+  obj = -12000.0;
+  ASSERT_EQ(-12000.0, obj.asDouble());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object double incorrect
+  obj = -12000.01;
+  ASSERT_EQ(-12000.01, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Object double correct
+  obj = 100.0;
+  ASSERT_EQ(100.0, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object double incorrect
+  obj = 100.001;
+  ASSERT_EQ(100.001, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Set default value
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_EQ(-38.0, obj.asDouble());
+
+  //Object string
+  obj = "string";
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_EQ(-38.0, obj.asDouble());
+}
+
+/**
+ * Test NumberSchemaItem as DOUBLE with default value out of range
+ **/
+TEST(test_double_default_value_out_of_range, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<double>::create(
+      TSchemaItemParameter<double>(90.0), TSchemaItemParameter<double>(100.0),
+      TSchemaItemParameter<double>(50.0));  // Default value out of range
+
+  //Object double correct
+  obj = 90.0;
+  ASSERT_EQ(90.0, obj.asDouble());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object double incorrect
+  obj = 89.999;
+  ASSERT_EQ(89.999, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Object double correct
+  obj = 100.0;
+  ASSERT_EQ(100.0, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  //Object double incorrect
+  obj = 100.001;
+  ASSERT_EQ(100.001, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  //Set default value
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+  EXPECT_EQ(50.0, obj.asDouble());
+
+  //Object string
+  obj = "string";
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+  EXPECT_EQ(50.0, obj.asDouble());
+}
+
+TEST(test_double_map_validate, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<double>::create(
+      TSchemaItemParameter<double>(-120.0), TSchemaItemParameter<double>(100.0),
+      TSchemaItemParameter<double>(-38.0));
+
+  obj["min"] = -120.0;
+  obj["out_of_min"] = -120.001;
+  obj["max"] = 100.0;
+  obj["out_of_max"] = 100.001;
+
+  int resultType = item->validate(obj["min"]);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj["max"]);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj["out_of_min"]);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+  resultType = item->validate(obj["out_of_max"]);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  bool resDefault = item->setDefaultValue(obj["aa"]);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(-38.0, obj["aa"].asDouble());
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(-38.0, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  resultType = item->validate(obj["min"]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+}
+
+TEST(test_double_array_validate, test_NumberSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+
+  SmartObject obj;
+
+  ISchemaItemPtr item = TNumberSchemaItem<double>::create(
+      TSchemaItemParameter<double>(-120.0), TSchemaItemParameter<double>(100.0),
+      TSchemaItemParameter<double>(-38.0));
+
+  obj[0] = -120.001;
+  obj[1] = -120.0;
+  obj[2] = 100.0;
+  obj[3] = 100.000001;
+
+  int resultType = item->validate(obj[0]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OUT_OF_RANGE,
+            resultType);
+
+  resultType = item->validate(obj[1]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+
+  resultType = item->validate(obj[2]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+
+  resultType = item->validate(obj[3]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OUT_OF_RANGE,
+            resultType);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+
+  bool resDefault = item->setDefaultValue(obj[0]);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(-38.0, obj[0].asDouble());
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(-38.0, obj.asDouble());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::OK, resultType);
+
+  resultType = item->validate(obj[0]);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(NsSmartDeviceLink::NsSmartObjects::Errors::INVALID_VALUE,
+            resultType);
+}
+}  // namespace SchemaItem
+}  // namespace SmartObjects
+}  // namespace components
+}  // namespace test
diff --git a/src/components/smart_objects/test/SmartObjectConvertionTime_test.cc b/src/components/smart_objects/test/SmartObjectConvertionTime_test.cc
new file mode 100644
index 0000000000..11a1ed3d2e
--- /dev/null
+++ b/src/components/smart_objects/test/SmartObjectConvertionTime_test.cc
@@ -0,0 +1,714 @@
+//TODO
+//this test file should be refactored. Now it doesn't test anything.
+//Previously it tests equality of objects but should test time for object's conversion
+/*
+ * Copyright (c) 2014, 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 "gmock/gmock.h"
+
+#include "utils/shared_ptr.h"
+
+#include "smart_objects/smart_object.h"
+#include "smart_objects/smart_schema.h"
+#include "smart_objects/schema_item.h"
+#include "formatters/CFormatterJsonSDLRPCv2.hpp"
+#include "formatters/CFormatterJsonSDLRPCv1.hpp"
+#include "smart_objects/array_schema_item.h"
+#include "smart_objects/bool_schema_item.h"
+#include "smart_objects/object_schema_item.h"
+#include "smart_objects/string_schema_item.h"
+#include "smart_objects/enum_schema_item.h"
+#include "smart_objects/number_schema_item.h"
+#include "smart_objects/schema_item_parameter.h"
+
+#include <string>
+#include <time.h>
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SmartObjectConvertionTimeTest {
+
+using namespace NsSmartDeviceLink::NsJSONHandler::strings;
+using namespace NsSmartDeviceLink::NsSmartObjects;
+
+namespace TestType {
+enum eType {
+  INVALID_ENUM = -1,
+  APPLICATION_NOT_REGISTERED = 0,
+  SUCCESS,
+  TOO_MANY_PENDING_REQUESTS,
+  REJECTED,
+  INVALID_DATA,
+  OUT_OF_MEMORY,
+  ABORTED,
+  USER_DISALLOWED,
+  GENERIC_ERROR,
+  DISALLOWED
+};
+}
+
+namespace FunctionIdTest {
+enum eType {
+  INVALID_ENUM = -1,
+  RegisterAppInterface,
+  UnregisterAppInterface,
+  SetGlobalProperties,
+};
+}
+
+namespace MessageTypeTest {
+enum eType {
+  INVALID_ENUM = -1,
+  request,
+  response,
+  notification
+};
+}
+
+class SmartObjectConvertionTimeTest : public ::testing::Test {
+ protected:
+
+  double getConvertionTimeToJsonV2Format(const SmartObject& srcObj,
+                                         std::string& jsonString) {
+    timespec convertionStartTime, convertionEndTime;
+    clock_gettime(CLOCK_REALTIME, &convertionStartTime);
+
+    // SmartObjects --> JSON
+    NsSmartDeviceLink::NsJSONHandler::Formatters::CFormatterJsonSDLRPCv2::toString(
+        srcObj, jsonString);
+
+    clock_gettime(CLOCK_REALTIME, &convertionEndTime);
+
+    return static_cast<double>(convertionEndTime.tv_sec
+        - convertionStartTime.tv_sec)
+        + static_cast<double>(convertionEndTime.tv_nsec
+            - convertionStartTime.tv_nsec) * 1e-9;
+  }
+
+  double getConvertionTimeFromJsonV2Format(std::string& jsonString,
+                                           SmartObject& dstObj) {
+    timespec convertionStartTime, convertionEndTime;
+    clock_gettime(CLOCK_REALTIME, &convertionStartTime);
+
+    // JSON --> SmartObjects
+    NsSmartDeviceLink::NsJSONHandler::Formatters::CFormatterJsonSDLRPCv2::fromString<
+        FunctionIdTest::eType, MessageTypeTest::eType>(
+        jsonString, dstObj, FunctionIdTest::RegisterAppInterface,
+        MessageTypeTest::request, 13);
+
+    clock_gettime(CLOCK_REALTIME, &convertionEndTime);
+    return static_cast<double>(convertionEndTime.tv_sec
+        - convertionStartTime.tv_sec)
+        + static_cast<double>(convertionEndTime.tv_nsec
+            - convertionStartTime.tv_nsec) * 1e-9;
+  }
+
+  double getConvertionTimeToJsonV1Format(const SmartObject& srcObj,
+                                         std::string& jsonString) {
+    timespec convertionStartTime, convertionEndTime;
+    clock_gettime(CLOCK_REALTIME, &convertionStartTime);
+
+    // SmartObjects --> JSON
+    NsSmartDeviceLink::NsJSONHandler::Formatters::CFormatterJsonSDLRPCv1::toString(
+        srcObj, jsonString);
+
+    clock_gettime(CLOCK_REALTIME, &convertionEndTime);
+    return static_cast<double>(convertionEndTime.tv_sec
+        - convertionStartTime.tv_sec)
+        + static_cast<double>(convertionEndTime.tv_nsec
+            - convertionStartTime.tv_nsec) * 1e-9;
+  }
+
+  double getConvertionTimeFromJsonV1Format(std::string& jsonString,
+                                           SmartObject& dstObj) {
+    timespec convertionStartTime, convertionEndTime;
+    clock_gettime(CLOCK_REALTIME, &convertionStartTime);
+
+    // JSON --> SmartObjects
+    NsSmartDeviceLink::NsJSONHandler::Formatters::CFormatterJsonSDLRPCv1::fromString<
+        FunctionIdTest::eType, MessageTypeTest::eType>(jsonString, dstObj);
+
+    clock_gettime(CLOCK_REALTIME, &convertionEndTime);
+    return static_cast<double>(convertionEndTime.tv_sec
+        - convertionStartTime.tv_sec)
+        + static_cast<double>(convertionEndTime.tv_nsec
+            - convertionStartTime.tv_nsec) * 1e-9;
+  }
+
+  void calculateConvertionTime(SmartObject& srcObj, SmartObject& dstObj) {
+    std::string jsonString;
+    double convertionToTime = 0.0;
+    double convertionFromTime = 0.0;
+    const int cycles = 1;
+
+    for (int i = 0; i < cycles; i++) {
+      convertionToTime += getConvertionTimeToJsonV1Format(srcObj, jsonString);
+//        printf("%s\n", jsonString.c_str());
+      convertionFromTime += getConvertionTimeFromJsonV1Format(jsonString,
+                                                              dstObj);
+    }
+    printf(
+        "Format V1. Convertion TO time = %.8f, Convertion FROM time = %.8f\n",
+        convertionToTime / cycles, convertionFromTime / cycles);
+
+    srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 1;       // adjust protocol version
+
+    srcObj.getSchema().applySchema(dstObj);
+    // The objects are different after remove non-schemed fields
+//      EXPECT_TRUE(srcObj == dstObj);
+
+    convertionToTime = 0.0;
+    convertionFromTime = 0.0;
+    for (int i = 0; i < cycles; i++) {
+      convertionToTime += getConvertionTimeToJsonV2Format(srcObj, jsonString);
+      convertionFromTime += getConvertionTimeFromJsonV2Format(jsonString,
+                                                              dstObj);
+    }
+    printf(
+        "Format V2. Convertion TO time = %.8f, Convertion FROM time = %.8f\n",
+        convertionToTime / cycles, convertionFromTime / cycles);
+
+    srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 2;       // adjust protocol version
+
+    dstObj.getSchema().applySchema(dstObj);
+    // The objects are different after remove non-schemed fields
+//      EXPECT_TRUE(srcObj == dstObj);
+  }
+
+  void calculateConvertionTimeWithJsonStringOutput(const SmartObject& srcObj,
+                                                   SmartObject& dstObj) {
+    std::string jsonString;
+    double convertionToTime = getConvertionTimeToJsonV1Format(srcObj,
+                                                              jsonString);
+    double convertionFromTime = getConvertionTimeFromJsonV1Format(jsonString,
+                                                                  dstObj);
+    printf("\nJSON string V1 = %s", jsonString.c_str());
+    printf(
+        "\nFormat V1. Convertion TO time = %.8f, Convertion FROM time = %.8f\n",
+        convertionToTime, convertionFromTime);
+
+    convertionToTime = getConvertionTimeToJsonV2Format(srcObj, jsonString);
+    convertionFromTime = getConvertionTimeFromJsonV2Format(jsonString, dstObj);
+    printf("\nJSON string V2 = %s", jsonString.c_str());
+    printf(
+        "\nFormat V2. Convertion TO time = %.8f, Convertion FROM time = %.8f\n",
+        convertionToTime, convertionFromTime);
+  }
+
+  // The basic Schema just for enum conversion (FunctionId and MessageType)
+  CSmartSchema initBasicObjectSchema() {
+    std::set<FunctionIdTest::eType> functionId_allowedEnumSubsetValues;
+    functionId_allowedEnumSubsetValues.insert(
+        FunctionIdTest::RegisterAppInterface);
+    functionId_allowedEnumSubsetValues.insert(
+        FunctionIdTest::UnregisterAppInterface);
+    functionId_allowedEnumSubsetValues.insert(
+        FunctionIdTest::SetGlobalProperties);
+
+    std::set<MessageTypeTest::eType> messageType_allowedEnumSubsetValues;
+    messageType_allowedEnumSubsetValues.insert(MessageTypeTest::request);
+    messageType_allowedEnumSubsetValues.insert(MessageTypeTest::response);
+    messageType_allowedEnumSubsetValues.insert(MessageTypeTest::notification);
+
+    ISchemaItemPtr functionId_SchemaItem =
+        TEnumSchemaItem<FunctionIdTest::eType>::create(
+            functionId_allowedEnumSubsetValues);
+
+    ISchemaItemPtr messageType_SchemaItem = TEnumSchemaItem<
+        MessageTypeTest::eType>::create(messageType_allowedEnumSubsetValues);
+
+    CObjectSchemaItem::Members paramsMembersMap;
+    paramsMembersMap[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] =
+        CObjectSchemaItem::SMember(functionId_SchemaItem, true);
+    paramsMembersMap[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] =
+        CObjectSchemaItem::SMember(messageType_SchemaItem, true);
+    paramsMembersMap[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] =
+        CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+    std::map<std::string, CObjectSchemaItem::SMember> rootMembersMap;
+    rootMembersMap[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] =
+        CObjectSchemaItem::SMember(CObjectSchemaItem::create(paramsMembersMap),
+                                   true);
+
+    return CSmartSchema(CObjectSchemaItem::create(rootMembersMap));
+  }
+
+  //Create SmartObjectSchema for test object
+  CSmartSchema initObjectSchema() {
+    std::set<TestType::eType> resultCode_allowedEnumSubsetValues;
+    resultCode_allowedEnumSubsetValues.insert(
+        TestType::APPLICATION_NOT_REGISTERED);
+    resultCode_allowedEnumSubsetValues.insert(TestType::SUCCESS);
+    resultCode_allowedEnumSubsetValues.insert(
+        TestType::TOO_MANY_PENDING_REQUESTS);
+    resultCode_allowedEnumSubsetValues.insert(TestType::REJECTED);
+    resultCode_allowedEnumSubsetValues.insert(TestType::INVALID_DATA);
+    resultCode_allowedEnumSubsetValues.insert(TestType::OUT_OF_MEMORY);
+    resultCode_allowedEnumSubsetValues.insert(TestType::ABORTED);
+    resultCode_allowedEnumSubsetValues.insert(TestType::USER_DISALLOWED);
+    resultCode_allowedEnumSubsetValues.insert(TestType::GENERIC_ERROR);
+    resultCode_allowedEnumSubsetValues.insert(TestType::DISALLOWED);
+
+    std::set<FunctionIdTest::eType> functionId_allowedEnumSubsetValues;
+    functionId_allowedEnumSubsetValues.insert(
+        FunctionIdTest::RegisterAppInterface);
+    functionId_allowedEnumSubsetValues.insert(
+        FunctionIdTest::UnregisterAppInterface);
+    functionId_allowedEnumSubsetValues.insert(
+        FunctionIdTest::SetGlobalProperties);
+
+    std::set<MessageTypeTest::eType> messageType_allowedEnumSubsetValues;
+    messageType_allowedEnumSubsetValues.insert(MessageTypeTest::request);
+    messageType_allowedEnumSubsetValues.insert(MessageTypeTest::response);
+    messageType_allowedEnumSubsetValues.insert(MessageTypeTest::notification);
+
+    ISchemaItemPtr success_SchemaItem = CBoolSchemaItem::create(
+        TSchemaItemParameter<bool>());
+
+    ISchemaItemPtr resultCode_SchemaItem =
+        TEnumSchemaItem<TestType::eType>::create(
+            resultCode_allowedEnumSubsetValues,
+            TSchemaItemParameter<TestType::eType>());
+
+    ISchemaItemPtr info_SchemaItem = CStringSchemaItem::create(
+        TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000),
+        TSchemaItemParameter<std::string>());
+
+    ISchemaItemPtr tryAgainTime_SchemaItem = TNumberSchemaItem<int>::create(
+        TSchemaItemParameter<int>(0), TSchemaItemParameter<int>(2000000000),
+        TSchemaItemParameter<int>());
+
+    std::map<std::string, CObjectSchemaItem::SMember> schemaMembersMap;
+
+    schemaMembersMap["success"] = CObjectSchemaItem::SMember(success_SchemaItem,
+                                                             true);
+    schemaMembersMap["resultCode"] = CObjectSchemaItem::SMember(
+        resultCode_SchemaItem, true);
+    schemaMembersMap["info"] = CObjectSchemaItem::SMember(info_SchemaItem,
+                                                          false);
+    schemaMembersMap["tryAgainTime"] = CObjectSchemaItem::SMember(
+        tryAgainTime_SchemaItem, true);
+
+    std::map<std::string, CObjectSchemaItem::SMember> paramsMembersMap;
+    paramsMembersMap[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] =
+        CObjectSchemaItem::SMember(
+            TEnumSchemaItem<FunctionIdTest::eType>::create(
+                functionId_allowedEnumSubsetValues),
+            true);
+    paramsMembersMap[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] =
+        CObjectSchemaItem::SMember(
+            TEnumSchemaItem<MessageTypeTest::eType>::create(
+                messageType_allowedEnumSubsetValues),
+            true);
+    paramsMembersMap[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] =
+        CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+    paramsMembersMap[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] =
+        CObjectSchemaItem::SMember(
+            TNumberSchemaItem<int>::create(TSchemaItemParameter<int>(1),
+                                           TSchemaItemParameter<int>(2)),
+            true);
+    paramsMembersMap[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] =
+        CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+    std::map<std::string, CObjectSchemaItem::SMember> rootMembersMap;
+    rootMembersMap[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] =
+        CObjectSchemaItem::SMember(CObjectSchemaItem::create(schemaMembersMap),
+                                   true);
+    rootMembersMap[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] =
+        CObjectSchemaItem::SMember(CObjectSchemaItem::create(paramsMembersMap),
+                                   true);
+    return CSmartSchema(CObjectSchemaItem::create(rootMembersMap));
+  }
+};
+
+TEST_F(SmartObjectConvertionTimeTest, test_int_object_convertion) {
+  SmartObject srcObj, dstObj;
+  CSmartSchema schema = initObjectSchema();
+
+  srcObj.setSchema(schema);
+  dstObj.setSchema(schema);
+
+  srcObj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request;
+  srcObj[S_PARAMS][S_FUNCTION_ID] = FunctionIdTest::RegisterAppInterface;
+  srcObj[S_PARAMS][S_CORRELATION_ID] = 13;
+  srcObj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 1;
+  srcObj[S_MSG_PARAMS]["value"] = 5;
+
+  printf("\n INT value.\n");
+  calculateConvertionTime(srcObj, dstObj);
+}
+
+TEST_F(SmartObjectConvertionTimeTest, test_double_object_convertion) {
+  SmartObject srcObj, dstObj;
+  CSmartSchema schema = initObjectSchema();
+
+  srcObj.setSchema(schema);
+  dstObj.setSchema(schema);
+
+  srcObj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request;
+  srcObj[S_PARAMS][S_FUNCTION_ID] = FunctionIdTest::RegisterAppInterface;
+  srcObj[S_PARAMS][S_CORRELATION_ID] = 13;
+  srcObj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  srcObj[S_MSG_PARAMS]["value1"] = 3.1415926;
+  srcObj[S_MSG_PARAMS]["value2"] = 32.6;
+  srcObj[S_MSG_PARAMS]["value3"] = 33.945;
+  srcObj[S_MSG_PARAMS]["value4"] = -12.5487698;
+  srcObj[S_MSG_PARAMS]["value5"] = 0.61287346;
+
+  printf("\n Double value.\n");
+  calculateConvertionTime(srcObj, dstObj);
+}
+
+TEST_F(SmartObjectConvertionTimeTest, test_some_object_convertion) {
+  SmartObject srcObj, dstObj;
+  CSmartSchema schema = initObjectSchema();
+
+  srcObj.setSchema(schema);
+  dstObj.setSchema(schema);
+
+  srcObj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request;
+  srcObj[S_PARAMS][S_FUNCTION_ID] = FunctionIdTest::RegisterAppInterface;
+  srcObj[S_PARAMS][S_CORRELATION_ID] = 13;
+  srcObj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  srcObj[S_MSG_PARAMS]["appId"] = "APP ID";
+  srcObj[S_MSG_PARAMS]["appName"] = "APP NAME";
+  srcObj[S_MSG_PARAMS]["appType"][0] = "SYSTEM";
+  srcObj[S_MSG_PARAMS]["appType"][1] = "COMMUNICATION";
+  srcObj[S_MSG_PARAMS]["hmiDisplayLanguageDesired"] = "RU-RU";
+  srcObj[S_MSG_PARAMS]["isMediaApplication"] = true;
+  srcObj[S_MSG_PARAMS]["languageDesired"] = "EN-US";
+  srcObj[S_MSG_PARAMS]["ngnMediaScreenAppName"] = "SCREEN NAME";
+  srcObj[S_MSG_PARAMS]["syncMsgVersion"]["majorVersion"] = 2;
+  srcObj[S_MSG_PARAMS]["syncMsgVersion"]["minorVersion"] = 10;
+  srcObj[S_MSG_PARAMS]["ttsName"][0]["text"] = "ABC";
+  srcObj[S_MSG_PARAMS]["ttsName"][0]["type"] = "TEXT";
+  srcObj[S_MSG_PARAMS]["vrSynonyms"][0] = "Synonym1";
+  srcObj[S_MSG_PARAMS]["vrSynonyms"][1] = "Synonym2";
+  srcObj[S_MSG_PARAMS]["null"] = SmartObject();
+  srcObj[S_MSG_PARAMS]["double"] = -0.1234;
+
+  printf("\n Random object.\n");
+  calculateConvertionTime(srcObj, dstObj);
+}
+
+TEST_F(SmartObjectConvertionTimeTest, test_map_object_convertion) {
+  SmartObject srcObj, dstObj, mapObj, innerObj;
+  CSmartSchema schema = initObjectSchema();
+
+  srcObj.setSchema(schema);
+  dstObj.setSchema(schema);
+
+  // First iteration
+  mapObj["request"]["name"] = "My Request";
+  mapObj["request"]["id"] = 123;
+  mapObj["response"]["name"] = "My Response";
+  mapObj["response"]["id"] = 456;
+  mapObj["we"]["need"]["to"]["go"]["deeper"] = true;
+
+  srcObj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request;
+  srcObj[S_PARAMS][S_FUNCTION_ID] = FunctionIdTest::RegisterAppInterface;
+  srcObj[S_PARAMS][S_CORRELATION_ID] = 13;
+  srcObj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  srcObj[S_MSG_PARAMS]["value"] = mapObj;
+
+  printf("\n MAP object.\n");
+  calculateConvertionTime(srcObj, dstObj);
+
+  // Second iteration
+  innerObj = mapObj;
+  mapObj["request"]["value"] = innerObj;
+  mapObj["response"]["value"] = innerObj;
+  mapObj["we"]["need"]["to"]["go"]["deeper"]["value"] = innerObj;
+  srcObj[S_MSG_PARAMS]["value"] = mapObj;
+
+  printf("\n Complex MAP object.\n");
+  calculateConvertionTime(srcObj, dstObj);
+
+  // Third iteration
+  innerObj = mapObj;
+  mapObj["request"]["value"] = innerObj;
+  mapObj["response"]["value"] = innerObj;
+  mapObj["we"]["need"]["to"]["go"]["deeper"]["value"] = innerObj;
+  srcObj[S_MSG_PARAMS]["value"] = mapObj;
+
+  printf("\n Very Complex MAP object.\n");
+  calculateConvertionTime(srcObj, dstObj);
+
+  // Last iteration
+  innerObj = mapObj;
+  mapObj["request"]["value"] = innerObj;
+  mapObj["response"]["value"] = innerObj;
+  mapObj["we"]["need"]["to"]["go"]["deeper"]["value"] = innerObj;
+  srcObj[S_MSG_PARAMS]["value"] = mapObj;
+
+  printf("\n Very Very Complex MAP object.\n");
+  calculateConvertionTime(srcObj, dstObj);
+}
+
+TEST_F(SmartObjectConvertionTimeTest, test_array_convertion) {
+  SmartObject srcObj, dstObj, arrayObj, innerObj;
+  CSmartSchema schema = initObjectSchema();
+  int arraySize = 10;
+
+  srcObj.setSchema(schema);
+  dstObj.setSchema(schema);
+
+  // First iteration
+  for (int i = 0; i < arraySize; i++) {
+    arrayObj[i] = rand();
+  }
+
+  srcObj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request;
+  srcObj[S_PARAMS][S_FUNCTION_ID] = FunctionIdTest::RegisterAppInterface;
+  srcObj[S_PARAMS][S_CORRELATION_ID] = 13;
+  srcObj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  srcObj[S_MSG_PARAMS]["array"] = arrayObj;
+
+  printf("\n Array object [%d].\n", arraySize);
+  calculateConvertionTime(srcObj, dstObj);
+
+  // Second iteration
+  printf("\n Array object [%d x %d].\n", arraySize, arraySize);
+  innerObj = arrayObj;
+  for (int i = 0; i < arraySize; i++) {
+    arrayObj[i] = innerObj;
+  }
+
+  srcObj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request;
+  srcObj[S_PARAMS][S_FUNCTION_ID] = FunctionIdTest::RegisterAppInterface;
+  srcObj[S_PARAMS][S_CORRELATION_ID] = 13;
+  srcObj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  srcObj[S_MSG_PARAMS]["array"] = arrayObj;
+
+  calculateConvertionTime(srcObj, dstObj);
+
+  // Third iteration
+  printf("\n Array object [%d x %d x %d].\n", arraySize, arraySize, arraySize);
+  innerObj = arrayObj;
+  for (int i = 0; i < arraySize; i++) {
+    arrayObj[i] = innerObj;
+  }
+
+  srcObj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request;
+  srcObj[S_PARAMS][S_FUNCTION_ID] = FunctionIdTest::RegisterAppInterface;
+  srcObj[S_PARAMS][S_CORRELATION_ID] = 13;
+  srcObj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  srcObj[S_MSG_PARAMS]["array"] = arrayObj;
+
+  calculateConvertionTime(srcObj, dstObj);
+
+  // Fourth iteration
+  printf("\n Array object [%d x %d x %d x %d].\n", arraySize, arraySize,
+         arraySize, arraySize);
+  innerObj = arrayObj;
+  for (int i = 0; i < arraySize; i++) {
+    arrayObj[i] = innerObj;
+  }
+
+  srcObj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request;
+  srcObj[S_PARAMS][S_FUNCTION_ID] = FunctionIdTest::RegisterAppInterface;
+  srcObj[S_PARAMS][S_CORRELATION_ID] = 13;
+  srcObj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  srcObj[S_MSG_PARAMS]["array"] = arrayObj;
+
+  calculateConvertionTime(srcObj, dstObj);
+
+  // Last iteration
+  printf("\n Array object [%d x %d x %d x %d x %d].\n", arraySize, arraySize,
+         arraySize, arraySize, arraySize);
+  innerObj = arrayObj;
+  for (int i = 0; i < arraySize; i++) {
+    arrayObj[i] = innerObj;
+  }
+
+  srcObj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request;
+  srcObj[S_PARAMS][S_FUNCTION_ID] = FunctionIdTest::RegisterAppInterface;
+  srcObj[S_PARAMS][S_CORRELATION_ID] = 13;
+  srcObj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  srcObj[S_MSG_PARAMS]["array"] = arrayObj;
+
+  calculateConvertionTime(srcObj, dstObj);
+}
+
+TEST_F(SmartObjectConvertionTimeTest, test_object_with_enum_convertion) {
+  SmartObject srcObj, dstObj;
+  CSmartSchema schema = initObjectSchema();
+
+  srcObj.setSchema(schema);
+  dstObj.setSchema(schema);
+
+  srcObj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request;
+  srcObj[S_PARAMS][S_FUNCTION_ID] = FunctionIdTest::RegisterAppInterface;
+  srcObj[S_PARAMS][S_CORRELATION_ID] = 13;
+  srcObj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  srcObj[S_MSG_PARAMS]["success"] = true;
+  srcObj[S_MSG_PARAMS]["resultCode"] = 2;
+  srcObj[S_MSG_PARAMS]["info"] = "Some string";
+  srcObj[S_MSG_PARAMS]["tryAgainTime"] = 322;
+  srcObj.setSchema(schema);
+
+  printf("\n Object with enum.\n");
+  calculateConvertionTime(srcObj, dstObj);
+}
+
+TEST_F(SmartObjectConvertionTimeTest, test_object_without_enum_convertion) {
+  SmartObject srcObj, dstObj;
+  CSmartSchema schema = initObjectSchema();
+
+  srcObj.setSchema(schema);
+  dstObj.setSchema(schema);
+
+  srcObj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request;
+  srcObj[S_PARAMS][S_FUNCTION_ID] = FunctionIdTest::RegisterAppInterface;
+  srcObj[S_PARAMS][S_CORRELATION_ID] = 13;
+  srcObj[S_PARAMS][S_PROTOCOL_TYPE] = 0;
+  srcObj[S_PARAMS][S_PROTOCOL_VERSION] = 2;
+  srcObj[S_MSG_PARAMS]["success"] = true;
+  srcObj[S_MSG_PARAMS]["resultCode"] = 2;
+  srcObj[S_MSG_PARAMS]["info"] = "Some string";
+  srcObj[S_MSG_PARAMS]["tryAgainTime"] = 322;
+
+  printf("\n Object without enum.\n");
+  calculateConvertionTime(srcObj, dstObj);
+}
+
+}
+}
+}
+}
+
+namespace NsSmartDeviceLink {
+namespace NsSmartObjects {
+
+template<>
+const EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::eType>::EnumToCStringMap EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::eType>::enum_to_cstring_map_ =
+    EnumConversionHelper<
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::eType>::InitEnumToCStringMap();
+
+template<>
+const EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::eType>::CStringToEnumMap EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::eType>::cstring_to_enum_map_ =
+    EnumConversionHelper<
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::eType>::InitCStringToEnumMap();
+
+template<>
+const char* const EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::eType>::cstring_values_[] =
+    { "APPLICATION_NOT_REGISTERED", "SUCCESS", "TOO_MANY_PENDING_REQUESTS",
+        "REJECTED", "INVALID_DATA", "OUT_OF_MEMORY", "ABORTED",
+        "USER_DISALLOWED", "GENERIC_ERROR", "DISALLOWED" };
+
+template<>
+const test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::eType EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::eType>::enum_values_[] =
+    {
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::APPLICATION_NOT_REGISTERED,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::SUCCESS,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::TOO_MANY_PENDING_REQUESTS,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::REJECTED,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::INVALID_DATA,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::OUT_OF_MEMORY,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::ABORTED,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::USER_DISALLOWED,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::GENERIC_ERROR,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::TestType::DISALLOWED };
+
+template<>
+const EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::eType>::EnumToCStringMap EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::eType>::enum_to_cstring_map_ =
+    EnumConversionHelper<
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::eType>::InitEnumToCStringMap();
+
+template<>
+const EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::eType>::CStringToEnumMap EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::eType>::cstring_to_enum_map_ =
+    EnumConversionHelper<
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::eType>::InitCStringToEnumMap();
+
+template<>
+const char* const EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::eType>::cstring_values_[] =
+    { "RegisterAppInterface", "UnregisterAppInterface", "SetGlobalProperties" };
+
+template<>
+const test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::eType EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::eType>::enum_values_[] =
+    {
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::RegisterAppInterface,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::UnregisterAppInterface,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::FunctionIdTest::SetGlobalProperties };
+
+template<>
+const EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::eType>::EnumToCStringMap EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::eType>::enum_to_cstring_map_ =
+    EnumConversionHelper<
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::eType>::InitEnumToCStringMap();
+
+template<>
+const EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::eType>::CStringToEnumMap EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::eType>::cstring_to_enum_map_ =
+    EnumConversionHelper<
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::eType>::InitCStringToEnumMap();
+
+template<>
+const char* const EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::eType>::cstring_values_[] =
+    { "request", "response", "notification" };
+
+template<>
+const test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::eType EnumConversionHelper<
+    test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::eType>::enum_values_[] =
+    {
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::request,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::response,
+        test::components::SmartObjects::SmartObjectConvertionTimeTest::MessageTypeTest::notification };
+
+}
+}
diff --git a/src/components/smart_objects/test/SmartObjectDraft_test.cc b/src/components/smart_objects/test/SmartObjectDraft_test.cc
new file mode 100644
index 0000000000..85c97c2625
--- /dev/null
+++ b/src/components/smart_objects/test/SmartObjectDraft_test.cc
@@ -0,0 +1,364 @@
+/*
+ * Copyright (c) 2014, 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 <string>
+#include <vector>
+
+#include "gmock/gmock.h"
+
+#include "smart_objects/smart_object.h"
+
+using ::testing::ElementsAre;
+using ::testing::ContainerEq;
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SmartObjectDraftTest {
+
+using NsSmartDeviceLink::NsSmartObjects::SmartObject;
+using NsSmartDeviceLink::NsSmartObjects::SmartType;
+
+TEST(SmartObjectsDraftTest, primitive_types) {
+  SmartObject obj;
+
+  obj = true;
+  ASSERT_TRUE(obj.asBool());
+  ASSERT_EQ(SmartType::SmartType_Boolean, obj.getType());
+
+  obj = 5;
+  ASSERT_EQ(5, obj.asInt());
+  ASSERT_EQ(SmartType::SmartType_Integer, obj.getType());
+
+  obj = 'A';
+  ASSERT_DOUBLE_EQ('A', obj.asChar());
+  ASSERT_EQ(SmartType::SmartType_Character, obj.getType());
+
+  obj = "Test";
+  ASSERT_EQ(std::string("Test"), obj.asString());
+  ASSERT_EQ(SmartType::SmartType_String, obj.getType());
+
+  obj = 6.0;
+  ASSERT_DOUBLE_EQ(6.0, obj.asDouble());
+  ASSERT_EQ(SmartType::SmartType_Double, obj.getType());
+}
+
+TEST(SmartObjectsDraftTest, test_map_access) {
+  SmartObject obj;
+
+  obj["aa"] = true;
+  ASSERT_TRUE(obj["aa"].asInt());
+  ASSERT_EQ(SmartType::SmartType_Map, obj.getType());
+
+  obj["aa"]["fds"]["Fsdf"] = 123;
+  ASSERT_EQ(123, obj["aa"]["fds"]["Fsdf"].asInt());
+  ASSERT_EQ(SmartType::SmartType_Map, obj.getType());
+}
+
+TEST(SmartObjectsDraftTest, test_array_access) {
+  SmartObject obj;
+
+  obj[0] = 5;
+  obj[-1] = 6;  //  Appending new item to array
+
+  ASSERT_EQ(5, obj[0].asInt());
+  ASSERT_EQ(6, obj[1].asInt());
+  ASSERT_EQ(SmartType::SmartType_Array, obj.getType());
+}
+
+TEST(SmartObjectsDraftTest, test_public_interface) {
+  SmartObject obj;
+
+  // ---- INTEGER ---- //
+  obj = 1;
+  ASSERT_EQ(1, obj.asInt());
+
+  // ---- unsigned int ---- //
+  obj = static_cast<unsigned int>(100);
+  ASSERT_EQ(100u, obj.asUInt());
+
+  // ---- DOUBLE ---- //
+  obj = 3.14;
+  ASSERT_EQ(3.14, obj.asDouble());
+
+  // ---- CHAR ---- //
+  obj = 'a';
+  ASSERT_EQ('a', obj.asChar());
+
+  // ---- BOOL ---- //
+  obj = true;
+  ASSERT_TRUE(obj.asBool());
+
+  // ---- CHAR* ---- //
+  obj = "Hello, world";
+  ASSERT_EQ(std::string("Hello, world"), obj.asString());
+
+  // ---- STD::STRING ---- //
+  obj = std::string("Hello, world");
+  ASSERT_EQ(std::string("Hello, world"), obj.asString());
+
+  // ---- Binary ---- //
+  NsSmartDeviceLink::NsSmartObjects::SmartBinary binaryData;
+  binaryData.push_back('\0');
+  binaryData.push_back('a');
+  obj = binaryData;
+  ASSERT_THAT(obj.asBinary(), ElementsAre('\0', 'a'));
+
+  // ---- ARRAY ---- //
+  obj[0] = 1;
+  obj[1] = true;
+  obj[2] = 'a';
+  obj[3] = 3.14;
+
+  ASSERT_EQ(1, obj[0].asInt());
+  ASSERT_TRUE(obj[1].asBool());
+  ASSERT_EQ('a', obj[2].asChar());
+  ASSERT_EQ(3.14, obj[3].asDouble());
+
+  // ---- DEEP ARRAY ---- //
+  obj[0] = 1;
+  obj[1][0] = 3.14;
+  obj[1][1][0] = true;
+
+  ASSERT_EQ(1, obj[0].asInt());
+  ASSERT_EQ(3.14, obj[1][0].asDouble());
+  ASSERT_TRUE(obj[1][1][0].asBool());
+
+  // ---- MAP ---- //
+  obj["name"] = "My name";
+  obj["count"] = 10;
+  obj["isValid"] = true;
+
+  ASSERT_EQ(std::string("My name"), obj["name"].asString());
+  ASSERT_EQ(10, obj["count"].asInt());
+  ASSERT_TRUE(obj["isValid"].asBool());
+
+  // ---- DEEP MAP ---- //
+  obj["request"]["name"] = "My Request";
+  obj["request"]["id"] = 123;
+  obj["response"]["name"] = "My Response";
+  obj["response"]["id"] = 456;
+  obj["we"]["need"]["to"]["go"]["deeper"] = true;
+
+  ASSERT_EQ(std::string("My Request"), obj["request"]["name"].asString());
+  ASSERT_EQ(123, obj["request"]["id"].asInt());
+  ASSERT_EQ(std::string("My Response"), obj["response"]["name"].asString());
+  ASSERT_EQ(456, obj["response"]["id"].asInt());
+  ASSERT_TRUE(obj["we"]["need"]["to"]["go"]["deeper"].asBool());
+}
+
+TEST(SmartObjectsDraftTest, test_helper_methods) {
+  SmartObject obj;
+
+  // ---- INTEGER ---- //
+  obj = 1;
+  ASSERT_EQ(1, obj.asInt());
+
+  // ---- unsigned int ---- //
+  obj = static_cast<unsigned int>(100);
+  ASSERT_EQ(100u, obj.asUInt());
+
+  // ---- DOUBLE ---- //
+  obj = 3.14;
+  ASSERT_EQ(3.14, obj.asDouble());
+  //TEST_COMPONENTS_SMART_OBJECTS_SMARTOBJECTDRAFTTEST_H_
+  // ---- CHAR ---- //
+  obj = 'a';
+  ASSERT_EQ('a', obj.asChar());
+
+  // ---- BOOL ---- //
+  obj = true;
+  ASSERT_TRUE(obj.asBool());
+
+  // ---- STD::STRING ---- //
+  obj = std::string("Hello, world");
+  ASSERT_EQ(std::string("Hello, world"), obj.asString());
+
+  // ---- Binary ---- //
+  NsSmartDeviceLink::NsSmartObjects::SmartBinary binaryData;
+  binaryData.push_back('\0');
+  binaryData.push_back('a');
+  obj = binaryData;
+  ASSERT_THAT(obj.asBinary(), ElementsAre('\0', 'a'));
+}
+
+TEST(SmartObjectsDraftTest, compare_empty_objects_by_types) {
+  ASSERT_EQ(SmartObject(), SmartObject());
+
+  std::vector<SmartType> smart_types;
+  smart_types.push_back(SmartType::SmartType_Null);
+  smart_types.push_back(SmartType::SmartType_Boolean);
+  smart_types.push_back(SmartType::SmartType_Integer);
+  smart_types.push_back(SmartType::SmartType_Character);
+  smart_types.push_back(SmartType::SmartType_String);
+  smart_types.push_back(SmartType::SmartType_Double);
+  smart_types.push_back(SmartType::SmartType_Map);
+  smart_types.push_back(SmartType::SmartType_Array);
+  smart_types.push_back(SmartType::SmartType_Binary);
+  smart_types.push_back(SmartType::SmartType_Invalid);
+
+  for (size_t i = 0u; i < smart_types.size(); ++i) {
+    const SmartType type_i = smart_types[i];
+    for (size_t j = 0u; j < smart_types.size(); ++j) {
+      const SmartType type_j = smart_types[i];
+      if (type_i == type_j) {
+        ASSERT_EQ(SmartObject(type_i), SmartObject(type_j));
+        ASSERT_EQ(SmartObject(type_j), SmartObject(type_i));
+      } else {
+        ASSERT_NE(SmartObject(type_i), SmartObject(type_j));
+        ASSERT_EQ(SmartObject(type_j), SmartObject(type_i));
+      }
+    }
+  }
+}
+
+TEST(SmartObjectsDraftTest, compare_integer_type) {
+  SmartObject value = SmartObject(0xFFFFF);
+  SmartObject same_value = SmartObject(static_cast<int64_t>(value.asInt()));
+
+  ASSERT_EQ(value, same_value);
+  ASSERT_EQ(same_value, value);
+
+  SmartObject other_value = SmartObject(0x00000);
+
+  ASSERT_NE(value, other_value);
+  ASSERT_NE(other_value, value);
+
+  ASSERT_NE(other_value, same_value);
+  ASSERT_NE(same_value, other_value);
+
+  ASSERT_NE(value, SmartObject());
+  ASSERT_NE(other_value, SmartObject());
+  ASSERT_NE(same_value, SmartObject());
+}
+
+TEST(SmartObjectsDraftTest, compare_double_type) {
+  SmartObject value = SmartObject(6.0);
+  SmartObject same_value = SmartObject(6.0);
+
+  ASSERT_EQ(value, same_value);
+  ASSERT_EQ(same_value, value);
+
+  SmartObject other_value = SmartObject(6.0000001);
+
+  ASSERT_NE(value, other_value);
+  ASSERT_NE(other_value, value);
+
+  ASSERT_NE(other_value, same_value);
+  ASSERT_NE(same_value, other_value);
+
+  ASSERT_NE(value, SmartObject());
+  ASSERT_NE(other_value, SmartObject());
+  ASSERT_NE(same_value, SmartObject());
+}
+
+TEST(SmartObjectsDraftTest, compare_bool_type) {
+  SmartObject value = SmartObject(true);
+  SmartObject same_value = SmartObject(true);
+
+  ASSERT_EQ(value, same_value);
+  ASSERT_EQ(same_value, value);
+
+  SmartObject other_value = SmartObject(false);
+
+  ASSERT_NE(value, other_value);
+  ASSERT_NE(other_value, value);
+
+  ASSERT_NE(other_value, same_value);
+  ASSERT_NE(same_value, other_value);
+
+  ASSERT_NE(value, SmartObject());
+  ASSERT_NE(other_value, SmartObject());
+  ASSERT_NE(same_value, SmartObject());
+}
+
+TEST(SmartObjectsDraftTest, compare_string_type) {
+  SmartObject value = SmartObject("Test string");
+  SmartObject same_value = SmartObject(std::string("Test string"));
+
+  ASSERT_EQ(value, same_value);
+  ASSERT_EQ(same_value, value);
+
+  SmartObject other_value = SmartObject("Other string");
+
+  ASSERT_NE(value, other_value);
+  ASSERT_NE(other_value, value);
+
+  ASSERT_NE(other_value, same_value);
+  ASSERT_NE(same_value, other_value);
+
+  ASSERT_NE(value, SmartObject());
+  ASSERT_NE(other_value, SmartObject());
+  ASSERT_NE(same_value, SmartObject());
+}
+
+TEST(SmartObjectsDraftTest, compare_map_type) {
+  SmartObject value;
+  value["KEY1"] = "VALUE1";
+  value["KEY2"] = 0;
+  value["KEY3"] = false;
+
+  SmartObject same_value;
+  same_value["KEY1"] = "VALUE1";
+  same_value["KEY2"] = 0;
+  same_value["KEY3"] = false;
+
+  ASSERT_EQ(value, same_value);
+  ASSERT_EQ(same_value, value);
+
+  SmartObject other_value;
+  other_value["KEY1"] = "VALUE1";
+  other_value["KEY2"] = 0;
+  // no KEY3 field
+
+  SmartObject other_value2;
+  other_value2["KEY1"] = "VALUE1";
+  other_value2["KEY2"] = 0;
+  // other ype of KEY3 field
+  other_value2["KEY3"] = "VALUE3";
+
+  ASSERT_NE(value, other_value);
+  ASSERT_NE(other_value, value);
+
+  ASSERT_NE(value, other_value2);
+  ASSERT_NE(other_value2, value);
+
+  ASSERT_NE(value, SmartObject());
+  ASSERT_NE(same_value, SmartObject());
+  ASSERT_NE(other_value, SmartObject());
+  ASSERT_NE(other_value2, SmartObject());
+}
+// TODO(Ezamakhov): add test for conversion string/int/double
+}// namespace SmartObjectDraftTest
+}  // namespace SmartObjects
+}  // namespace components
+}  // namespace test
diff --git a/src/components/smart_objects/test/SmartObjectInvalid_test.cc b/src/components/smart_objects/test/SmartObjectInvalid_test.cc
new file mode 100644
index 0000000000..6a3caf2950
--- /dev/null
+++ b/src/components/smart_objects/test/SmartObjectInvalid_test.cc
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2014, 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 <string>
+
+#include "gmock/gmock.h"
+
+#include "smart_objects/smart_object.h"
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SmartObjectInvalidTest {
+using namespace NsSmartDeviceLink::NsSmartObjects;
+
+TEST(test_SmartObjectInvalidTest, simple_type_can_be_set_in_constructor) {
+  SmartObject objMap(SmartType_Map);
+  ASSERT_EQ(SmartType_Map, objMap.getType());
+
+  SmartObject objArray(SmartType_Array);
+  ASSERT_EQ(SmartType_Array, objArray.getType());
+
+  SmartObject objInt(SmartType_Integer);
+  ASSERT_EQ(SmartType_Integer, objInt.getType());
+
+  SmartObject objDouble(SmartType_Double);
+  ASSERT_EQ(SmartType_Double, objDouble.getType());
+
+  SmartObject objBoolean(SmartType_Boolean);
+  ASSERT_EQ(SmartType_Boolean, objBoolean.getType());
+
+  SmartObject objChar(SmartType_Character);
+  ASSERT_EQ(SmartType_Character, objChar.getType());
+
+  SmartObject objString(SmartType_String);
+  ASSERT_EQ(SmartType_String, objString.getType());
+
+  SmartObject objBinary(SmartType_Binary);
+  ASSERT_EQ(SmartType_Binary, objBinary.getType());
+
+  SmartObject objInvalid(SmartType_Invalid);
+  ASSERT_EQ(SmartType_Invalid, objInvalid.getType());
+
+  SmartObject objNullConstructor(SmartType_Null);
+  ASSERT_EQ(SmartType_Null, objNullConstructor.getType());
+
+  SmartObject objNullDefault;
+  ASSERT_EQ(SmartType_Null, objNullDefault.getType());
+}
+
+TEST(test_SmartObjectInvalidTest, invalid_object_remains_invalid) {
+  SmartObject obj(SmartType_Invalid);
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+
+  obj = 1;
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+  ASSERT_EQ(invalid_int_value, obj.asInt());
+
+  // ---- unsigned int ---- //
+  obj = static_cast<unsigned int>(100);
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+  ASSERT_EQ(invalid_unsigned_int_value, obj.asUInt());
+
+  // ---- DOUBLE ---- //
+  obj = 3.14;
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+  ASSERT_EQ(invalid_double_value, obj.asDouble());
+
+  // ---- CHAR ---- //
+  obj = 'a';
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+  ASSERT_EQ(invalid_char_value, obj.asChar());
+
+  // ---- BOOL ---- //
+  obj = true;
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+  ASSERT_EQ(invalid_bool_value, obj.asBool());
+
+  // ---- CHAR* ---- //
+  obj = "Hello, world";
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+  ASSERT_EQ(invalid_string_value, obj.asString());
+
+  // ---- STD::STRING ---- //
+  obj = std::string("Hello, world");
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+  ASSERT_EQ(invalid_string_value, obj.asString());
+
+  // ---- BINARY ---- //
+  NsSmartDeviceLink::NsSmartObjects::SmartBinary binaryData;
+  binaryData.push_back('\0');
+  binaryData.push_back('a');
+  obj = binaryData;
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+  ASSERT_EQ(invalid_binary_value, obj.asBinary());
+
+  // ---- ARRAY ---- //
+  obj[0] = 1;
+  obj[1] = true;
+  obj[2] = 'a';
+  obj[3] = 3.14;
+
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+  ASSERT_EQ(invalid_int_value, obj[0].asInt());
+  ASSERT_EQ(invalid_bool_value, obj[1].asBool());
+  ASSERT_EQ(invalid_char_value, obj[2].asChar());
+  ASSERT_EQ(invalid_double_value, obj[3].asDouble());
+
+  // ---- DEEP ARRAY ---- //
+  obj[0] = 1;
+  obj[1][0] = 3.14;
+  obj[1][1][0] = true;
+
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+  ASSERT_EQ(invalid_int_value, obj[0].asInt());
+  ASSERT_EQ(invalid_double_value, obj[1][0].asDouble());
+  ASSERT_EQ(invalid_bool_value, obj[1][1][0].asBool());
+
+  // ---- MAP ---- //
+  obj["name"] = "My name";
+  obj["count"] = 10;
+  obj["isValid"] = true;
+
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+  ASSERT_EQ(invalid_string_value, obj["name"].asString());
+  ASSERT_EQ(invalid_int_value, obj["count"].asInt());
+  ASSERT_EQ(invalid_bool_value, obj["isValid"].asBool());
+
+  // ---- DEEP MAP ---- //
+  obj["request"]["name"] = "My Request";
+  obj["request"]["id"] = 123;
+  obj["response"]["name"] = "My Response";
+  obj["response"]["id"] = 456;
+  obj["we"]["need"]["to"]["go"]["deeper"] = true;
+
+  ASSERT_EQ(SmartType_Invalid, obj.getType());
+
+  ASSERT_EQ(invalid_string_value, obj["request"]["name"].asString());
+  ASSERT_EQ(invalid_int_value, obj["request"]["id"].asInt());
+  ASSERT_EQ(invalid_string_value, obj["response"]["name"].asString());
+  ASSERT_EQ(invalid_int_value, obj["response"]["id"].asInt());
+  ASSERT_EQ(invalid_bool_value,
+            obj["we"]["need"]["to"]["go"]["deeper"].asBool());
+}
+}  // namespace SmartObjectInvalidTest
+}  // namespace SmartObjects
+}  // namespace components
+}  // namespace test
diff --git a/src/components/smart_objects/test/SmartObjectStress_test.cc b/src/components/smart_objects/test/SmartObjectStress_test.cc
new file mode 100644
index 0000000000..4fb7b2efc0
--- /dev/null
+++ b/src/components/smart_objects/test/SmartObjectStress_test.cc
@@ -0,0 +1,336 @@
+/*
+ * Copyright (c) 2014, 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 <sstream>
+#include "gmock/gmock.h"
+#include "smart_objects/smart_object.h"
+
+//#define NO_INCLUSIVE_MAPS
+//#define COPY_SUB_OBJECTS_WORKAROUND
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SmartObjectStressTest {
+
+using namespace NsSmartDeviceLink::NsSmartObjects;
+
+class StressTestHelper : public ::testing::Test {
+ private:
+  char get_random_char() const {
+    return static_cast<char>('A' + (rand() % 52));
+  }
+
+  std::string to_string(const int value) const {
+    std::ostringstream oss;
+    oss << value;
+    return oss.str();
+  }
+
+  std::string to_string(const double value) const {
+    // Content is the same as in SmartObject::convert_double_to_string
+    std::stringstream ss;
+    ss << std::fixed << std::setprecision(10) << value;  //convert double to string w fixed notation, hi precision
+    std::string s = ss.str();                            //output to std::string
+    s.erase(s.find_last_not_of('0') + 1, std::string::npos);  //remove trailing 000s    (123.1200 => 123.12,  123.000 => 123.)
+    if (s[s.size() - 1] == '.') {
+      s.erase(s.end() - 1);              //remove dangling decimal (123. => 123)
+    }
+    return s;
+  }
+
+  std::string to_string(const char ch) const {
+    char buff[2];
+    sprintf(buff, "%c", ch);
+    return std::string(buff);
+  }
+
+  std::string to_string(const bool b) const {
+    return std::string((b) ? "true" : "false");
+  }
+
+ protected:
+  typedef std::map<std::string, std::string> VerificationMap;
+  VerificationMap mVerifyMap;
+
+  std::vector<std::string> split(const std::string &s, char delim) const {
+    std::vector < std::string > elems;
+
+    std::stringstream ss(s);
+    std::string item;
+    while (std::getline(ss, item, delim)) {
+      elems.push_back(item);
+    }
+
+    return elems;
+  }
+
+  std::string generate_key(const char *pPrefix, const int index) const {
+    char buff[32];
+    sprintf(buff, "%s%d", pPrefix, index);
+    return std::string(buff);
+  }
+
+  void makeRandomObject(SmartObject &obj, const int size,
+                        std::string key_path) {
+    int type_id = rand() % 8;
+
+    switch (type_id) {
+      case 0:     // int
+      {
+        int iVal = rand();
+        obj = iVal;
+        mVerifyMap[key_path] = to_string(iVal);
+        //std::cout << "Created int, value: " << iVal << std::endl;
+        break;
+      }
+      case 1:     // bool
+      {
+        bool bVal = static_cast<bool>(rand() % 2);
+        obj = bVal;
+        mVerifyMap[key_path] = to_string(bVal);
+        //std::cout << "Created bool, value: " << to_string(bVal) << std::endl;
+        break;
+      }
+      case 2:     // double
+      {
+        double dVal = 100.0 / (rand() % 200);
+        obj = dVal;
+        mVerifyMap[key_path] = to_string(dVal);
+        //std::cout << "Created double, value: " << dVal << std::endl;
+        break;
+      }
+      case 3:     // char
+      {
+        char cVal = get_random_char();
+        obj = cVal;
+        mVerifyMap[key_path] = to_string(cVal);
+        //std::cout << "Created char, value: " << cVal << std::endl;
+        break;
+      }
+      case 4:     // string
+      {
+        std::string strVal(rand() % 200, get_random_char());
+        obj = strVal;   // string with random char filled random size
+        mVerifyMap[key_path] = strVal;
+        //std::cout << "Created string, value: " << strVal << std::endl;
+        break;
+      }
+      case 5:     // map
+        if (size <= 0)
+          break;
+
+        //std::cout << "Creating a map with size: " << size << std::endl;
+        mVerifyMap[key_path] = "map";
+        for (int i = 0; i < size; i++) {
+          std::string key = generate_key("M", i);
+#ifdef NO_INCLUSIVE_MAPS
+          obj[key] = key;
+#else
+          obj[key] = SmartObject();
+          makeRandomObject(obj[key], size - 1, key_path + key + ' ');  // recursion
+#endif // MAP_WORKAROUND
+        }
+        break;
+      case 6:     // array
+        if (size <= 0)
+          break;
+
+        //std::cout << "Creating an array with size: " << size << std::endl;
+        mVerifyMap[key_path] = "array";
+        for (int i = 0; i < size; i++) {
+          obj[i] = SmartObject();      // just init it as an array
+          makeRandomObject(obj[i], size - 1,
+                           key_path + generate_key("A", i) + ' ');  // recursion
+        }
+        break;
+      case 7:     // binary
+        int dataSize = rand() % 200;
+        char randomChar = get_random_char();
+        std::string strDataVal(dataSize, randomChar);
+        std::string strVal("c:");
+        strVal += strDataVal;
+
+        NsSmartDeviceLink::NsSmartObjects::SmartBinary binaryVal(dataSize,
+                                                                 randomChar);
+
+        obj = binaryVal;   // string with binary data filled with random chars
+        mVerifyMap[key_path] = strVal;
+        //std::cout << "Created string, value: " << strVal << std::endl;
+        break;
+    }
+  }
+
+  SmartObject get_object(SmartObject &rootObj, const std::string &path) const {
+    std::vector < std::string > obj_tokens;
+    SmartObject lastObj = rootObj;
+
+    obj_tokens = split(path, ' ');
+
+    for (size_t i = 0; i < obj_tokens.size(); i++) {
+      if (obj_tokens[i][0] == 'A')            // array
+          {
+        int index = atoi(&(obj_tokens[i].c_str()[1]));  // get integer skipping first char
+#ifdef COPY_SUB_OBJECTS_WORKAROUND
+            lastObj = SmartObject(lastObj[index]);
+#else
+        lastObj = lastObj[index];       // go to the child object
+#endif
+      } else if (obj_tokens[i][0] == 'M')       // map
+          {
+#ifdef COPY_SUB_OBJECTS_WORKAROUND
+        lastObj = SmartObject(lastObj[obj_tokens[i]]);
+#else
+        lastObj = lastObj[obj_tokens[i]];       // go to the child object
+#endif
+      } else {
+        //FAIL();
+        EXPECT_TRUE(false);
+      }
+    }
+    return lastObj;
+  }
+};
+
+/*
+ * The test creates the initial SmartObject and use it as an array for the next SmartObjects.
+ * Each next SmartObject is randomly assigned to some type.
+ * If one of the object happens to be a container it fills it with SmartObject of random type. The amount of these
+ * objects is the size of the parent container -1.
+ * The iteration continues until all nodes are simple SmartObjects (not arrays or maps)
+ */
+TEST_F(StressTestHelper, StressTest) {
+  SmartObject objects;
+
+  const int size = 11;
+
+  for (int i = 0; i < size; i++) {
+    SmartObject obj;
+
+    makeRandomObject(obj, size - 1, generate_key("A", i) + ' ');
+
+    objects[i] = obj;
+  }
+
+  for (VerificationMap::const_iterator it = mVerifyMap.begin();
+      it != mVerifyMap.end(); it++) {
+    std::string value(it->second);
+    SmartObject obj = get_object(objects, it->first);
+
+    // Binary data check
+    if (!value.compare(0, 2, "c:")) {
+      std::string etalonData = value.substr(2);
+
+      ASSERT_EQ(NsSmartDeviceLink::NsSmartObjects::SmartType_Binary,
+                obj.getType());
+
+      NsSmartDeviceLink::NsSmartObjects::SmartBinary binaryData =
+          obj.asBinary();
+      ASSERT_EQ(etalonData.size(), binaryData.size());
+
+      for (size_t i = 0; i < etalonData.size(); ++i) {
+        {
+          std::string etalonData = value.substr(2);
+
+          ASSERT_EQ(NsSmartDeviceLink::NsSmartObjects::SmartType_Binary,
+                    obj.getType());
+
+          NsSmartDeviceLink::NsSmartObjects::SmartBinary binaryData = obj
+              .asBinary();
+          ASSERT_EQ(etalonData.size(), binaryData.size());
+
+          for (size_t i = 0; i < etalonData.size(); ++i) {
+            ASSERT_EQ(etalonData.at(i), binaryData.at(i));
+          }
+          continue;
+        }
+
+        ASSERT_EQ(etalonData.at(i), binaryData.at(i));
+      }
+      continue;
+    }
+
+#ifdef NO_INCLUSIVE_MAPS
+    if (!value.compare("map"))
+    {
+      std::vector<std::string> path = split(it->first, ' ');
+
+      std::string map_value = path[path.size()-1];
+      ASSERT_EQ(map_value, static_cast<std::string>(obj));
+      continue;
+    }
+#endif
+    if (value.compare("map") && value.compare("array")) {
+      //std::cout << "Verification key: " << it->first << " Value: " << value << std::endl;
+      //std::cout << "Object Value: " << static_cast<std::string>(obj) << std::endl;
+
+      if (!value.compare("true")) {
+        ASSERT_TRUE(obj.asBool());
+      } else if (!value.compare("false")) {
+        ASSERT_FALSE(obj.asBool());
+      } else {
+        ASSERT_EQ(value, obj.asString())<< "Object value is not correct. Object path: " << it->first;
+      }
+    }
+  }
+}
+
+TEST_F(StressTestHelper, ExtraManualDebugTest) {
+  SmartObject obj;
+
+  obj[0] = false;
+  obj[1] = 0.869495;
+  obj[2] = true;
+  obj[3] = 'Q';
+  obj[4] = true;
+  obj[5] = 3.704;
+  obj[6] = SmartObject();
+  obj[6][0] =
+      std::string(
+          "ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt");
+  obj[6][1] = 'K';
+  obj[6][2] = 0.735294;
+  obj[6][3] = 'I';
+  obj[6][4] = SmartObject();
+  obj[6][4]["M0"] = 0.59432;
+  SmartObject & refObj = obj[6][4];
+  refObj["M1"]["M0"]["M0"][0] = true;
+
+  // FIXME: Figure out why there's a trailing zero while converting from double to string
+  ASSERT_EQ("0.59432", get_object(obj, "A6 A4 M0").asString());
+  ASSERT_TRUE(get_object(obj, "A6 A4 M1 M0 M0 A0").asBool());
+}
+
+}
+}
+}
+}
diff --git a/src/components/smart_objects/test/SmartObjectUnit_test.cc b/src/components/smart_objects/test/SmartObjectUnit_test.cc
new file mode 100644
index 0000000000..d1d790f9d4
--- /dev/null
+++ b/src/components/smart_objects/test/SmartObjectUnit_test.cc
@@ -0,0 +1,584 @@
+/*
+ * Copyright (c) 2014, 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 "gmock/gmock.h"
+#include "smart_objects/smart_object.h"
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SmartObjectUnitTest {
+
+using namespace NsSmartDeviceLink::NsSmartObjects;
+
+class TestHelper : public ::testing::Test {
+ protected:
+
+  void makeMapObject(SmartObject& obj, const int size) const {
+    char i_key[8], j_key[8], k_key[8], value[8];
+
+    for (int i = 0; i < size; i++)
+      for (int j = 0; j < size; j++)
+        for (int k = 0; k < size; k++) {
+          sprintf(i_key, "i_%d", i);
+          sprintf(j_key, "j_%d", j);
+          sprintf(k_key, "k_%d", k);
+          sprintf(value, "%d", i + j + k);
+          obj[i_key][j_key][k_key] = value;
+        }
+  }
+
+  void checkMapObject(SmartObject& obj, const int size) const {
+    char i_key[8], j_key[8], k_key[8], value[8];
+
+    for (int i = 0; i < size; i++)
+      for (int j = 0; j < size; j++)
+        for (int k = 0; k < size; k++) {
+          sprintf(i_key, "i_%d", i);
+          sprintf(j_key, "j_%d", j);
+          sprintf(k_key, "k_%d", k);
+          sprintf(value, "%d", i + j + k);
+
+          ASSERT_EQ(std::string(value), obj[i_key][j_key][k_key].asString())<<
+          "Wrong value in the map at [" << i_key << "][" << j_key << "][" << k_key << "]";
+        }
+      }
+
+      void makeArrayObject(SmartObject& obj, int size, int base = 0) {
+        for (int i = 0; i < size; i++)
+        for (int j = 0; j < size; j++)
+        for (int k = 0; k < size; k++) {
+          obj[i][j][k] = base + i + j + k;
+        }
+      }
+
+      void checkArrayObject(SmartObject& obj, int size, int base = 0) {
+        for (int i = 0; i < size; i++)
+        for (int j = 0; j < size; j++)
+        for (int k = 0; k < size; k++) {
+          ASSERT_EQ(base + i + j + k, obj[i][j][k].asInt()) <<
+          "Wrong value in the array at index: " << i << ", " << j << ", " << k;
+        }
+      }
+    };
+
+    /*
+     * Tests different types sequentially
+     */
+TEST(BasicMixtedTypes, test_SmartObjectUnitTest) {
+  SmartObject obj;
+
+  ASSERT_EQ(invalid_int_value, obj.asInt())<< "Wrong cast to int just after construction";
+
+  obj = 10;
+  ASSERT_EQ(10, obj.asInt())<< "Wrong cast to int";
+
+  obj = "some string";
+  ASSERT_EQ("some string", obj.asString())<< "Wrong cast to std::string";
+
+  obj = false;
+  ASSERT_FALSE(obj.asBool())<< "Wrong cast to bool";
+
+  obj = 'A';
+  ASSERT_EQ('A', obj.asChar())<< "Wrong cast to char";
+
+  obj = 3.14;
+  ASSERT_EQ(3.14, obj.asDouble())<< "Wrong cast to double";
+
+  // array test
+  for (int i = 0; i < 100; i++) {
+    obj[i] = i;
+    ASSERT_EQ(i, obj[i].asInt());
+  }
+
+  // map test
+  for (int i = 0; i < 100; i++) {
+    char key[8];
+    sprintf(key, "%d", i);
+    obj[key] = i;
+    ASSERT_EQ(i, obj[key].asInt());
+  }
+}
+
+TEST_F(TestHelper, BasicArrayTest) {
+  SmartObject obj;
+
+  ASSERT_EQ(invalid_int_value,
+      obj[0].asInt())<< "Wrong value at accessing non existent index";
+  ASSERT_EQ(invalid_int_value,
+      obj["non_existent_key"].asInt())<< "Wrong value at accessing non existent key";
+
+  obj[0] = 1;
+  ASSERT_EQ(1, obj[0].asInt())<< "Wrong value at 0 index";
+  obj[1] = 2;
+  ASSERT_EQ(2, obj[1].asInt())<< "Wrong value at 1 index";
+
+  obj[0][0] = 3;
+  obj[1][0] = 1;
+  ASSERT_EQ(3, obj[0][0].asInt())<< "Wrong value at index 0, 0";
+
+  obj[0][0][0] = 4;
+  obj[0][1][0] = 5;
+  ASSERT_EQ(4, obj[0][0][0].asInt())<< "Wrong value at index 0, 0, 0";
+
+  const int size = 32;
+  makeArrayObject(obj, size);
+
+  checkArrayObject(obj, size);
+}
+
+TEST_F(TestHelper, BasicMapTest) {
+  SmartObject obj;
+
+  ASSERT_EQ(invalid_int_value,
+      obj["non_existent_key"].asInt())<< "Wrong value for non existent key";
+
+  obj["abc"]["def"]["ghi"] = 5;
+  ASSERT_EQ(5, obj["abc"]["def"]["ghi"].asInt())<< "Wrong value for triple map";
+
+  obj["123"]["456"]["789"] = "string test";
+
+  ASSERT_EQ("string test", obj["123"]["456"]["789"].asString())<<
+  "Wrong value for triple map";
+
+  const int size = 32;
+
+  makeMapObject(obj, size);
+
+  checkMapObject(obj, size);
+}
+
+TEST(ConstructorsTest, test_SmartObjectUnitTest) {
+  SmartObject objInt(5678);
+  ASSERT_EQ(5678, objInt.asInt())<< "Wrong constructor with int param";
+
+  const char* c_str = "test c_string";
+  SmartObject obj_c_str(c_str);
+  ASSERT_EQ("test c_string", obj_c_str.asString())<< "Wrong constructor with c_str param";
+
+  SmartObject obj_std_str(std::string("test std_string"));
+  ASSERT_EQ(std::string("test std_string"), obj_std_str.asString());
+
+  SmartObject obj_char('R');
+  ASSERT_EQ('R', obj_char.asChar())<< "Wrong constructor with char param";
+
+  SmartObject obj_double(-0.4321);
+  ASSERT_EQ(-0.4321, obj_double.asDouble())<< "Wrong constructor with double param";
+
+  SmartObject obj_bool(true);
+  ASSERT_TRUE(obj_bool.asBool())<< "Wrong constructor with bool param";
+
+  SmartObject src_obj;
+
+  src_obj["key_1"] = "value_1";     // FIXME: String assignment crashes test
+  src_obj["key_2"]["sub_key_1"] = "value_2";
+
+  SmartObject dst_obj(src_obj);
+  ASSERT_EQ("value_1", dst_obj["key_1"].asString())<< "Copy constructor is not correct";
+  ASSERT_EQ("value_2", dst_obj["key_2"]["sub_key_1"].asString())<<
+  "Copy constructor is not correct";
+}
+
+TEST(FromString, TypeConversion) {
+  {
+    // String to bool
+    SmartObject obj;
+    ASSERT_EQ(invalid_bool_value, obj.asBool());
+    obj = "true";
+    ASSERT_EQ(invalid_bool_value, obj.asBool());
+    obj = "false";
+    ASSERT_EQ(invalid_bool_value, obj.asBool());
+    obj = true;
+    ASSERT_TRUE(obj.asBool());
+  }
+  {
+    // String to int
+    SmartObject obj;
+    ASSERT_EQ(invalid_int_value, obj.asInt());
+    obj = "0";
+    ASSERT_EQ(0, obj.asInt());
+    obj = "-34323";
+    ASSERT_EQ(-34323, obj.asInt());
+    obj = "+1234";
+    ASSERT_EQ(1234, obj.asInt());
+    obj = "3232.0";
+    ASSERT_EQ(invalid_int_value, obj.asInt());
+    obj = "123wtf";
+    ASSERT_EQ(invalid_int_value, obj.asInt());
+    obj = "";
+    ASSERT_EQ(invalid_int_value, obj.asInt());
+    obj = " 123 ";
+    ASSERT_EQ(invalid_int_value, obj.asInt());
+    obj = " 123";
+    ASSERT_EQ(123, obj.asInt());
+  }
+  {
+    // String to char
+    SmartObject obj;
+    ASSERT_EQ(invalid_char_value, obj.asChar());
+    obj = "C";
+    ASSERT_EQ('C', obj.asChar());
+    obj = "\n";
+    ASSERT_EQ('\n', obj.asChar());
+    obj = " A";
+    ASSERT_EQ(invalid_char_value, obj.asChar());
+    obj = "";
+    ASSERT_EQ(invalid_char_value, obj.asChar());
+  }
+  {
+    // String to double
+    SmartObject obj;
+    ASSERT_EQ(invalid_double_value, obj.asDouble());
+    obj = "1234";
+    ASSERT_EQ(1234, obj.asDouble());
+    obj = "-0.1234";
+    ASSERT_EQ(-0.1234, obj.asDouble());
+    obj = ".54321";
+    ASSERT_EQ(.54321, obj.asDouble());
+    obj = "123.45.6";
+    ASSERT_EQ(invalid_double_value, obj.asDouble());
+    obj = "123 wtf";
+    ASSERT_EQ(invalid_double_value, obj.asDouble());
+    obj = " 0.5";
+    ASSERT_EQ(0.5, obj.asDouble());
+  }
+  {
+    // String to Map
+    SmartObject obj;
+    ASSERT_EQ(invalid_int_value, obj["key"].asInt());
+    obj = "this is not a map";
+    ASSERT_EQ(invalid_char_value, obj["some_key"].asChar());
+  }
+  {
+    // String to Array
+    SmartObject obj;
+    ASSERT_EQ(invalid_bool_value, obj[0].asBool());
+    obj = "this is not an array";
+    ASSERT_EQ(invalid_double_value, obj[0].asDouble());
+  }
+  {
+    // String to Binary
+    SmartObject obj;
+    ASSERT_EQ(invalid_binary_value, obj.asBinary());
+    obj = "this is not an array";
+    ASSERT_EQ(invalid_binary_value, obj.asBinary());
+  }
+}
+
+TEST(FromBool, TypeConversion) {
+  SmartObject obj;
+
+  obj = true;
+
+  ASSERT_EQ(invalid_string_value, obj.asString());
+  ASSERT_TRUE(obj.asBool());
+  ASSERT_EQ(1, obj.asInt());
+  ASSERT_EQ(invalid_char_value, obj.asChar());
+  ASSERT_EQ(1.0, obj.asDouble());
+  ASSERT_EQ(invalid_int_value, obj["key"].asInt());
+  ASSERT_EQ(invalid_char_value, obj[0].asChar());
+  ASSERT_EQ(invalid_binary_value, obj.asBinary());
+
+  obj = false;
+
+  ASSERT_EQ(invalid_string_value, obj.asString());
+  ASSERT_FALSE(obj.asBool());
+  ASSERT_EQ(0, obj.asBool());
+  ASSERT_EQ(invalid_char_value, obj.asChar());
+  ASSERT_EQ(0, obj.asDouble());
+  ASSERT_EQ(invalid_int_value, obj["key"].asInt());
+  ASSERT_EQ(invalid_char_value, obj[0].asChar());
+  ASSERT_EQ(invalid_binary_value, obj.asBinary());
+}
+
+TEST(FromInt, TypeConversion) {
+  SmartObject obj;
+
+  obj = 123;
+
+  ASSERT_EQ("123", obj.asString());
+  ASSERT_TRUE(obj.asBool());
+  ASSERT_EQ(invalid_char_value, obj.asChar());
+  ASSERT_EQ(123.0, obj.asDouble());
+  ASSERT_EQ(invalid_binary_value, obj.asBinary());
+
+  obj = 5;
+  ASSERT_EQ("5", obj.asString());
+  ASSERT_EQ(invalid_char_value, obj.asChar());
+
+  obj = 0;
+  ASSERT_EQ("0", obj.asString());
+  ASSERT_FALSE(obj.asBool());
+
+  obj = 1;
+  ASSERT_TRUE(obj.asBool());
+
+  obj = -1234;
+  ASSERT_EQ(-1234, obj.asInt());
+  ASSERT_EQ("-1234", obj.asString());
+  ASSERT_EQ(-1234.0, obj.asDouble());
+  ASSERT_EQ(invalid_char_value, obj.asChar());
+  ASSERT_TRUE(obj.asBool());
+  ASSERT_EQ(invalid_binary_value, obj.asBinary());
+}
+
+TEST(FromChar, TypeConversion) {
+  SmartObject obj;
+
+  obj = '1';
+
+  ASSERT_EQ("1", obj.asString());
+  ASSERT_EQ(invalid_int_value, obj.asInt());
+  ASSERT_EQ('1', obj.asChar());
+  ASSERT_EQ(invalid_double_value, obj.asDouble());
+  ASSERT_EQ(invalid_int_value, obj["key"].asInt());
+  ASSERT_EQ(invalid_char_value, obj[0].asChar());
+  ASSERT_EQ(invalid_binary_value, obj.asBinary());
+
+  obj = '0';
+
+  ASSERT_EQ("0", obj.asString());
+  ASSERT_EQ(invalid_int_value, obj.asInt());
+  ASSERT_EQ('0', obj.asChar());
+  ASSERT_EQ(invalid_double_value, obj.asDouble());
+  ASSERT_EQ(invalid_int_value, obj["key"].asInt());
+  ASSERT_EQ(invalid_char_value, obj[0].asChar());
+  ASSERT_EQ(invalid_binary_value, obj.asBinary());
+}
+
+TEST(FromDouble, TypeConversion) {
+  SmartObject obj;
+
+  obj = 0.1;
+  ASSERT_EQ("0.1", obj.asString());        // FIXME: result 0.100000
+  ASSERT_EQ(0, obj.asInt());
+  ASSERT_EQ(invalid_char_value, obj.asChar());
+  ASSERT_EQ(0.1, obj.asDouble());
+  ASSERT_TRUE(obj.asBool());
+  ASSERT_EQ(invalid_binary_value, obj.asBinary());
+
+  obj = 0.9;
+  ASSERT_EQ("0.9", obj.asString());
+  ASSERT_EQ(0, obj.asInt());
+  ASSERT_TRUE(obj.asBool());
+
+  obj = -12323.999;
+  ASSERT_EQ("-12323.999", obj.asString());
+  ASSERT_EQ(-12323, obj.asInt());
+  ASSERT_TRUE(obj.asBool());
+
+  obj = 0.0;
+  ASSERT_EQ("0", obj.asString());
+  ASSERT_EQ(0, obj.asInt());
+  ASSERT_FALSE(obj.asBool());
+  ASSERT_EQ(invalid_binary_value, obj.asBinary());
+}
+
+TEST(FromMap, TypeConversion) {
+  SmartObject obj;
+
+  obj["key1"] = 123;
+
+  ASSERT_EQ(invalid_string_value, obj.asString());
+  ASSERT_EQ(invalid_int_value, obj.asInt());
+  ASSERT_EQ(invalid_char_value, obj.asChar());
+  ASSERT_EQ(invalid_double_value, obj.asDouble());
+  ASSERT_EQ(123, obj["key1"].asInt());
+  ASSERT_EQ(invalid_char_value, obj[0].asChar());
+  ASSERT_EQ(invalid_binary_value, obj.asBinary());
+}
+
+TEST(FromArray, TypeConversion) {
+  SmartObject obj;
+
+  obj[0] = 'A';
+  obj[1] = -123;
+
+  ASSERT_EQ(invalid_string_value, obj.asString());
+  ASSERT_EQ(invalid_int_value, obj.asInt());
+  ASSERT_EQ(invalid_char_value, obj.asChar());
+  ASSERT_EQ(invalid_double_value, obj.asDouble());
+  ASSERT_EQ('A', obj[0].asChar());
+  ASSERT_EQ(invalid_int_value, obj["key1"].asInt());
+  ASSERT_EQ(invalid_binary_value, obj.asBinary());
+}
+
+TEST_F(TestHelper, AssignmentTest) {
+  SmartObject objSrc, objDst;
+
+  objSrc = -6;
+  objDst = 7;
+  objDst = objSrc;
+  ASSERT_EQ(-6, objDst.asInt())<< "Wrong assignment for int object";
+
+  objSrc = "Some test string";
+  objDst = "Other string";
+  objDst = objSrc;
+  ASSERT_EQ("Some test string",
+      objDst.asString())<< "Wrong assignment for std::string object";
+
+  objSrc = 0.5;
+  objDst = 4;
+  objDst = objSrc;
+  ASSERT_EQ(0.5, objDst.asDouble())<< "Wrong assignment for double object";
+
+  objSrc = true;
+  objDst = false;
+  objDst = objSrc;
+  ASSERT_TRUE(objDst.asBool())<< "Wrong assignment for bool object";
+
+  const int size = 32;
+  makeMapObject(objSrc, size);
+  objDst["a"]["b"] = 4;
+  objDst = objSrc;
+  checkMapObject(objDst, size);
+
+  makeArrayObject(objSrc, size, 5);
+  makeArrayObject(objDst, 23, 6);
+  objDst = objSrc;
+  checkArrayObject(objDst, size, 5);
+}
+
+TEST_F(TestHelper, SizeTest) {
+  SmartObject obj;
+
+  ASSERT_EQ(0u, obj.length())<< "Wrong size for the uninitialized object";
+
+  obj = 1234;
+  ASSERT_EQ(0u, obj.length())<< "Wrong size for the int object";
+
+  std::string str("Some test very long string");
+  obj = str;
+  ASSERT_EQ(str.size(), obj.length())<<
+  "The size of the object containing string is not correct";
+
+  obj = true;
+  ASSERT_EQ(0u, obj.length())<< "Wrong size of the true";
+
+  obj = 0.1234;
+  ASSERT_EQ(0u, obj.length())<< "Wrong size of the double";
+
+  obj = 'A';
+  ASSERT_EQ(0u, obj.length())<< "Wrong size of the char";
+
+  makeMapObject(obj, 12);
+  ASSERT_EQ(12u, obj.length())<< "Wrong size of the object containing map";
+
+  makeArrayObject(obj, 21);
+  ASSERT_EQ(21u, obj.length())<< "Wrong size of the object containing array";
+}
+
+TEST(CopyObjectsTest, SmartObjectTest) {
+  SmartObject obj;
+
+  obj[0] = "test string";
+
+  obj = obj[0];
+
+  ASSERT_EQ("test string", obj.asString());
+
+  obj["abc"] = "new test string";
+  obj = obj["abc"];
+
+  ASSERT_EQ("new test string", obj.asString());
+}
+
+TEST(CopyConstructorTest, SmartObjectTest) {
+  SmartObject srcObj;
+
+  srcObj[0] = "test string";
+
+  SmartObject dstObj = srcObj[0];
+
+  ASSERT_EQ("test string", dstObj.asString());
+}
+
+TEST(MapEraseTest, SmartObjectTest) {
+  SmartObject srcObj;
+
+  srcObj["one"] = 1;
+  srcObj["two"] = 2;
+  srcObj["three"] = 3;
+
+  ASSERT_EQ(3u, srcObj.length());
+  ASSERT_EQ(2, srcObj["two"].asInt());
+
+  ASSERT_TRUE(srcObj.erase("two"));
+  ASSERT_FALSE(srcObj.erase("two"));
+
+  ASSERT_EQ(2u, srcObj.length());
+  ASSERT_EQ(-1, srcObj["two"].asInt());
+  // The element "two" was accessed in the previous line so the element has been created
+  ASSERT_EQ(3u, srcObj.length());
+
+  srcObj["two"] = 2;
+
+  ASSERT_EQ(1, srcObj["one"].asInt());
+  ASSERT_EQ(2, srcObj["two"].asInt());
+  ASSERT_EQ(3, srcObj["three"].asInt());
+
+  ASSERT_TRUE(srcObj.erase("one"));
+
+  ASSERT_EQ(2u, srcObj.length());
+
+  ASSERT_TRUE(srcObj.erase("two"));
+
+  ASSERT_EQ(1u, srcObj.length());
+
+  ASSERT_TRUE(srcObj.erase("three"));
+
+  ASSERT_EQ(0u, srcObj.length());
+
+  srcObj["one"]["two"]["three"]["0"] = "1";
+  srcObj["one"]["two"]["three"]["1"] = "2";
+
+  ASSERT_EQ(1u, srcObj.length());
+  ASSERT_EQ(1u, srcObj["one"].length());
+  ASSERT_EQ(1u, srcObj["one"]["two"].length());
+  ASSERT_EQ(2u, srcObj["one"]["two"]["three"].length());
+
+  ASSERT_TRUE(srcObj["one"]["two"]["three"].erase("0"));
+  ASSERT_FALSE(srcObj["one"]["two"]["three"].erase("0"));
+
+  ASSERT_EQ(1u, srcObj["one"]["two"]["three"].length());
+
+  ASSERT_TRUE(srcObj["one"].erase("two"));
+  ASSERT_EQ(0u, srcObj["one"].length());
+
+  srcObj = 1234;       // not a map
+  ASSERT_FALSE(srcObj.erase("one"));
+}
+// TODO: Add a test to check accessing an array at strange indexes.
+}// namespace SmartObjectUnitTest
+}  // namespace SmartObjects
+}  // namespace components
+}  // namespace test
diff --git a/src/components/smart_objects/test/StringSchemaItem_test.cc b/src/components/smart_objects/test/StringSchemaItem_test.cc
new file mode 100644
index 0000000000..5fe179a7e1
--- /dev/null
+++ b/src/components/smart_objects/test/StringSchemaItem_test.cc
@@ -0,0 +1,302 @@
+/*
+ * Copyright (c) 2014, 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 <string>
+
+#include "gmock/gmock.h"
+
+#include "smart_objects/smart_object.h"
+#include "smart_objects/string_schema_item.h"
+
+namespace test {
+namespace components {
+namespace SmartObjects {
+namespace SchemaItem {
+
+/**
+ * Test StringSchemaItem no default value
+ *
+ * Create SchemaItem without default value. Method setDefaultValue should always return false
+ * and leave SmartObject in previous state.
+ **/
+TEST(test_no_default_value, test_StringSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+  SmartObject obj;
+
+  ISchemaItemPtr item = CStringSchemaItem::create();  // No default value, no max length
+
+  //Object - valid string
+  obj = "New valid string";
+  ASSERT_EQ(std::string("New valid string"), obj.asString());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  EXPECT_EQ(std::string("New valid string"), obj.asString());
+
+  //Obj - bool
+  obj = true;
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  EXPECT_TRUE(obj.asBool());
+
+  //Object - number
+  obj = 3.1415926;
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_FALSE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  EXPECT_EQ(3.1415926, obj.asDouble());
+}
+
+/**
+ * Test StringSchemaItem with default value
+ *
+ * Create SchemaItem with default value. Method setDefaultValue should return true,
+ * String SmartObject should contain default value.
+ * Not string SmartObject should converted to StringObject and setted up by the default value.
+ **/
+TEST(test_item_with_default_value, test_StringSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+  SmartObject obj;
+
+  ISchemaItemPtr item = CStringSchemaItem::create(
+      TSchemaItemParameter<size_t>(), TSchemaItemParameter<size_t>(),
+      TSchemaItemParameter<std::string>("Default string"));  // Default value, no max length
+
+  //Object - valid string
+  obj = "New valid string";
+  ASSERT_EQ(std::string("New valid string"), obj.asString());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(std::string("Default string"), obj.asString());
+
+  //Obj - bool
+  obj = true;
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(std::string("Default string"), obj.asString());
+
+  //Object - number
+  obj = 3.1415926;
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  EXPECT_EQ(std::string("Default string"), obj.asString());
+}
+
+/**
+ * Test StringSchemaItem with max length
+ **/
+TEST(test_item_with_max_length, test_StringSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+  SmartObject obj;
+
+  ISchemaItemPtr item = CStringSchemaItem::create(
+      TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(25),
+      TSchemaItemParameter<std::string>("Default string"));
+
+  //Object - valid string
+  obj = "New valid string";
+  ASSERT_EQ(std::string("New valid string"), obj.asString());
+
+  int resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+  bool resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(std::string("Default string"), obj.asString());
+
+  //Object - too long string
+  obj = "New very very loooooong string";
+  ASSERT_EQ(std::string("New very very loooooong string"), obj.asString());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(std::string("Default string"), obj.asString());
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+}
+
+TEST(test_map_validate, test_StringSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+  SmartObject obj;
+
+  ISchemaItemPtr item = CStringSchemaItem::create(
+      TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(25),
+      TSchemaItemParameter<std::string>("Default string"));
+
+  obj["str"] = "New valid string";
+  obj["long"] = "New very very loooooong string";
+  obj["bool"] = true;
+  obj["num"] = 3.14;
+
+  int resultType = item->validate(obj["str"]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  resultType = item->validate(obj["long"]);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  resultType = item->validate(obj["bool"]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resultType = item->validate(obj["num"]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  bool resDefault = item->setDefaultValue(obj["str"]);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(std::string("Default string"), obj["str"].asString());
+
+  resDefault = item->setDefaultValue(obj["bool"]);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(std::string("Default string"), obj["bool"].asString());
+
+  resDefault = item->setDefaultValue(obj["num"]);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(std::string("Default string"), obj["num"].asString());
+
+  resultType = item->validate(obj["str"]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  resultType = item->validate(obj["long"]);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  resultType = item->validate(obj["bool"]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  resultType = item->validate(obj["num"]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(std::string("Default string"), obj.asString());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+}
+
+TEST(test_array_validate, test_StringSchemaItemTest) {
+  using namespace NsSmartDeviceLink::NsSmartObjects;
+  SmartObject obj;
+
+  ISchemaItemPtr item = CStringSchemaItem::create(
+      TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(25),
+      TSchemaItemParameter<std::string>("Default string"));
+
+  obj[0] = "New valid string";
+  obj[1] = "New very very loooooong string";
+  obj[2] = true;
+  obj[3] = 3.14;
+  obj[4] = "New valid string";
+
+  int resultType = item->validate(obj[0]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  resultType = item->validate(obj[1]);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+
+  resultType = item->validate(obj[2]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resultType = item->validate(obj[3]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  resultType = item->validate(obj[4]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+
+  bool resDefault = item->setDefaultValue(obj[0]);
+  EXPECT_TRUE(resDefault);
+  resDefault = item->setDefaultValue(obj[2]);
+  EXPECT_TRUE(resDefault);
+  resDefault = item->setDefaultValue(obj[4]);
+  EXPECT_TRUE(resDefault);
+
+  //Set default value for non-initialized element
+  resDefault = item->setDefaultValue(obj[5]);
+  EXPECT_TRUE(resDefault);
+
+  EXPECT_EQ(std::string("Default string"), obj[0].asString());
+  EXPECT_EQ(std::string("Default string"), obj[2].asString());
+  EXPECT_EQ(std::string("Default string"), obj[4].asString());
+  EXPECT_EQ(std::string("Default string"), obj[5].asString());
+
+  resultType = item->validate(obj[0]);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj[1]);
+  EXPECT_EQ(Errors::OUT_OF_RANGE, resultType);
+  resultType = item->validate(obj[2]);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj[3]);
+  EXPECT_EQ(Errors::INVALID_VALUE, resultType);
+  resultType = item->validate(obj[4]);
+  EXPECT_EQ(Errors::OK, resultType);
+  resultType = item->validate(obj[5]);
+  EXPECT_EQ(Errors::OK, resultType);
+
+  resDefault = item->setDefaultValue(obj);
+  EXPECT_TRUE(resDefault);
+  EXPECT_EQ(std::string("Default string"), obj.asString());
+
+  resultType = item->validate(obj);
+  EXPECT_EQ(Errors::OK, resultType);
+}
+}  // namespace SchemaItem
+}  // namespace SmartObjects
+}  // namespace components
+}  // namespace test
diff --git a/src/components/smart_objects/test/TSharedPtr_test.cc b/src/components/smart_objects/test/TSharedPtr_test.cc
new file mode 100644
index 0000000000..3943d2b24b
--- /dev/null
+++ b/src/components/smart_objects/test/TSharedPtr_test.cc
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2014, 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 <stdlib.h>
+#include <vector>
+#include "gmock/gmock.h"
+#include "utils/shared_ptr.h"
+
+namespace test {
+namespace components {
+namespace utils {
+namespace SharedPtrTest {
+class CMockObject {
+ public:
+  CMockObject(int id);
+  ~CMockObject(void);
+  int getId(void) const;
+
+  MOCK_METHOD0(destructor, void ());
+
+private:
+  int mId;
+};
+
+class CExtendedMockObject : public CMockObject {
+ public:
+  CExtendedMockObject(int id);
+};
+}  // namespace CMockObject
+}  // namespace SmartObjects
+}  // namespace components
+}  // namespace test
+
+test::components::utils::SharedPtrTest::CMockObject::CMockObject(int id)
+    : mId(id) {
+}
+
+test::components::utils::SharedPtrTest::CMockObject::~CMockObject(void) {
+  destructor();
+}
+
+int test::components::utils::SharedPtrTest::CMockObject::getId(void) const {
+  return mId;
+}
+
+test::components::utils::SharedPtrTest::CExtendedMockObject::CExtendedMockObject(
+    int id)
+    : CMockObject(id) {
+}
+
+typedef utils::SharedPtr<test::components::utils::SharedPtrTest::CMockObject> tMockObjectPtr;
+typedef utils::SharedPtr<
+    test::components::utils::SharedPtrTest::CExtendedMockObject> tExtendedMockObjectPtr;
+
+TEST(SharedPtrTest, Constructor) {
+  test::components::utils::SharedPtrTest::CMockObject* object1 =
+      new test::components::utils::SharedPtrTest::CMockObject(1);
+  test::components::utils::SharedPtrTest::CMockObject* object2 =
+      new test::components::utils::SharedPtrTest::CMockObject(2);
+
+  EXPECT_CALL(*object1, destructor()).Times(0);
+  EXPECT_CALL(*object2, destructor()).Times(0);
+
+  tMockObjectPtr p1(object1);
+  ASSERT_EQ(1, p1->getId());
+
+  tMockObjectPtr p2(p1);
+  ASSERT_EQ(1, p2->getId());
+
+  tMockObjectPtr p3 = p2;
+  ASSERT_EQ(1, p3->getId());
+
+  tMockObjectPtr p4 = object2;
+  ASSERT_EQ(2, p4->getId());
+
+  p3 = p4;
+  ASSERT_EQ(2, p3->getId());
+
+  EXPECT_CALL(*object1, destructor());
+  EXPECT_CALL(*object2, destructor());
+}
+
+TEST(SharedPtrTest, PointerTypeCast) {
+  test::components::utils::SharedPtrTest::CExtendedMockObject* object1 =
+      new test::components::utils::SharedPtrTest::CExtendedMockObject(1);
+  test::components::utils::SharedPtrTest::CExtendedMockObject* object2 =
+      new test::components::utils::SharedPtrTest::CExtendedMockObject(2);
+
+  EXPECT_CALL(*object1, destructor()).Times(0);
+  EXPECT_CALL(*object2, destructor()).Times(0);
+
+  tExtendedMockObjectPtr ep1(object1);
+  ASSERT_EQ(1, ep1->getId());
+
+  tMockObjectPtr p1(ep1);
+  ASSERT_EQ(1, p1->getId());
+
+  tExtendedMockObjectPtr ep2(object2);
+  ASSERT_EQ(2, ep2->getId());
+
+  p1 = ep2;
+  ASSERT_EQ(2, p1->getId());
+
+  EXPECT_CALL(*object1, destructor());
+  EXPECT_CALL(*object2, destructor());
+}
+
+TEST(SharedPtrTest, AddedOperators) {
+  test::components::utils::SharedPtrTest::CExtendedMockObject* object1 =
+      new test::components::utils::SharedPtrTest::CExtendedMockObject(1);
+  test::components::utils::SharedPtrTest::CExtendedMockObject* object2 =
+      new test::components::utils::SharedPtrTest::CExtendedMockObject(2);
+
+  EXPECT_CALL(*object1, destructor()).Times(0);
+  EXPECT_CALL(*object2, destructor()).Times(0);
+
+  tExtendedMockObjectPtr ep1(object1);
+  tMockObjectPtr p1(ep1);
+  tExtendedMockObjectPtr ep2(object2);
+  p1 = ep2;
+
+  ASSERT_EQ(2, p1->getId());
+  ASSERT_EQ(2, (*p1).getId());
+
+  ASSERT_FALSE(!p1);
+
+  utils::SharedPtr<int> p3(new int(10));
+  ASSERT_EQ(10, *p3);
+  ASSERT_FALSE(!p3);
+
+  utils::SharedPtr<int> p2;
+  ASSERT_TRUE(!p2);
+
+  p2.reset(new int);
+  ASSERT_FALSE(!p2);
+  *p2 = 3;
+  ASSERT_EQ(3, *p2);
+
+  EXPECT_CALL(*object1, destructor());
+  EXPECT_CALL(*object2, destructor());
+}
+
+TEST(SharedPtrTest, StressTest) {
+  const size_t cNumIterations = 1024U * 1024U;
+
+  size_t objectCreated = 0U;
+  size_t pointersCopied = 0U;
+
+  std::vector<tMockObjectPtr> objects;
+
+  for (size_t i = 0U; i < cNumIterations; ++i) {
+    if ((true == objects.empty()) || (0 == rand() % 256)) {
+      test::components::utils::SharedPtrTest::CMockObject* object =
+          new test::components::utils::SharedPtrTest::CMockObject(0);
+      EXPECT_CALL(*object, destructor());
+
+      objects.push_back(object);
+
+      ++objectCreated;
+    } else {
+      size_t objectIndex = static_cast<size_t>(rand()) % objects.size();
+
+      if (rand() % 2) {
+        objects.push_back(objects[objectIndex]);
+
+        ++pointersCopied;
+      } else {
+        objects.erase(objects.begin() + objectIndex);
+      }
+    }
+  }
+  printf("%zu objects created, %zu pointers copied\n", objectCreated,
+         pointersCopied);
+}
diff --git a/src/components/smart_objects/test/main.cc b/src/components/smart_objects/test/main.cc
new file mode 100644
index 0000000000..59fa20e8b5
--- /dev/null
+++ b/src/components/smart_objects/test/main.cc
@@ -0,0 +1,7 @@
+#include "gmock/gmock.h"

+

+int main(int argc, char** argv) {

+   testing::InitGoogleMock(&argc, argv);

+   return RUN_ALL_TESTS();

+}

+

diff --git a/src/components/smart_objects/test/map_performance_test.cc b/src/components/smart_objects/test/map_performance_test.cc
new file mode 100644
index 0000000000..e7e9ccffac
--- /dev/null
+++ b/src/components/smart_objects/test/map_performance_test.cc
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2014, 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 <string>
+#include <vector>
+#include <map>
+
+#include "gmock/gmock.h"
+
+typedef std::string Key;
+typedef std::vector<std::string> Value;
+typedef std::map<Key, Value> Map;
+
+namespace {
+void MakeMapObject(Map &obj, const int size) {
+  char i_key[8], j_key[8];
+
+  Value array;
+  for (int i = 0; i < size; i++) {
+    for (int j = 0; j < size; j++) {
+      sprintf(j_key, "j_%d", j);
+      array.push_back(j_key);
+    }
+
+    sprintf(i_key, "i_%d", i);
+    obj[i_key] = array;
+  }
+}
+}
+
+TEST(SmartObjectPerformanceTest, SmartObjectMapPerformance) {
+  Map object;
+  MakeMapObject(object, 100);
+
+  for (Map::const_iterator i = object.begin(); i != object.end(); ++i) {
+    printf("%s - ", i->first.c_str());
+    const Value& value = i->second;
+
+    Value::const_iterator item = std::find(value.begin(), value.end(), "j_9");
+    if (item != value.end()) {
+      printf("%s\n", item->c_str());
+    } else {
+      printf("none...\n");
+    }
+  }
+}
diff --git a/src/components/smart_objects/test/smart_object_performance_test.cc b/src/components/smart_objects/test/smart_object_performance_test.cc
new file mode 100644
index 0000000000..72b6c1fa6d
--- /dev/null
+++ b/src/components/smart_objects/test/smart_object_performance_test.cc
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2014, 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 <string>
+#include <set>
+
+#include "gmock/gmock.h"
+
+#include "smart_objects/smart_object.h"
+
+using namespace NsSmartDeviceLink::NsSmartObjects;
+
+namespace {
+void MakeMapObject(SmartObject &obj, const int size) {
+  char i_key[8], j_key[8];
+
+  SmartObject array;
+  for (int i = 0; i < size; i++) {
+    for (int j = 0; j < size; j++) {
+      sprintf(j_key, "j_%d", j);
+      array[-1] = j_key;
+    }
+
+    sprintf(i_key, "i_%d", i);
+    obj[i_key] = array;
+  }
+}
+}
+
+TEST(SmartObjectPerformanceTest, SmartObjectPerformance) {
+  SmartObject object;
+  MakeMapObject(object, 100);
+
+  std::set < std::string > keys = object.enumerate();
+  for (std::set<std::string>::iterator i = keys.begin(); i != keys.end(); ++i) {
+    printf("%s - ", i->c_str());
+    SmartArray* array = object[*i].asArray();
+
+    SmartArray::iterator item = std::find(array->begin(), array->end(), "j_9");
+    if (item != array->end()) {
+      printf("%s\n", item->asString().c_str());
+    } else {
+      printf("none...\n");
+    }
+  }
+}