Merge branch 'release/4.0.0' into develop

7 files changed, 739 insertions, 349 deletions

diff --git a/src/components/connection_handler/test/CMakeLists.txt b/src/components/connection_handler/test/CMakeLists.txt
index f98c03391d..8e454ccf9e 100644
--- a/src/components/connection_handler/test/CMakeLists.txt
+++ b/src/components/connection_handler/test/CMakeLists.txt
@@ -36,13 +36,19 @@ include_directories(
     ${GMOCK_INCLUDE_DIRECTORY}
     ${COMPONENTS_DIR}/connection_handler/include
     ${COMPONENTS_DIR}/security_manager/test/include
+    ${COMPONENTS_DIR}/protocol_handler/test/include
     ${COMPONENTS_DIR}/security_manager/include
+    ${COMPONENTS_DIR}/application_manager/include
+    ${COMPONENTS_DIR}/connection_handler/test/include
+    ${COMPONENTS_DIR}/transport_manager/test/include
 )
 
 set(LIBRARIES
     gmock
     connectionHandler
     ConfigProfile
+    ProtocolHandler
+    TransportManager
 )
 
 set(SOURCES
diff --git a/src/components/connection_handler/test/connection_handler_impl_test.cc b/src/components/connection_handler/test/connection_handler_impl_test.cc
index 59dbe3bb7e..94e4c816fa 100644
--- a/src/components/connection_handler/test/connection_handler_impl_test.cc
+++ b/src/components/connection_handler/test/connection_handler_impl_test.cc
@@ -38,6 +38,9 @@
 #include "config_profile/profile.h"
 // TODO(EZamakhov): move security test
 #include "security_manager_mock.h"
+#include "protocol_handler_mock.h"
+#include "connection_handler_observer_mock.h"
+#include "transport_manager_mock.h"
 
 namespace test {
 namespace components {
@@ -46,52 +49,66 @@ namespace connection_handle_test {
 using namespace ::connection_handler;
 using ::protocol_handler::ServiceType;
 using namespace ::protocol_handler;
+using ::testing::_;
+using ::testing::InSequence;
 // For service types and PROTECTION_ON/OFF
 
 class ConnectionHandlerTest : public ::testing::Test {
  protected:
   void SetUp() OVERRIDE {
     connection_handler_ = ConnectionHandlerImpl::instance();
-    uid = 1u;
-    connection_key = connection_handler_->KeyFromPair(0, 0u);
+    uid_ = 1u;
+    connection_key_ = connection_handler_->KeyFromPair(0, 0u);
   }
   void TearDown() OVERRIDE {
     ConnectionHandlerImpl::destroy();
   }
   // Additional SetUp
   void AddTestDeviceConnection() {
-    const transport_manager::DeviceHandle device_handle = 0;
-    const transport_manager::DeviceInfo device_info(device_handle,
-                                                    std::string("test_address"),
-                                                    std::string("test_name"),
-                                                    std::string("BTMAC"));
+    device_handle_ = 0;
+
+    connection_type_ = "BTMAC";
+    device_name_ = "test_name";
+    mac_address_ = "test_address";
+
+    const transport_manager::DeviceInfo device_info(device_handle_,
+                                                    mac_address_,
+                                                    device_name_,
+                                                    connection_type_);
     // Add Device and connection
-    connection_handler_->addDeviceConnection(device_info, uid);
-    connection_key = connection_handler_->KeyFromPair(uid, 0u);
+    connection_handler_->addDeviceConnection(device_info, uid_);
+    connection_key_ = connection_handler_->KeyFromPair(uid_, 0u);
     // Remove all specific services
     SetSpecificServices("", "");
   }
   void AddTestSession() {
-    start_session_id = connection_handler_->OnSessionStartedCallback(
-        uid, 0, kRpc, PROTECTION_OFF, &out_hash_id);
-    EXPECT_NE(0u, start_session_id);
-    EXPECT_EQ(SessionHash(uid, start_session_id), out_hash_id);
-    connection_key = connection_handler_->KeyFromPair(uid, start_session_id);
-    CheckSessionExists(uid, start_session_id);
+    start_session_id_ = connection_handler_->OnSessionStartedCallback(
+                       uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
+    EXPECT_NE(0u, start_session_id_);
+    EXPECT_EQ(SessionHash(uid_, start_session_id_), out_hash_id_);
+    connection_key_ = connection_handler_->KeyFromPair(uid_, start_session_id_);
+    CheckSessionExists(uid_, start_session_id_);
   }
   uint32_t SessionHash(const uint32_t connection, const uint32_t session) {
     return connection_handler_->KeyFromPair(connection, session);
   }
+  void AddTestService(ServiceType service_type) {
+    EXPECT_NE(0u, start_session_id_);
+    EXPECT_EQ(SessionHash(uid_, start_session_id_), out_hash_id_);
+    connection_key_ = connection_handler_->KeyFromPair(uid_, start_session_id_);
+    CheckSessionExists(uid_, start_session_id_);
+    uint32_t session_id = connection_handler_->OnSessionStartedCallback(
+        uid_, start_session_id_, service_type, PROTECTION_OFF, 0);
+    EXPECT_EQ(session_id, start_session_id_);
+  }
 
   // Additional SetUp
-  void SetSpecificServices(const std::string& protect,
-                           const std::string& not_protect) {
+  void SetSpecificServices(const std::string& protect, const std::string& not_protect) {
     const char* config_file = "config.ini";
     std::ofstream file_config(config_file);
     ASSERT_TRUE(file_config.is_open());
     const std::string non("NON");
-    file_config
-        << "[Security Manager]" << std::endl
+    file_config << "[Security Manager]" << std::endl
         << "; Force protected services (could be id's from 0x01 to 0xFF)"
         << std::endl << "ForceProtectedService = "
         << (protect.empty() ? non : protect) << std::endl
@@ -105,8 +122,7 @@ class ConnectionHandlerTest : public ::testing::Test {
   // If session_id is NULL - check that there is no sessions in connection
   void CheckSessionExists(const int connectionId, const int session_id) {
     // Check all tree to find Session and check own protected value
-    const ConnectionList& connection_list = connection_handler_
-        ->getConnectionList();
+    const ConnectionList& connection_list = connection_handler_->getConnectionList();
     ASSERT_FALSE(connection_list.empty());
     ConnectionList::const_iterator conn_it = connection_list.find(connectionId);
     ASSERT_NE(conn_it, connection_list.end());
@@ -123,10 +139,8 @@ class ConnectionHandlerTest : public ::testing::Test {
       const ServiceList& service_list = session.service_list;
       ASSERT_FALSE(service_list.empty());
       // Check RPC and bulk services in session
-      ASSERT_NE(service_list.end(),
-                std::find(service_list.begin(), service_list.end(), kRpc));
-      ASSERT_NE(service_list.end(),
-                std::find(service_list.begin(), service_list.end(), kBulk));
+      ASSERT_NE(service_list.end(), std::find(service_list.begin(), service_list.end(), kRpc));
+      ASSERT_NE(service_list.end(), std::find(service_list.begin(), service_list.end(), kBulk));
     }
   }
 
@@ -135,8 +149,7 @@ class ConnectionHandlerTest : public ::testing::Test {
                           const ::protocol_handler::ServiceType serviceId,
                           const bool exists) {
     // Check all trees to find Service and check own protected value
-    const ConnectionList& connection_list = connection_handler_
-        ->getConnectionList();
+    const ConnectionList& connection_list = connection_handler_->getConnectionList();
     ASSERT_FALSE(connection_list.empty());
     ConnectionList::const_iterator conn_it = connection_list.find(connectionId);
     ASSERT_NE(conn_it, connection_list.end());
@@ -149,9 +162,7 @@ class ConnectionHandlerTest : public ::testing::Test {
     const Session& session = sess_it->second;
     const ServiceList& service_list = session.service_list;
     ASSERT_FALSE(service_list.empty());
-    ServiceList::const_iterator serv_it = std::find(service_list.begin(),
-                                                    service_list.end(),
-                                                    serviceId);
+    ServiceList::const_iterator serv_it = std::find(service_list.begin(), service_list.end(), serviceId);
     if (exists) {
       ASSERT_NE(serv_it, service_list.end());
     } else {
@@ -164,8 +175,7 @@ class ConnectionHandlerTest : public ::testing::Test {
                     const ::security_manager::SSLContext* ssl_context,
                     const bool is_protected) {
     // Check all tree to find Service and check own protected value
-    const ConnectionList& connection_list = connection_handler_
-        ->getConnectionList();
+    const ConnectionList& connection_list = connection_handler_->getConnectionList();
     ASSERT_FALSE(connection_list.empty());
     ConnectionList::const_iterator conn_it = connection_list.find(connectionId);
     ASSERT_NE(conn_it, connection_list.end());
@@ -181,9 +191,7 @@ class ConnectionHandlerTest : public ::testing::Test {
 #endif  // ENABLE_SECURITY
     const ServiceList& service_list = session.service_list;
     ASSERT_FALSE(service_list.empty());
-    ServiceList::const_iterator serv_it = std::find(service_list.begin(),
-                                                    service_list.end(),
-                                                    serviceId);
+    ServiceList::const_iterator serv_it = std::find(service_list.begin(), service_list.end(), serviceId);
     ASSERT_NE(serv_it, service_list.end());
 
     const Service& service = *serv_it;
@@ -191,31 +199,51 @@ class ConnectionHandlerTest : public ::testing::Test {
 #ifdef ENABLE_SECURITY
     if (is_protected) {
       // Emulate success protection - check enable service flag
-      const uint32_t connection_key = connection_handler_->KeyFromPair(
+      const uint32_t connection_key_ = connection_handler_->KeyFromPair(
           connectionId, session_id);
-      connection_handler_->SetProtectionFlag(connection_key, serviceId);
+      connection_handler_->SetProtectionFlag(connection_key_, serviceId);
     }
 #endif  // ENABLE_SECURITY
   }
 
+  void ChangeProtocol(const int connectionId, const int session_id, const uint8_t protocol_version) {
+    ConnectionList connection_list = connection_handler_->getConnectionList();
+
+    ConnectionList::const_iterator conn_it = (connection_handler_->getConnectionList()).find(connectionId);
+    ASSERT_NE(conn_it, connection_list.end());
+    Connection * connection = conn_it->second;
+    ASSERT_TRUE(connection != NULL);
+    connection->UpdateProtocolVersionSession(session_id, protocol_version);
+    uint8_t check_protocol_version;
+    EXPECT_TRUE(connection->ProtocolVersion(session_id, check_protocol_version));
+    EXPECT_EQ(check_protocol_version,protocol_version);
+
+  }
+
   ConnectionHandlerImpl* connection_handler_;
-  transport_manager::ConnectionUID uid;
-  uint32_t connection_key;
-  uint32_t start_session_id;
-  uint32_t out_hash_id;
+  transport_manager::DeviceHandle device_handle_;
+  transport_manager::ConnectionUID uid_;
+  uint32_t connection_key_;
+  uint32_t start_session_id_;
+  uint32_t out_hash_id_;
+
+  std::string connection_type_;
+  std::string device_name_;
+  std::string mac_address_;
+
 };
 
 TEST_F(ConnectionHandlerTest, StartSession_NoConnection) {
   // Null sessionId for start new session
   const uint8_t sessionID = 0;
   // Start new session with RPC service
-  const uint32_t result_fail = connection_handler_->OnSessionStartedCallback(
-      uid, sessionID, kRpc, PROTECTION_ON, &out_hash_id);
+  const uint32_t result_fail = connection_handler_->OnSessionStartedCallback(uid_, sessionID, kRpc, PROTECTION_ON, &out_hash_id_);
   // Unknown connection error is '0'
   EXPECT_EQ(0u, result_fail);
-  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id);
+  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
   ASSERT_TRUE(connection_handler_->getConnectionList().empty());
 }
+
 TEST_F(ConnectionHandlerTest, StartSession) {
   // Add virtual device and connection
   AddTestDeviceConnection();
@@ -376,17 +404,28 @@ TEST_F(ConnectionHandlerTest,OnFindNewApplicationsRequestWithoutSession) {
 TEST_F(ConnectionHandlerTest, OnMalformedMessageCallback) {
   AddTestDeviceConnection();
   AddTestSession();
+  AddTestService(kAudio);
+  AddTestService(kMobileNav);
   connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
   connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
 
+  InSequence seq;
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kMobileNav, kMalformed)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1);
   EXPECT_CALL(mock_connection_handler_observer,
-              OnServiceEndedCallback(connection_key_,_, kMalformed)).Times(2);
+              OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1);
   connection_handler_->OnMalformedMessageCallback(uid_);
 }
 
 TEST_F(ConnectionHandlerTest, OnApplicationFloodCallBack) {
   AddTestDeviceConnection();
   AddTestSession();
+  AddTestService(kAudio);
+  AddTestService(kMobileNav);
   connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
   connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
 
@@ -394,8 +433,16 @@ TEST_F(ConnectionHandlerTest, OnApplicationFloodCallBack) {
   connection_handler_->set_protocol_handler(&mock_protocol_handler);
 
   EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_));
+
+  InSequence seq;
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kMobileNav, kCommon)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1);
   EXPECT_CALL(mock_connection_handler_observer,
-              OnServiceEndedCallback(connection_key_,_, kCommon)).Times(2);
+              OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1);
   connection_handler_->OnApplicationFloodCallBack(uid_);
 }
 
@@ -442,7 +489,8 @@ TEST_F(ConnectionHandlerTest, CloseRevokedConnection) {
 TEST_F(ConnectionHandlerTest, CloseSessionWithCommonReason) {
   AddTestDeviceConnection();
   AddTestSession();
-
+  AddTestService(kAudio);
+  AddTestService(kMobileNav);
   connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
   connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
 
@@ -450,16 +498,24 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithCommonReason) {
   connection_handler_->set_protocol_handler(&mock_protocol_handler);
 
   EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_));
-  EXPECT_CALL(mock_connection_handler_observer,
-              OnServiceEndedCallback(connection_key_,_, kCommon)).Times(2);
 
+  InSequence seq;
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kMobileNav, kCommon)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1);
   connection_handler_->CloseSession(connection_key_, kCommon);
 }
 
 TEST_F(ConnectionHandlerTest, CloseSessionWithFloodReason) {
   AddTestDeviceConnection();
   AddTestSession();
-
+  AddTestService(kAudio);
+  AddTestService(kMobileNav);
   connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
   connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
 
@@ -467,16 +523,24 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithFloodReason) {
   connection_handler_->set_protocol_handler(&mock_protocol_handler);
 
   EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_));
-  EXPECT_CALL(mock_connection_handler_observer,
-              OnServiceEndedCallback(connection_key_,_, kFlood)).Times(2);
 
+  InSequence seq;
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kMobileNav, kFlood)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kAudio, kFlood)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kBulk, kFlood)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kRpc, kFlood)).Times(1);
   connection_handler_->CloseSession(connection_key_, kFlood);
 }
 
 TEST_F(ConnectionHandlerTest, CloseSessionWithMalformedMessage) {
   AddTestDeviceConnection();
   AddTestSession();
-
+  AddTestService(kAudio);
+  AddTestService(kMobileNav);
   connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
   connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
 
@@ -484,16 +548,24 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithMalformedMessage) {
   connection_handler_->set_protocol_handler(&mock_protocol_handler);
 
   EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)).Times(0);
-  EXPECT_CALL(mock_connection_handler_observer,
-              OnServiceEndedCallback(connection_key_,_, kMalformed)).Times(2);
 
+  InSequence seq;
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kMobileNav, kMalformed)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1);
   connection_handler_->CloseSession(connection_key_, kMalformed);
 }
 
 TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithMalformedMessage) {
   AddTestDeviceConnection();
   AddTestSession();
-
+  AddTestService(kAudio);
+  AddTestService(kMobileNav);
   connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
   connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
 
@@ -501,16 +573,24 @@ TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithMalformedMessage) {
   connection_handler_->set_protocol_handler(&mock_protocol_handler);
 
   EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)).Times(0);
-  EXPECT_CALL(mock_connection_handler_observer,
-              OnServiceEndedCallback(connection_key_,_, kMalformed)).Times(2);
 
+  InSequence seq;
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kMobileNav, kMalformed)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1);
   connection_handler_->CloseConnectionSessions(uid_, kMalformed);
 }
 
 TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithCommonReason) {
   AddTestDeviceConnection();
   AddTestSession();
-
+  AddTestService(kAudio);
+  AddTestService(kMobileNav);
   connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
   connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
 
@@ -518,9 +598,16 @@ TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithCommonReason) {
   connection_handler_->set_protocol_handler(&mock_protocol_handler);
 
   EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_));
-  EXPECT_CALL(mock_connection_handler_observer,
-              OnServiceEndedCallback(connection_key_,_, kCommon)).Times(2);
 
+  InSequence seq;
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kMobileNav, kCommon)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1);
   connection_handler_->CloseConnectionSessions(uid_, kCommon);
 }
 
@@ -531,35 +618,35 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) {
 
   // Start Audio service
   const uint32_t start_audio = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kAudio, PROTECTION_OFF, &out_hash_id);
-  EXPECT_EQ(start_session_id, start_audio);
-  CheckServiceExists(uid, start_session_id, kAudio, true);
-  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id);
+        uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
+  EXPECT_EQ(start_session_id_, start_audio);
+  CheckServiceExists(uid_, start_session_id_, kAudio, true);
+  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
 
   // Start Audio service
   const uint32_t start_video = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kMobileNav, PROTECTION_OFF, &out_hash_id);
-  EXPECT_EQ(start_session_id, start_video);
-  CheckServiceExists(uid, start_session_id, kMobileNav, true);
-  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id);
+      uid_, start_session_id_, kMobileNav, PROTECTION_OFF, &out_hash_id_);
+  EXPECT_EQ(start_session_id_, start_video);
+  CheckServiceExists(uid_, start_session_id_, kMobileNav, true);
+  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
 }
 
 TEST_F(ConnectionHandlerTest, ServiceStop_UnExistSession) {
   AddTestDeviceConnection();
 
-  const uint32_t end_session_result = connection_handler_
-      ->OnSessionEndedCallback(uid, 0u, 0u, kAudio);
+  const uint32_t end_session_result = connection_handler_->OnSessionEndedCallback(
+        uid_, 0u, 0u, kAudio);
   EXPECT_EQ(0u, end_session_result);
-  CheckSessionExists(uid, 0);
+  CheckSessionExists(uid_, 0);
 }
 
 TEST_F(ConnectionHandlerTest, ServiceStop_UnExistService) {
   AddTestDeviceConnection();
   AddTestSession();
-  const uint32_t end_session_result = connection_handler_
-      ->OnSessionEndedCallback(uid, start_session_id, 0u, kAudio);
+  const uint32_t end_session_result = connection_handler_->OnSessionEndedCallback(
+        uid_, start_session_id_, 0u, kAudio);
   EXPECT_EQ(0u, end_session_result);
-  CheckServiceExists(uid, start_session_id, kAudio, false);
+  CheckServiceExists(uid_, start_session_id_, kAudio, false);
 }
 
 TEST_F(ConnectionHandlerTest, ServiceStop) {
@@ -569,14 +656,14 @@ TEST_F(ConnectionHandlerTest, ServiceStop) {
   for (uint32_t some_hash_id = 0; some_hash_id < 0xFF; ++some_hash_id) {
     // Start audio service
     const uint32_t start_audio = connection_handler_->OnSessionStartedCallback(
-        uid, start_session_id, kAudio, PROTECTION_OFF, &out_hash_id);
-    EXPECT_EQ(start_session_id, start_audio);
-    EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id);
-
-    const uint32_t end_session_result = connection_handler_
-        ->OnSessionEndedCallback(uid, start_session_id, some_hash_id, kAudio);
-    EXPECT_EQ(connection_key, end_session_result);
-    CheckServiceExists(uid, start_session_id, kAudio, false);
+          uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
+    EXPECT_EQ(start_session_id_, start_audio);
+    EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
+
+    const uint32_t end_session_result = connection_handler_->OnSessionEndedCallback(
+          uid_, start_session_id_, some_hash_id, kAudio);
+    EXPECT_EQ(connection_key_, end_session_result);
+    CheckServiceExists(uid_, start_session_id_, kAudio, false);
   }
 }
 
@@ -585,18 +672,18 @@ TEST_F(ConnectionHandlerTest, SessionStop_CheckHash) {
   for (uint32_t session = 0; session < 0xFF; ++session) {
     AddTestSession();
 
-    const uint32_t hash = connection_key;
+    const uint32_t hash = connection_key_;
     const uint32_t wrong_hash = hash + 1;
 
-    const uint32_t end_audio_wrong_hash = connection_handler_
-        ->OnSessionEndedCallback(uid, start_session_id, wrong_hash, kRpc);
+    const uint32_t end_audio_wrong_hash = connection_handler_->OnSessionEndedCallback(
+          uid_, start_session_id_, wrong_hash, kRpc);
     EXPECT_EQ(0u, end_audio_wrong_hash);
-    CheckSessionExists(uid, start_session_id);
+    CheckSessionExists(uid_, start_session_id_);
 
     const uint32_t end_audio = connection_handler_->OnSessionEndedCallback(
-        uid, start_session_id, hash, kRpc);
-    EXPECT_EQ(connection_key, end_audio);
-    CheckSessionExists(uid, 0);
+          uid_, start_session_id_, hash, kRpc);
+    EXPECT_EQ(connection_key_, end_audio);
+    CheckSessionExists(uid_, 0);
   }
 }
 
@@ -608,15 +695,15 @@ TEST_F(ConnectionHandlerTest, SessionStop_CheckSpecificHash) {
     const uint32_t wrong_hash = protocol_handler::HASH_ID_WRONG;
     const uint32_t hash = protocol_handler::HASH_ID_NOT_SUPPORTED;
 
-    const uint32_t end_audio_wrong_hash = connection_handler_
-        ->OnSessionEndedCallback(uid, start_session_id, wrong_hash, kRpc);
+    const uint32_t end_audio_wrong_hash = connection_handler_->OnSessionEndedCallback(
+          uid_, start_session_id_, wrong_hash, kRpc);
     EXPECT_EQ(0u, end_audio_wrong_hash);
-    CheckSessionExists(uid, start_session_id);
+    CheckSessionExists(uid_, start_session_id_);
 
     const uint32_t end_audio = connection_handler_->OnSessionEndedCallback(
-        uid, start_session_id, hash, kRpc);
-    EXPECT_EQ(connection_key, end_audio);
-    CheckSessionExists(uid, 0);
+          uid_, start_session_id_, hash, kRpc);
+    EXPECT_EQ(connection_key_, end_audio);
+    CheckSessionExists(uid_, 0);
   }
 }
 
@@ -626,28 +713,24 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Unprote
   // Forbid start kRPC without encryption
   SetSpecificServices("0x07", "");
   // Start new session with RPC service
-  const uint32_t session_id_fail =
-      connection_handler_->OnSessionStartedCallback(uid, 0, kRpc,
-                                                    PROTECTION_OFF,
-                                                    &out_hash_id);
+  const uint32_t session_id_fail = connection_handler_->OnSessionStartedCallback(
+        uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(0u, session_id_fail);
-  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id);
+  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
 #else
   EXPECT_EQ(1u, session_id_fail);
-  EXPECT_EQ(SessionHash(uid, session_id_fail), out_hash_id);
+  EXPECT_EQ(SessionHash(uid_, session_id_fail), out_hash_id_);
 #endif  // ENABLE_SECURITY
 
   // Allow start kRPC without encryption
   SetSpecificServices("0x00, Non", "");
   // Start new session with RPC service
   const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
-      uid, 0, kRpc, PROTECTION_OFF, &out_hash_id);
+        uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
   EXPECT_NE(0u, session_id);
-  CheckService(uid, session_id, kRpc,
-               NULL,
-               PROTECTION_OFF);
-  EXPECT_EQ(SessionHash(uid, session_id), out_hash_id);
+  CheckService(uid_, session_id, kRpc, NULL, PROTECTION_OFF);
+  EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_);
 }
 
 TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect) {
@@ -656,9 +739,8 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect
   // Forbid start kRPC with encryption
   SetSpecificServices("", "0x06, 0x07, 0x08, Non");
   // Start new session with RPC service
-  const uint32_t session_id_fail =
-      connection_handler_->OnSessionStartedCallback(uid, 0, kRpc, PROTECTION_ON,
-      NULL);
+  const uint32_t session_id_fail = connection_handler_->OnSessionStartedCallback(
+        uid_, 0, kRpc, PROTECTION_ON, NULL);
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(0u, session_id_fail);
 #else
@@ -669,14 +751,12 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect
   SetSpecificServices("", "0x00, 0x05, Non");
   // Start new session with RPC service
   const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
-      uid, 0, kRpc, PROTECTION_ON, &out_hash_id);
+        uid_, 0, kRpc, PROTECTION_ON, &out_hash_id_);
   EXPECT_NE(0u, session_id);
-  EXPECT_EQ(SessionHash(uid, session_id), out_hash_id);
+  EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_);
 
   // Protection steal FALSE because of APPlink Protocol implementation
-  CheckService(uid, session_id, kRpc,
-               NULL,
-               PROTECTION_OFF);
+  CheckService(uid_, session_id, kRpc, NULL, PROTECTION_OFF);
 }
 
 TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Unprotect) {
@@ -690,7 +770,7 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Unprote
   SetSpecificServices("0x06, 0x0A, 0x08, Non", "");
   // Start new session with Audio service
   const uint32_t session_id2 = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kAudio, PROTECTION_OFF, NULL);
+        uid_, start_session_id_, kAudio, PROTECTION_OFF, NULL);
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(0u, session_id2);
 #else
@@ -699,17 +779,17 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Unprote
   // Allow start kAudio without encryption
   SetSpecificServices("0x06, 0x0B, 0x08, Non", "");
   const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kAudio, PROTECTION_OFF, &out_hash_id);
+        uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
   // Returned original session id
 #ifdef ENABLE_SECURITY
-  EXPECT_EQ(start_session_id, session_id3);
-  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id);
-  CheckService(uid, session_id3, kRpc,
-                 NULL,
-                 PROTECTION_OFF);
+  EXPECT_EQ(start_session_id_, session_id3);
+  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
+  CheckService(uid_, session_id3, kRpc,
+      NULL,
+      PROTECTION_OFF);
 #else
   EXPECT_EQ(0u, session_id3);
-  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id);
+  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
 #endif  // ENABLE_SECURITY
 }
 
@@ -722,9 +802,8 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Protect
   // Forbid start kAudio with encryption
   SetSpecificServices("", "0x06, 0x0A, 0x08, Non");
   // Start new session with Audio service
-  const uint32_t session_id_reject = connection_handler_
-      ->OnSessionStartedCallback(uid, start_session_id, kAudio, PROTECTION_ON,
-  NULL);
+  const uint32_t session_id_reject = connection_handler_->OnSessionStartedCallback(
+        uid_, start_session_id_, kAudio, PROTECTION_ON, NULL);
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(0u, session_id_reject);
 #else
@@ -733,20 +812,18 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Protect
   // Allow start kAudio with encryption
   SetSpecificServices("", "Non");
   const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kAudio, PROTECTION_ON, &out_hash_id);
+        uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_);
   // Returned original session id
 #ifdef ENABLE_SECURITY
-  EXPECT_EQ(start_session_id, session_id3);
-  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id);
-  CheckService(uid, session_id3, kAudio,
-               NULL,
-               PROTECTION_ON);
+  EXPECT_EQ(start_session_id_, session_id3);
+  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
+  CheckService(uid_, session_id3, kAudio,
+      NULL,
+      PROTECTION_ON);
 #else
   EXPECT_EQ(0u, session_id3);
-  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id);
-  CheckService(uid, start_session_id, kAudio,
-                   NULL,
-                   PROTECTION_OFF);
+  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
+  CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_OFF);
 #endif  // ENABLE_SECURITY
 }
 
@@ -756,47 +833,41 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtect) {
 
   // Start RPC protection
   const uint32_t session_id_new = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kRpc, PROTECTION_ON, &out_hash_id);
+        uid_, start_session_id_, kRpc, PROTECTION_ON, &out_hash_id_);
 #ifdef ENABLE_SECURITY
-  EXPECT_EQ(start_session_id, session_id_new);
+  EXPECT_EQ(start_session_id_, session_id_new);
   // Post protection nedd no hash
-  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id);
-  CheckService(uid, start_session_id, kRpc,
-               NULL,
-               PROTECTION_ON);
+  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
+  CheckService(uid_, start_session_id_, kRpc,
+      NULL,
+      PROTECTION_ON);
 #else
   EXPECT_EQ(0u, session_id_new);
-    // Post protection nedd no hash
-  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id);
-  CheckService(uid, start_session_id, kRpc,
-                 NULL,
-                 PROTECTION_OFF);
+  // Post protection nedd no hash
+  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
+  CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_OFF);
 #endif  // ENABLE_SECURITY
 
   // Start Audio session without protection
   const uint32_t session_id2 = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kAudio, PROTECTION_OFF, &out_hash_id);
-  EXPECT_EQ(start_session_id, session_id2);
-  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id);
-  CheckService(uid, start_session_id, kAudio,
-               NULL,
-               PROTECTION_OFF);
+        uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
+  EXPECT_EQ(start_session_id_, session_id2);
+  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
+  CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_OFF);
 
   // Start Audio protection
   const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kAudio, PROTECTION_ON, &out_hash_id);
+        uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_);
 #ifdef ENABLE_SECURITY
-  EXPECT_EQ(start_session_id, session_id3);
-  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id);
-  CheckService(uid, start_session_id, kAudio,
-               NULL,
-               PROTECTION_ON);
+  EXPECT_EQ(start_session_id_, session_id3);
+  EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
+  CheckService(uid_, start_session_id_, kAudio,
+      NULL,
+      PROTECTION_ON);
 #else
   EXPECT_EQ(0u, session_id3);
-  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id);
-  CheckService(uid, start_session_id, kAudio,
-                 NULL,
-                 PROTECTION_OFF);
+  EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
+  CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_OFF);
 #endif  // ENABLE_SECURITY
 }
 
@@ -805,169 +876,168 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtectBulk) {
   AddTestSession();
 
   const uint32_t session_id_new = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kBulk, PROTECTION_ON, NULL);
+        uid_, start_session_id_, kBulk, PROTECTION_ON, NULL);
 #ifdef ENABLE_SECURITY
-  EXPECT_EQ(start_session_id, session_id_new);
-  CheckService(uid, start_session_id, kRpc,
-               NULL,
-               PROTECTION_ON);
+  EXPECT_EQ(start_session_id_, session_id_new);
+  CheckService(uid_, start_session_id_, kRpc,
+      NULL,
+      PROTECTION_ON);
 #else
   EXPECT_EQ(0u, session_id_new);
-  CheckService(uid, start_session_id, kRpc,
-                 NULL,
-                 PROTECTION_OFF);
+  CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_OFF);
 #endif  // ENABLE_SECURITY
 }
 
 #ifdef ENABLE_SECURITY
 TEST_F(ConnectionHandlerTest, SetSSLContext_Null) {
   // No SSLContext on start up
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
   EXPECT_EQ(::security_manager::SecurityManager::ERROR_INTERNAL,
-            connection_handler_->SetSSLContext(connection_key, NULL));
+      connection_handler_->SetSSLContext(connection_key_, NULL));
   // No SSLContext after error
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
 
   AddTestDeviceConnection();
   EXPECT_EQ(::security_manager::SecurityManager::ERROR_INTERNAL,
-            connection_handler_->SetSSLContext(connection_key, NULL));
+      connection_handler_->SetSSLContext(connection_key_, NULL));
   // No SSLContext after error
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
 
   AddTestSession();
   EXPECT_EQ(::security_manager::SecurityManager::ERROR_SUCCESS,
-            connection_handler_->SetSSLContext(connection_key, NULL));
+      connection_handler_->SetSSLContext(connection_key_, NULL));
   // NULL SSLContext after success
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
 }
 TEST_F(ConnectionHandlerTest, SetSSLContext) {
   // No SSLContext on start up
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
 
   testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context;
   // Error on no connection
   EXPECT_EQ(
-      connection_handler_->SetSSLContext(connection_key, &mock_ssl_context),
+      connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context),
       ::security_manager::SecurityManager::ERROR_INTERNAL);
   // No SSLContext after error
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
 
   AddTestDeviceConnection();
   // Error on no session
   EXPECT_EQ(
-      connection_handler_->SetSSLContext(connection_key, &mock_ssl_context),
+      connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context),
       ::security_manager::SecurityManager::ERROR_INTERNAL);
   // No SSLContext after error
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
   AddTestSession();
   // Success
   EXPECT_EQ(
-      connection_handler_->SetSSLContext(connection_key, &mock_ssl_context),
+      connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context),
       ::security_manager::SecurityManager::ERROR_SUCCESS);
   // SSLContext set on Success
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            &mock_ssl_context);
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      &mock_ssl_context);
   // Null SSLContext for unprotected services
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kRpc),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kBulk),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kAudio),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kMobileNav),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kMobileNav),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
 }
 
 TEST_F(ConnectionHandlerTest, GetSSLContext_ByProtectedService) {
   // No SSLContext on start up
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
 
   testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context;
   AddTestDeviceConnection();
   AddTestSession();
   EXPECT_EQ(
-      connection_handler_->SetSSLContext(connection_key, &mock_ssl_context),
+      connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context),
       ::security_manager::SecurityManager::ERROR_SUCCESS);
   // kControl service mean - return for all connection
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            &mock_ssl_context);
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      &mock_ssl_context);
 
   // kAudio is not exists yet
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kAudio),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
   // Open kAudio service
   const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kAudio, PROTECTION_ON, NULL);
-  EXPECT_EQ(session_id, start_session_id);
-  CheckService(uid, session_id, kAudio, &mock_ssl_context, PROTECTION_ON);
+      uid_, start_session_id_, kAudio, PROTECTION_ON, NULL);
+  EXPECT_EQ(session_id, start_session_id_);
+  CheckService(uid_, session_id, kAudio, &mock_ssl_context, PROTECTION_ON);
 
   // kAudio is not exists yet
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kAudio),
-            &mock_ssl_context);
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio),
+      &mock_ssl_context);
 }
-TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtecteRPC) {
+TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedRPC) {
   testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context;
   AddTestDeviceConnection();
   AddTestSession();
   EXPECT_EQ(
-      connection_handler_->SetSSLContext(connection_key, &mock_ssl_context),
+      connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context),
       ::security_manager::SecurityManager::ERROR_SUCCESS);
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            &mock_ssl_context);
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      &mock_ssl_context);
 
   // kRpc is not protected
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kRpc),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
 
   // Protect kRpc (Bulk will be protect also)
   const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kRpc, PROTECTION_ON, NULL);
-  EXPECT_EQ(start_session_id, session_id);
-  CheckService(uid, session_id, kRpc, &mock_ssl_context, PROTECTION_ON);
+      uid_, start_session_id_, kRpc, PROTECTION_ON, NULL);
+  EXPECT_EQ(start_session_id_, session_id);
+  CheckService(uid_, session_id, kRpc, &mock_ssl_context, PROTECTION_ON);
 
   // kRpc is protected
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kRpc),
-            &mock_ssl_context);
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
+      &mock_ssl_context);
   // kBulk is protected
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kBulk),
-            &mock_ssl_context);
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk),
+      &mock_ssl_context);
 }
-TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtecteBulk) {
+TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedBulk) {
   testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context;
   AddTestDeviceConnection();
   AddTestSession();
   EXPECT_EQ(
-      connection_handler_->SetSSLContext(connection_key, &mock_ssl_context),
+      connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context),
       ::security_manager::SecurityManager::ERROR_SUCCESS);
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl),
-            &mock_ssl_context);
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
+      &mock_ssl_context);
 
   // kRpc is not protected
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kRpc),
-            reinterpret_cast<security_manager::SSLContext *>(NULL));
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
+      reinterpret_cast<security_manager::SSLContext *>(NULL));
 
   // Protect Bulk (kRpc will be protected also)
   const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
-      uid, start_session_id, kBulk, PROTECTION_ON, NULL);
-  EXPECT_EQ(start_session_id, session_id);
-  CheckService(uid, session_id, kRpc, &mock_ssl_context, PROTECTION_ON);
+      uid_, start_session_id_, kBulk, PROTECTION_ON, NULL);
+  EXPECT_EQ(start_session_id_, session_id);
+  CheckService(uid_, session_id, kRpc, &mock_ssl_context, PROTECTION_ON);
 
   // kRpc is protected
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kRpc),
-            &mock_ssl_context);
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
+      &mock_ssl_context);
   // kBulk is protected
-  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kBulk),
-            &mock_ssl_context);
+  EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk),
+      &mock_ssl_context);
 }
 #endif  // ENABLE_SECURITY
+
 }  // namespace connection_handle_test
 }  // namespace components
 }  // namespace test
diff --git a/src/components/connection_handler/test/connection_test.cc b/src/components/connection_handler/test/connection_test.cc
index 9462f039c9..a1e9307ce3 100644
--- a/src/components/connection_handler/test/connection_test.cc
+++ b/src/components/connection_handler/test/connection_test.cc
@@ -37,6 +37,7 @@
 #include "connection_handler/connection_handler_impl.h"
 #include "protocol/service_type.h"
 #include "utils/shared_ptr.h"
+#include "security_manager_mock.h"
 
 #define EXPECT_RETURN_TRUE true
 #define EXPECT_RETURN_FALSE false
@@ -46,17 +47,18 @@
 namespace test {
 namespace components {
 namespace connection_handle {
-  using namespace ::connection_handler;
-  using namespace ::protocol_handler;
+using namespace ::connection_handler;
+using namespace ::protocol_handler;
 
-class ConnectionTest: public ::testing::Test {
+class ConnectionTest : public ::testing::Test {
  protected:
   void SetUp() OVERRIDE {
     connection_handler_ = ConnectionHandlerImpl::instance();
     const ConnectionHandle connectionHandle = 0;
     const DeviceHandle device_handle = 0;
-    connection_.reset(new Connection(connectionHandle, device_handle,
-                                     connection_handler_, 10000));
+    connection_.reset(
+        new Connection(connectionHandle, device_handle, connection_handler_,
+                       10000));
   }
 
   void TearDown() OVERRIDE {
@@ -70,16 +72,17 @@ class ConnectionTest: public ::testing::Test {
     EXPECT_FALSE(sessionMap.empty());
     const ServiceList serviceList = sessionMap.begin()->second.service_list;
     EXPECT_FALSE(serviceList.empty());
-    const ServiceList::const_iterator it =
-        std::find(serviceList.begin(), serviceList.end(), protocol_handler::kRpc);
+    const ServiceList::const_iterator it = std::find(serviceList.begin(),
+                                                     serviceList.end(),
+                                                     protocol_handler::kRpc);
     EXPECT_NE(it, serviceList.end());
   }
   void AddNewService(const protocol_handler::ServiceType service_type,
-                    const bool protection,
-                    const bool expect_add_new_service_call_result,
-                    const bool expect_exist_service) {
-    const bool result = connection_->
-        AddNewService(session_id, service_type, protection);
+                     const bool protection,
+                     const bool expect_add_new_service_call_result,
+                     const bool expect_exist_service) {
+    const bool result = connection_->AddNewService(session_id, service_type,
+                                                   protection);
     EXPECT_EQ(result, expect_add_new_service_call_result);
 
 #ifdef ENABLE_SECURITY
@@ -91,8 +94,9 @@ class ConnectionTest: public ::testing::Test {
     EXPECT_FALSE(session_map.empty());
     const ServiceList newServiceList = session_map.begin()->second.service_list;
     EXPECT_FALSE(newServiceList.empty());
-    const ServiceList::const_iterator it =
-        std::find(newServiceList.begin(), newServiceList.end(), service_type);
+    const ServiceList::const_iterator it = std::find(newServiceList.begin(),
+                                                     newServiceList.end(),
+                                                     service_type);
     const bool found_result = it != newServiceList.end();
     EXPECT_EQ(expect_exist_service, found_result);
 #ifdef ENABLE_SECURITY
@@ -106,16 +110,17 @@ class ConnectionTest: public ::testing::Test {
   void RemoveService(const protocol_handler::ServiceType service_type,
                      const bool expect_remove_service_result,
                      const bool expect_exist_service) {
-    const bool result = connection_->
-        RemoveService(session_id, service_type);
+    const bool result = connection_->RemoveService(session_id, service_type);
     EXPECT_EQ(result, expect_remove_service_result);
 
     const SessionMap newSessionMap = connection_->session_map();
     EXPECT_FALSE(newSessionMap.empty());
-    const ServiceList newServiceList = newSessionMap.begin()->second.service_list;
+    const ServiceList newServiceList = newSessionMap.begin()->second
+        .service_list;
     EXPECT_FALSE(newServiceList.empty());
-    const ServiceList::const_iterator it =
-        std::find(newServiceList.begin(), newServiceList.end(), service_type);
+    const ServiceList::const_iterator it = std::find(newServiceList.begin(),
+                                                     newServiceList.end(),
+                                                     service_type);
     const bool found_result = it != newServiceList.end();
     EXPECT_EQ(expect_exist_service, found_result);
   }
@@ -125,50 +130,89 @@ class ConnectionTest: public ::testing::Test {
   uint32_t session_id;
 };
 
+
+TEST_F(ConnectionTest, Session_TryGetProtocolVersionWithoutSession) {
+  uint8_t protocol_version;
+  EXPECT_FALSE(connection_->ProtocolVersion(session_id, protocol_version));
+}
+
+TEST_F(ConnectionTest, Session_GetDefaultProtocolVersion) {
+  StartSession();
+  uint8_t protocol_version;
+  EXPECT_TRUE(connection_->ProtocolVersion(session_id, protocol_version));
+  EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_2);
+}
+TEST_F(ConnectionTest, Session_UpdateProtocolVersion) {
+  StartSession();
+  uint8_t protocol_version = ::protocol_handler::PROTOCOL_VERSION_3;
+  connection_->UpdateProtocolVersionSession(session_id, protocol_version);
+  EXPECT_TRUE(connection_->ProtocolVersion(session_id, protocol_version));
+  EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_3);
+}
+
+TEST_F(ConnectionTest, HeartBeat_NotSupported) {
+  // Arrange
+  StartSession();
+  uint8_t protocol_version;
+  EXPECT_TRUE(connection_->ProtocolVersion(session_id, protocol_version));
+  EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_2);
+
+  // Assert
+  EXPECT_FALSE(connection_->SupportHeartBeat(session_id));
+}
+
+TEST_F(ConnectionTest, DISABLED_HeartBeat_Supported) {
+  // Arrange
+  StartSession();
+
+  // Check if protocol version is 3
+  uint8_t protocol_version = ::protocol_handler::PROTOCOL_VERSION_3;
+  connection_->UpdateProtocolVersionSession(session_id, protocol_version);
+  EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_3);
+
+  // Assert
+  EXPECT_TRUE(connection_->SupportHeartBeat(session_id));
+}
+
 // Try to add service without session
 TEST_F(ConnectionTest, Session_AddNewServiceWithoutSession) {
-  EXPECT_EQ(connection_->
-            AddNewService(session_id, protocol_handler::kAudio, true),
-            EXPECT_RETURN_FALSE);
-  EXPECT_EQ(connection_->
-            AddNewService(session_id, protocol_handler::kAudio, false),
-            EXPECT_RETURN_FALSE);
-  EXPECT_EQ(connection_->
-            AddNewService(session_id, protocol_handler::kMobileNav, true),
-            EXPECT_RETURN_FALSE);
-  EXPECT_EQ(connection_->
-            AddNewService(session_id, protocol_handler::kMobileNav, false),
-            EXPECT_RETURN_FALSE);
+  EXPECT_EQ(
+      connection_->AddNewService(session_id, protocol_handler::kAudio, true),
+      EXPECT_RETURN_FALSE);
+  EXPECT_EQ(
+      connection_->AddNewService(session_id, protocol_handler::kAudio, false),
+      EXPECT_RETURN_FALSE);
+  EXPECT_EQ(
+      connection_->AddNewService(session_id, protocol_handler::kMobileNav, true),
+      EXPECT_RETURN_FALSE);
+  EXPECT_EQ(
+      connection_->AddNewService(session_id, protocol_handler::kMobileNav, false),
+      EXPECT_RETURN_FALSE);
 }
 
 // Try to remove service without session
 TEST_F(ConnectionTest, Session_RemoveServiceWithoutSession) {
-  EXPECT_EQ(connection_->
-            RemoveService(session_id, protocol_handler::kAudio),
-            EXPECT_RETURN_FALSE);
-  EXPECT_EQ(connection_->
-            RemoveService(session_id, protocol_handler::kMobileNav),
+  EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio),
             EXPECT_RETURN_FALSE);
+  EXPECT_EQ(
+      connection_->RemoveService(session_id, protocol_handler::kMobileNav),
+      EXPECT_RETURN_FALSE);
 }
 // Try to remove RPC
 TEST_F(ConnectionTest, Session_RemoveRPCBulk) {
   StartSession();
-  EXPECT_EQ(connection_->
-            RemoveService(session_id, protocol_handler::kRpc),
+  EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kRpc),
             EXPECT_RETURN_FALSE);
-  EXPECT_EQ(connection_->
-            RemoveService(session_id, protocol_handler::kBulk),
+  EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kBulk),
             EXPECT_RETURN_FALSE);
 }
 // Control Service could not be started anyway
 TEST_F(ConnectionTest, Session_AddControlService) {
   StartSession();
 
-  AddNewService(protocol_handler::kControl, PROTECTION_OFF,
-                EXPECT_RETURN_FALSE,
+  AddNewService(protocol_handler::kControl, PROTECTION_OFF, EXPECT_RETURN_FALSE,
                 EXPECT_SERVICE_NOT_EXISTS);
-  AddNewService(protocol_handler::kControl, PROTECTION_ON,
-                EXPECT_RETURN_FALSE,
+  AddNewService(protocol_handler::kControl, PROTECTION_ON, EXPECT_RETURN_FALSE,
                 EXPECT_SERVICE_NOT_EXISTS);
 }
 
@@ -177,89 +221,107 @@ TEST_F(ConnectionTest, Session_AddInvalidService) {
   StartSession();
 
   AddNewService(protocol_handler::kInvalidServiceType, PROTECTION_OFF,
-                EXPECT_RETURN_FALSE,
-                EXPECT_SERVICE_NOT_EXISTS);
+                EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS);
   AddNewService(protocol_handler::kInvalidServiceType, PROTECTION_ON,
-                EXPECT_RETURN_FALSE,
-                EXPECT_SERVICE_NOT_EXISTS);
+                EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS);
 }
 
 // RPC and Bulk Services could be only delay protected
 TEST_F(ConnectionTest, Session_AddRPCBulkServices) {
   StartSession();
   AddNewService(protocol_handler::kRpc, PROTECTION_OFF,
-                EXPECT_RETURN_FALSE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
 
   //  Bulk shall not be added and shall be PROTECTION_OFF
   AddNewService(protocol_handler::kBulk, PROTECTION_OFF,
-                EXPECT_RETURN_FALSE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
 #ifdef ENABLE_SECURITY
   AddNewService(protocol_handler::kRpc, PROTECTION_ON,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+      EXPECT_RETURN_TRUE,
+      EXPECT_SERVICE_EXISTS);
 #else
   AddNewService(protocol_handler::kRpc, PROTECTION_ON,
-                EXPECT_RETURN_FALSE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
 #endif  // ENABLE_SECURITY
 
   //  Bulk shall not be added and shall be PROTECTION_ON
   AddNewService(protocol_handler::kBulk, PROTECTION_ON,
-                EXPECT_RETURN_FALSE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
 }
 
 TEST_F(ConnectionTest, Session_AddAllOtherService_Unprotected) {
   StartSession();
 
   AddNewService(protocol_handler::kAudio, PROTECTION_OFF,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
   AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
 }
 
 TEST_F(ConnectionTest, Session_AddAllOtherService_Protected) {
   StartSession();
 
   AddNewService(protocol_handler::kAudio, PROTECTION_ON,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
   AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+}
+
+TEST_F(ConnectionTest, FindAddedService) {
+  StartSession();
+
+  // Arrange
+  SessionMap currentSessionMap = connection_->session_map();
+  Service * sessionWithService = currentSessionMap.find(session_id)->second
+      .FindService(protocol_handler::kAudio);
+  EXPECT_EQ(NULL, sessionWithService);
+
+  // Act
+  AddNewService(protocol_handler::kAudio, PROTECTION_OFF,
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+
+  currentSessionMap = connection_->session_map();
+
+  // Expect that service is existing
+  sessionWithService = currentSessionMap.find(session_id)->second.FindService(
+                       protocol_handler::kAudio);
+  EXPECT_TRUE(sessionWithService != NULL);
+}
+
+TEST_F(ConnectionTest, Session_RemoveAddedService) {
+  StartSession();
+  AddNewService(protocol_handler::kAudio, PROTECTION_OFF,
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+
+  EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio),
+            EXPECT_RETURN_TRUE);
+
+  // Try delete nonexisting service
+  EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio),
+            EXPECT_RETURN_FALSE);
 }
 
 TEST_F(ConnectionTest, Session_AddAllOtherService_DelayProtected1) {
   StartSession();
 
   AddNewService(protocol_handler::kAudio, PROTECTION_OFF,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
 
   AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
 
 #ifdef ENABLE_SECURITY
   AddNewService(protocol_handler::kAudio, PROTECTION_ON,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
 
   AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
 #else
   AddNewService(protocol_handler::kAudio, PROTECTION_ON,
-                EXPECT_RETURN_FALSE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
 
   AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
-                EXPECT_RETURN_FALSE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
 #endif  // ENABLE_SECURITY
 }
 
@@ -268,32 +330,121 @@ TEST_F(ConnectionTest, Session_AddAllOtherService_DelayProtected2) {
   StartSession();
 
   AddNewService(protocol_handler::kAudio, PROTECTION_OFF,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
 #ifdef ENABLE_SECURITY
   AddNewService(protocol_handler::kAudio, PROTECTION_ON,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+      EXPECT_RETURN_TRUE,
+      EXPECT_SERVICE_EXISTS);
 #else
   AddNewService(protocol_handler::kAudio, PROTECTION_ON,
-                EXPECT_RETURN_FALSE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
 #endif  // ENABLE_SECURITY
 
   AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
 #ifdef ENABLE_SECURITY
   AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
-                EXPECT_RETURN_TRUE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
 #else
   AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
-                EXPECT_RETURN_FALSE,
-                EXPECT_SERVICE_EXISTS);
+                EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
 #endif  // ENABLE_SECURITY
 }
 
+TEST_F(ConnectionTest, RemoveSession) {
+  StartSession();
+  EXPECT_EQ(session_id, connection_->RemoveSession(session_id));
+  EXPECT_EQ(0u, connection_->RemoveSession(session_id));
+}
+
+#ifdef ENABLE_SECURITY
+
+TEST_F(ConnectionTest, SetSSLContextWithoutSession) {
+  //random value. Session was not started
+  uint8_t session_id = 10;
+  security_manager_test::SSLContextMock mock_ssl_context;
+  int setResult = connection_->SetSSLContext(session_id, &mock_ssl_context);
+  EXPECT_EQ(security_manager::SecurityManager::ERROR_INTERNAL,setResult);
+}
+
+TEST_F(ConnectionTest, GetSSLContextWithoutSession) {
+  //random value. Session was not started
+  uint8_t session_id = 10;
+
+  EXPECT_EQ(NULL,connection_->GetSSLContext(session_id,protocol_handler::kMobileNav));
+}
+
+TEST_F(ConnectionTest, SetGetSSLContext) {
+  StartSession();
+
+  EXPECT_EQ(NULL,connection_->GetSSLContext(session_id,protocol_handler::kMobileNav));
+  AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
+                EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+
+  EXPECT_EQ(NULL,connection_->GetSSLContext(session_id,protocol_handler::kMobileNav));
+
+  security_manager_test::SSLContextMock mock_ssl_context;
+  //Set SSLContext
+  int setResult = connection_->SetSSLContext(session_id, &mock_ssl_context);
+  EXPECT_EQ(security_manager::SecurityManager::ERROR_SUCCESS,setResult);
+
+  security_manager::SSLContext *result = connection_->GetSSLContext(session_id,protocol_handler::kMobileNav);
+  EXPECT_EQ(result,&mock_ssl_context);
+}
+
+TEST_F(ConnectionTest, SetProtectionFlagForRPC) {
+  StartSession();
+  // Arrange
+  SessionMap currentSessionMap = connection_->session_map();
+  Service * service_rpc = currentSessionMap.find(session_id)->second
+       .FindService(protocol_handler::kRpc);
+
+  EXPECT_FALSE(service_rpc->is_protected_);
+
+  Service * service_bulk = currentSessionMap.find(session_id)->second
+         .FindService(protocol_handler::kBulk);
+  EXPECT_FALSE(service_bulk->is_protected_);
+
+  // Expect that service protection is enabled
+  connection_->SetProtectionFlag(session_id, protocol_handler::kRpc);
+
+  currentSessionMap = connection_->session_map();
+  service_bulk = currentSessionMap.find(session_id)->second
+        .FindService(protocol_handler::kBulk);
+  EXPECT_TRUE(service_bulk->is_protected_);
+
+  service_rpc = currentSessionMap.find(session_id)->second
+        .FindService(protocol_handler::kRpc);
+  EXPECT_TRUE(service_rpc->is_protected_);
+}
+
+
+TEST_F(ConnectionTest, SetProtectionFlagForBulk) {
+  StartSession();
+  // Arrange
+  SessionMap currentSessionMap = connection_->session_map();
+  Service * service_rpc = currentSessionMap.find(session_id)->second
+       .FindService(protocol_handler::kRpc);
+
+  EXPECT_FALSE(service_rpc->is_protected_);
+
+  Service * service_bulk = currentSessionMap.find(session_id)->second
+         .FindService(protocol_handler::kBulk);
+  EXPECT_FALSE(service_bulk->is_protected_);
+
+  // Expect that service protection is enabled
+  connection_->SetProtectionFlag(session_id, protocol_handler::kBulk);
+
+  currentSessionMap = connection_->session_map();
+  service_bulk = currentSessionMap.find(session_id)->second.FindService(protocol_handler::kBulk);
+  EXPECT_TRUE(service_bulk->is_protected_);
+
+  service_rpc = currentSessionMap.find(session_id)->second.FindService(protocol_handler::kRpc);
+  EXPECT_TRUE(service_rpc->is_protected_);
+}
+
+#endif  // ENABLE_SECURITY
+
 }  // namespace connection_handle
 }  // namespace components
 }  // namespace test
diff --git a/src/components/connection_handler/test/device_test.cc b/src/components/connection_handler/test/device_test.cc
new file mode 100644
index 0000000000..dc1a51faf1
--- /dev/null
+++ b/src/components/connection_handler/test/device_test.cc
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2015, 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 <gtest/gtest.h>
+#include "encryption/hashing.h"
+#include "connection_handler/device.h"
+
+namespace test {
+namespace components {
+namespace connection_handle {
+
+using namespace connection_handler;
+TEST(ConnectionDevice, CompareDevicesWithDifferentMacAddresses) {
+  DeviceHandle device_handle = 0;
+
+  std::string connection_type = "BTMAC";
+  std::string device_name = "test_name";
+  std::string mac_address = "test_address";
+
+  Device test_device(device_handle, device_name, mac_address, connection_type);
+
+  EXPECT_EQ(device_handle, test_device.device_handle());
+  EXPECT_EQ(device_name, test_device.user_friendly_name());
+  EXPECT_NE(mac_address, test_device.mac_address());
+  EXPECT_EQ(connection_type, test_device.connection_type());
+  std::string hash_mac_address = test_device.mac_address();
+
+  std::string test_next_mac_address = "test_address_";
+  Device next_test_device(device_handle, device_name, test_next_mac_address, connection_type);
+  EXPECT_NE(test_next_mac_address, next_test_device.mac_address());
+  std::string hash_next_mac_address = next_test_device.mac_address();
+
+  EXPECT_NE(hash_mac_address, hash_next_mac_address);
+}
+
+TEST(ConnectionDevice, MacAddressHash) {
+  DeviceHandle device_handle = 0;
+  std::string connection_type = "BTMAC";
+  std::string device_name = "test_name";
+  std::string mac_address = "test_address";
+
+  Device test_device(device_handle, device_name, mac_address, connection_type);
+
+  std::string hashed_mac_address = encryption::MakeHash(mac_address);
+  EXPECT_EQ(hashed_mac_address, test_device.mac_address());
+}
+
+}  // namespace connection_handle
+}  // namespace components
+}  // namespace test
+
diff --git a/src/components/connection_handler/test/heart_beat_monitor_test.cc b/src/components/connection_handler/test/heart_beat_monitor_test.cc
index f4a1708de5..710977c643 100644
--- a/src/components/connection_handler/test/heart_beat_monitor_test.cc
+++ b/src/components/connection_handler/test/heart_beat_monitor_test.cc
@@ -31,6 +31,7 @@
  */
 
 #include <string>
+#include <iostream>
 //#include <stdio.h>
 #include "gmock/gmock.h"
 #include "connection_handler/heartbeat_monitor.h"
@@ -38,6 +39,12 @@
 #include "connection_handler/connection_handler.h"
 #include "config_profile/profile.h"
 
+namespace {
+const int32_t MILLISECONDS_IN_SECOND = 1000;
+const int32_t MICROSECONDS_IN_MILLISECONDS = 1000;
+const int32_t MICROSECONDS_IN_SECOND = 1000 * 1000;
+}
+
 namespace test {
 namespace components {
 namespace connection_handler_test {
@@ -62,6 +69,7 @@ class ConnectionHandlerMock : public connection_handler::ConnectionHandler {
   MOCK_METHOD2(GetDeviceID,
       bool(const std::string& mac_address,
           connection_handler::DeviceHandle* device_handle));
+  MOCK_CONST_METHOD1(GetConnectedDevicesMAC, void(std::vector<std::string> &device_macs));
   MOCK_METHOD2(CloseSession,
             void(uint32_t key,
                  connection_handler::CloseSessionReason close_reason));
@@ -78,10 +86,14 @@ class ConnectionHandlerMock : public connection_handler::ConnectionHandler {
       void(connection_handler::ConnectionHandle connection_handle,
           uint8_t session_id));
   MOCK_METHOD2(SetHeartBeatTimeout, void(uint32_t connection_key,
-          int32_t timeout));
+          uint32_t timeout));
   MOCK_METHOD2(BindProtocolVersionWithSession,
       void(uint32_t connection_key,
           uint8_t protocol_version));
+  MOCK_METHOD4(GetDataOnSessionKey,
+      int32_t(uint32_t key, uint32_t* app_id,
+              std::list<int32_t>* sessions_list,
+              uint32_t* device_id));
 };
 
 class HeartBeatMonitorTest : public testing::Test {
@@ -95,7 +107,7 @@ public:
 protected:
   testing::NiceMock<ConnectionHandlerMock> connection_handler_mock;
   connection_handler::Connection* conn;
-  int32_t kTimeout;
+  uint32_t kTimeout;
   static const connection_handler::ConnectionHandle kConnectionHandle = 0xABCDEF;
 
   virtual void SetUp() {
@@ -122,7 +134,7 @@ TEST_F(HeartBeatMonitorTest, TimerNotStarted) {
   EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, _)).Times(0);
 
   conn->AddNewSession();
-  sleep(kTimeout + 1);
+  usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND);
 }
 
 TEST_F(HeartBeatMonitorTest, TimerNotElapsed) {
@@ -132,7 +144,7 @@ TEST_F(HeartBeatMonitorTest, TimerNotElapsed) {
 
   const uint32_t session = conn->AddNewSession();
   conn->StartHeartBeat(session);
-  sleep(kTimeout - 1);
+  usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND);
 }
 
 TEST_F(HeartBeatMonitorTest, TimerElapsed) {
@@ -144,7 +156,7 @@ TEST_F(HeartBeatMonitorTest, TimerElapsed) {
   EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, session));
 
   conn->StartHeartBeat(session);
-  sleep(2 * kTimeout + 1);
+  usleep(2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND);
 }
 
 TEST_F(HeartBeatMonitorTest, KeptAlive) {
@@ -154,13 +166,13 @@ TEST_F(HeartBeatMonitorTest, KeptAlive) {
 
   const uint32_t session = conn->AddNewSession();
   conn->StartHeartBeat(session);
-  sleep(kTimeout - 1);
+  usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND);
   conn->KeepAlive(session);
-  sleep(kTimeout - 1);
+  usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND);
   conn->KeepAlive(session);
-  sleep(kTimeout - 1);
+  usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND);
   conn->KeepAlive(session);
-  sleep(kTimeout - 1);
+  usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND);
 }
 
 TEST_F(HeartBeatMonitorTest, NotKeptAlive) {
@@ -172,13 +184,13 @@ TEST_F(HeartBeatMonitorTest, NotKeptAlive) {
   EXPECT_CALL(connection_handler_mock, CloseConnection(_));
 
   conn->StartHeartBeat(session);
-  sleep(kTimeout - 1);
+  usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND);
   conn->KeepAlive(session);
-  sleep(kTimeout - 1);
+  usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND);
   conn->KeepAlive(session);
-  sleep(kTimeout - 1);
+  usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND);
   conn->KeepAlive(session);
-  sleep(2 * kTimeout + 1);
+  usleep(2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND);
 }
 
 TEST_F(HeartBeatMonitorTest, TwoSessionsElapsed) {
@@ -195,7 +207,7 @@ TEST_F(HeartBeatMonitorTest, TwoSessionsElapsed) {
 
   conn->StartHeartBeat(kSession1);
   conn->StartHeartBeat(kSession2);
-  sleep(2 * kTimeout + 1);
+  usleep(2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND);
 }
 
 TEST_F(HeartBeatMonitorTest, IncreaseHeartBeatTimeout) {
@@ -206,25 +218,26 @@ TEST_F(HeartBeatMonitorTest, IncreaseHeartBeatTimeout) {
   EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, _)).Times(0);
 
 
-  const int32_t kNewTimeout = kTimeout + 1;
+  const uint32_t kNewTimeout = kTimeout + MICROSECONDS_IN_MILLISECONDS;
   conn->StartHeartBeat(kSession);
   conn->SetHeartBeatTimeout(kNewTimeout, kSession);
   // new timeout greater by old timeout so mock object shouldn't be invoked
-  sleep(kTimeout);
+  usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS);
 }
 
 TEST_F(HeartBeatMonitorTest, DecreaseHeartBeatTimeout) {
   const uint32_t kSession = conn->AddNewSession();
-  EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, kSession));
+
   EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession,_))
   .WillOnce(RemoveSession(conn, kSession));
   EXPECT_CALL(connection_handler_mock, CloseConnection(_));
+  EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, kSession));
 
-  const int32_t kNewTimeout = kTimeout - 1;
+  const uint32_t kNewTimeout = kTimeout - MICROSECONDS_IN_MILLISECONDS;
   conn->StartHeartBeat(kSession);
   conn->SetHeartBeatTimeout(kNewTimeout, kSession);
   // new timeout less than old timeout so mock object should be invoked
-  sleep(kTimeout*2);
+  usleep(kTimeout * 2 * MICROSECONDS_IN_MILLISECONDS);
 }
 
 } // namespace connection_handler_test
diff --git a/src/components/connection_handler/test/include/connection_handler_observer_mock.h b/src/components/connection_handler/test/include/connection_handler_observer_mock.h
new file mode 100644
index 0000000000..9a74375262
--- /dev/null
+++ b/src/components/connection_handler/test/include/connection_handler_observer_mock.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2015, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SRC_COMPONENTS_CONNECTION_HANDLER_TEST_INCLUDE_CONNECTION_HANDLER_OBSERVER_MOCK_H_
+#define SRC_COMPONENTS_CONNECTION_HANDLER_TEST_INCLUDE_CONNECTION_HANDLER_OBSERVER_MOCK_H_
+
+#include <gmock/gmock.h>
+#include <string>
+#include "connection_handler/connection_handler_observer.h"
+
+namespace test {
+namespace components {
+namespace connection_handler_test {
+
+/*
+ * MOCK implementation of ::connection_handler::ConnectionHandlerObserver interface
+ */
+class ConnectionHandlerObserverMock : public ::connection_handler::ConnectionHandlerObserver {
+ public:
+  MOCK_METHOD1(OnDeviceListUpdated,
+      void(const connection_handler::DeviceMap &device_list));
+  MOCK_METHOD0(OnFindNewApplicationsRequest,void());
+  MOCK_METHOD1(RemoveDevice,
+      void(const connection_handler::DeviceHandle &device_handle));
+  MOCK_METHOD3(OnServiceStartedCallback,
+      bool(const connection_handler::DeviceHandle &device_handle,
+           const int32_t &session_key,
+           const protocol_handler::ServiceType &type));
+  MOCK_METHOD3(OnServiceEndedCallback,
+      void(const int32_t &session_key,
+           const protocol_handler::ServiceType &type,
+           const connection_handler::CloseSessionReason& close_reason));
+  MOCK_CONST_METHOD1(GetHandshakeContext,
+                     security_manager::SSLContext::HandshakeContext(
+                       uint32_t key));
+
+};
+} // namespace connection_handler_test
+} // namespace components
+} // namespace test
+#endif  //SRC_COMPONENTS_CONNECTION_HANDLER_TEST_INCLUDE_CONNECTION_HANDLER_OBSERVER_MOCK_H_
diff --git a/src/components/connection_handler/test/smartDeviceLink.ini b/src/components/connection_handler/test/smartDeviceLink.ini
index 0e79edf3ac..109003eb5f 100644
--- a/src/components/connection_handler/test/smartDeviceLink.ini
+++ b/src/components/connection_handler/test/smartDeviceLink.ini
@@ -58,7 +58,7 @@ AppTimeScaleMaxRequests = 1000
 AppRequestsTimeScale = 10
 ; Allowed pending requests amount. If value is 0 check will be skipped
 PendingRequestsAmount = 5000
-HeartBeatTimeout = 7
+HeartBeatTimeout = 7000
 SupportedDiagModes = 0x01, 0x02, 0x03, 0x05, 0x06, 0x07, 0x09, 0x0A, 0x18, 0x19, 0x22, 0x3E
 SystemFilesPath = /tmp/fs/mp/images/ivsu_cache
 UseLastState = true