Merge pull request #254 in NAR/sdl-core from feat/connection_handler_unit_tests to feature/Ford-WiFi

* commit '226ab65d123547f6b17559f10fa0adc54505d26f':
  UT: Add tests for ConnectionHandlerImpl
  minor fix
  start unit tests for connection_handler_impl class
  Minor fix in connection.cc
  Add more unit tests for Connection class
  connection unit test
  fix build error

4 files changed, 410 insertions, 14 deletions

diff --git a/src/components/connection_handler/src/connection.cc b/src/components/connection_handler/src/connection.cc
index dd12c5f698..0729e00a64 100644
--- a/src/components/connection_handler/src/connection.cc
+++ b/src/components/connection_handler/src/connection.cc
@@ -192,7 +192,7 @@ uint32_t Connection::RemoveSession(uint8_t session_id) {
 DEPRECATED bool Connection::AddNewService(uint8_t session_id,
                                protocol_handler::ServiceType service_type,
                                const bool request_protection) {
-  return AddNewService(session_id, service_type, 0);
+  return AddNewService(session_id, service_type, request_protection, 0);
 }
 
 bool Connection::AddNewService(uint8_t session_id,
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 7d82605265..cc799078f1 100644
--- a/src/components/connection_handler/test/connection_handler_impl_test.cc
+++ b/src/components/connection_handler/test/connection_handler_impl_test.cc
@@ -198,10 +198,12 @@ class ConnectionHandlerTest : public ::testing::Test {
   }
 
   // Check Service Wrapper
-  void CheckServiceExists(const int connectionId,
-                          const int session_id,
-                          const ::protocol_handler::ServiceType serviceId,
-                          const bool exists) {
+  void CheckServiceExists(
+      const int connectionId,
+      const int session_id,
+      const ::protocol_handler::ServiceType serviceId,
+      const ::transport_manager::ConnectionUID serviceConnectionId,
+      const bool exists) {
     // Check all trees to find Service and check own protected value
     const ConnectionList& connection_list =
         connection_handler_->getConnectionList();
@@ -221,6 +223,7 @@ class ConnectionHandlerTest : public ::testing::Test {
         std::find(service_list.begin(), service_list.end(), serviceId);
     if (exists) {
       ASSERT_NE(serv_it, service_list.end());
+      ASSERT_EQ(serv_it->connection_id, serviceConnectionId);
     } else {
       ASSERT_EQ(serv_it, service_list.end());
     }
@@ -306,6 +309,31 @@ class ConnectionHandlerTest : public ::testing::Test {
         connection->ProtocolVersion(session_id, check_protocol_version));
     EXPECT_EQ(check_protocol_version, protocol_version);
   }
+  void AddSecondaryTestService(ServiceType service_type) {
+    EXPECT_NE(0u, out_context_.new_session_id_);
+    EXPECT_EQ(SessionHash(uid_, out_context_.new_session_id_),
+              out_context_.hash_id_);
+    CheckSessionExists(uid_, out_context_.new_session_id_);
+
+    // Set protocol version to 5
+    ChangeProtocol(uid_,
+                   out_context_.new_session_id_,
+                   protocol_handler::PROTOCOL_VERSION_5);
+
+    connection_handler_test::MockConnectionHandlerObserver
+        temp_connection_handler_observer;
+    connection_handler_->set_connection_handler_observer(
+        &temp_connection_handler_observer);
+    EXPECT_CALL(temp_connection_handler_observer,
+                OnServiceStartedCallback(_, _, service_type, _)).Times(1);
+
+    connection_handler_->OnSessionStartedCallback(2u,
+                                                  out_context_.new_session_id_,
+                                                  service_type,
+                                                  PROTECTION_OFF,
+                                                  static_cast<BsonObject*>(0));
+    connection_handler_->set_connection_handler_observer(NULL);
+  }
 
   ConnectionHandlerImpl* connection_handler_;
   testing::NiceMock<transport_manager_test::MockTransportManager>
@@ -1112,7 +1140,7 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) {
                                                 PROTECTION_OFF,
                                                 static_cast<BsonObject*>(NULL));
   EXPECT_NE(0u, audio_context.new_session_id_);
-  CheckServiceExists(uid_, audio_context.new_session_id_, kAudio, true);
+  CheckServiceExists(uid_, audio_context.new_session_id_, kAudio, uid_, true);
   EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, audio_context.hash_id_);
 
   // Start Audio service
@@ -1122,7 +1150,8 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) {
                                                 PROTECTION_OFF,
                                                 static_cast<BsonObject*>(NULL));
   EXPECT_NE(0u, video_context.new_session_id_);
-  CheckServiceExists(uid_, video_context.new_session_id_, kMobileNav, true);
+  CheckServiceExists(
+      uid_, video_context.new_session_id_, kMobileNav, uid_, true);
   EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, video_context.hash_id_);
 
   connection_handler_->set_protocol_handler(NULL);
@@ -1150,7 +1179,8 @@ TEST_F(ConnectionHandlerTest, StartService_withServices_withParams) {
                                                 PROTECTION_OFF,
                                                 dummy_param);
   EXPECT_EQ(out_context_.new_session_id_, video_context.new_session_id_);
-  CheckServiceExists(uid_, out_context_.new_session_id_, kMobileNav, true);
+  CheckServiceExists(
+      uid_, out_context_.new_session_id_, kMobileNav, uid_, true);
   EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, video_context.hash_id_);
 
   connection_handler_->set_protocol_handler(NULL);
@@ -1174,7 +1204,7 @@ TEST_F(ConnectionHandlerTest, ServiceStop_UnExistService) {
       connection_handler_->OnSessionEndedCallback(
           uid_, out_context_.new_session_id_, &dummy_hash, kAudio);
   EXPECT_EQ(0u, end_session_result);
-  CheckServiceExists(uid_, out_context_.new_session_id_, kAudio, false);
+  CheckServiceExists(uid_, out_context_.new_session_id_, kAudio, uid_, false);
 }
 
 TEST_F(ConnectionHandlerTest, ServiceStop) {
@@ -1204,7 +1234,7 @@ TEST_F(ConnectionHandlerTest, ServiceStop) {
         connection_handler_->OnSessionEndedCallback(
             uid_, out_context_.new_session_id_, &some_hash_id, kAudio);
     EXPECT_EQ(connection_key_, end_session_result);
-    CheckServiceExists(uid_, out_context_.new_session_id_, kAudio, false);
+    CheckServiceExists(uid_, out_context_.new_session_id_, kAudio, uid_, false);
   }
 }
 
@@ -2024,6 +2054,199 @@ TEST_F(ConnectionHandlerTest, OnDeviceConnectionSwitching) {
   connection_handler_->OnDeviceSwitchingStart(mac_address_, second_mac_address);
 }
 
+TEST_F(ConnectionHandlerTest, StartStopSecondarySession) {
+  // Add virtual device and connection
+  AddTestDeviceConnection();
+  // Start new session with RPC service
+  AddTestSession();
+
+  connection_handler_test::MockConnectionHandlerObserver
+      mock_connection_handler_observer;
+  connection_handler_->set_connection_handler_observer(
+      &mock_connection_handler_observer);
+
+  // Start a session on a secondary transport
+  const transport_manager::DeviceInfo secondary_device_info(
+      device_handle_, mac_address_, device_name_, std::string("WIFI"));
+  const transport_manager::ConnectionUID secondary_uid = 2u;
+  // Add Device and connection
+  ON_CALL(mock_connection_handler_settings, heart_beat_timeout())
+      .WillByDefault(Return(1000u));
+  connection_handler_->addDeviceConnection(secondary_device_info,
+                                           secondary_uid);
+
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnSecondaryTransportStartedCallback(device_handle_, _)).Times(1);
+
+  connection_handler_->OnSecondaryTransportStarted(
+      uid_, secondary_uid, out_context_.new_session_id_);
+
+  SessionTransports st =
+      connection_handler_->GetSessionTransports(out_context_.new_session_id_);
+  EXPECT_EQ(st.primary_transport, uid_);
+  EXPECT_EQ(st.secondary_transport, secondary_uid);
+
+  AddSecondaryTestService(kAudio);
+  AddSecondaryTestService(kMobileNav);
+
+  CheckServiceExists(
+      uid_, out_context_.new_session_id_, kAudio, secondary_uid, true);
+  CheckServiceExists(
+      uid_, out_context_.new_session_id_, kMobileNav, secondary_uid, true);
+
+  connection_handler_->set_connection_handler_observer(
+      &mock_connection_handler_observer);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnSecondaryTransportEndedCallback(_)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(_, kAudio, _)).Times(1);
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnServiceEndedCallback(_, kMobileNav, _)).Times(1);
+
+  connection_handler_->OnSecondaryTransportEnded(uid_, secondary_uid);
+
+  st = connection_handler_->GetSessionTransports(out_context_.new_session_id_);
+  EXPECT_EQ(st.primary_transport, uid_);
+  EXPECT_EQ(st.secondary_transport, 0u);
+
+  CheckServiceExists(
+      uid_, out_context_.new_session_id_, kAudio, secondary_uid, false);
+  CheckServiceExists(
+      uid_, out_context_.new_session_id_, kMobileNav, secondary_uid, false);
+}
+
+TEST_F(ConnectionHandlerTest, StopSecondarySession_NoService) {
+  AddTestDeviceConnection();
+  AddTestSession();
+
+  connection_handler_test::MockConnectionHandlerObserver
+      mock_connection_handler_observer;
+  connection_handler_->set_connection_handler_observer(
+      &mock_connection_handler_observer);
+
+  const transport_manager::DeviceInfo secondary_device_info(
+      device_handle_, mac_address_, device_name_, std::string("WIFI"));
+  const transport_manager::ConnectionUID secondary_uid = 123u;
+  ON_CALL(mock_connection_handler_settings, heart_beat_timeout())
+      .WillByDefault(Return(1000u));
+  connection_handler_->addDeviceConnection(secondary_device_info,
+                                           secondary_uid);
+
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnSecondaryTransportStartedCallback(device_handle_, _)).Times(1);
+  connection_handler_->OnSecondaryTransportStarted(
+      uid_, secondary_uid, out_context_.new_session_id_);
+
+  // check if OnSecondaryTransportEndedCallback is triggered with correct
+  // session ID even if we don't have any services
+  EXPECT_CALL(mock_connection_handler_observer,
+              OnSecondaryTransportEndedCallback(_));
+
+  connection_handler_->OnSecondaryTransportEnded(uid_, secondary_uid);
+
+  SessionTransports st =
+      connection_handler_->GetSessionTransports(out_context_.new_session_id_);
+  EXPECT_EQ(st.primary_transport, uid_);
+  EXPECT_EQ(st.secondary_transport, 0u);
+}
+
+TEST_F(ConnectionHandlerTest, ConnectionType_valid) {
+  AddTestDeviceConnection();
+  AddTestSession();
+
+  std::string ret = connection_handler_->connection_type(uid_);
+  EXPECT_EQ(connection_type_, ret);
+}
+
+TEST_F(ConnectionHandlerTest, ConnectionType_invalid) {
+  AddTestDeviceConnection();
+
+  transport_manager::ConnectionUID invalid_uid = 12345;
+  ASSERT_TRUE(invalid_uid != uid_);
+  std::string ret = connection_handler_->connection_type(invalid_uid);
+  EXPECT_EQ(std::string(), ret);
+}
+
+TEST_F(ConnectionHandlerTest, SetSecondaryTransportID_UpdateSuccess) {
+  uint8_t session_id = 123;
+  transport_manager::ConnectionUID primary_uid = 100;
+  transport_manager::ConnectionUID secondary_uid = 0;
+  {
+    NonConstDataAccessor<SessionConnectionMap> accessor =
+        connection_handler_->session_connection_map();
+    SessionConnectionMap& session_conneciton_map = accessor.GetData();
+    // secondary transport's ID is 0
+    SessionTransports st = {primary_uid, secondary_uid};
+    session_conneciton_map[session_id] = st;
+  }
+
+  secondary_uid = 200;
+  SessionTransports st =
+      connection_handler_->SetSecondaryTransportID(session_id, secondary_uid);
+  EXPECT_EQ(primary_uid, st.primary_transport);
+  EXPECT_EQ(secondary_uid, st.secondary_transport);
+}
+
+TEST_F(ConnectionHandlerTest, SetSecondaryTransportID_UpdateFailure) {
+  uint8_t session_id = 123;
+  transport_manager::ConnectionUID primary_uid = 100;
+  transport_manager::ConnectionUID secondary_uid = 300;
+  {
+    NonConstDataAccessor<SessionConnectionMap> accessor =
+        connection_handler_->session_connection_map();
+    SessionConnectionMap& session_conneciton_map = accessor.GetData();
+    // secondary transport's ID is already assigned
+    SessionTransports st = {primary_uid, secondary_uid};
+    session_conneciton_map[session_id] = st;
+  }
+
+  SessionTransports st =
+      connection_handler_->SetSecondaryTransportID(session_id, 500);
+  EXPECT_EQ(primary_uid, st.primary_transport);
+  // secondary transport's ID is NOT updated
+  EXPECT_EQ(secondary_uid, st.secondary_transport);
+}
+
+TEST_F(ConnectionHandlerTest, SetSecondaryTransportID_OverwirteSecondaryUID) {
+  uint8_t session_id = 123;
+  transport_manager::ConnectionUID primary_uid = 200;
+  transport_manager::ConnectionUID secondary_uid = 500;
+  {
+    NonConstDataAccessor<SessionConnectionMap> accessor =
+        connection_handler_->session_connection_map();
+    SessionConnectionMap& session_conneciton_map = accessor.GetData();
+    SessionTransports st = {primary_uid, secondary_uid};
+    session_conneciton_map[session_id] = st;
+  }
+
+  secondary_uid = 0xFFFFFFFF;
+  SessionTransports st =
+      connection_handler_->SetSecondaryTransportID(session_id, secondary_uid);
+  EXPECT_EQ(primary_uid, st.primary_transport);
+  // secondary transport's ID is updated
+  EXPECT_EQ(secondary_uid, st.secondary_transport);
+}
+
+TEST_F(ConnectionHandlerTest, SetSecondaryTransportID_Failure) {
+  uint8_t session_id = 123;
+  transport_manager::ConnectionUID primary_uid = 100;
+  transport_manager::ConnectionUID secondary_uid = 0;
+  {
+    NonConstDataAccessor<SessionConnectionMap> accessor =
+        connection_handler_->session_connection_map();
+    SessionConnectionMap& session_conneciton_map = accessor.GetData();
+    SessionTransports st = {primary_uid, secondary_uid};
+    session_conneciton_map[session_id] = st;
+  }
+
+  uint8_t invalid_session_id = 10;
+  secondary_uid = 300;
+  SessionTransports st = connection_handler_->SetSecondaryTransportID(
+      invalid_session_id, secondary_uid);
+  EXPECT_EQ(0u, st.primary_transport);
+  EXPECT_EQ(0u, st.secondary_transport);
+}
+
 }  // namespace connection_handler_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 593c05fb33..02c7a7c8d2 100644
--- a/src/components/connection_handler/test/connection_test.cc
+++ b/src/components/connection_handler/test/connection_test.cc
@@ -36,6 +36,7 @@
 
 #include "protocol/common.h"
 #include "connection_handler/connection.h"
+#include "connection_handler/mock_connection_handler.h"
 #include "connection_handler/connection_handler_impl.h"
 #include "protocol/service_type.h"
 #include "connection_handler/mock_connection_handler_settings.h"
@@ -56,6 +57,8 @@ namespace connection_handler_test {
 using namespace ::connection_handler;
 using namespace ::protocol_handler;
 
+using ::testing::Return;
+
 class ConnectionTest : public ::testing::Test {
  protected:
   void SetUp() OVERRIDE {
@@ -88,6 +91,7 @@ class ConnectionTest : public ::testing::Test {
         std::find(serviceList.begin(), serviceList.end(), kRpc);
     const bool found_result = (it != serviceList.end());
     EXPECT_TRUE(found_result);
+    EXPECT_EQ(connection_->primary_connection_handle(), 0);
   }
   void AddNewService(const ServiceType service_type,
                      const bool protection,
@@ -110,12 +114,35 @@ class ConnectionTest : public ::testing::Test {
         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
     if (found_result) {
       const Service& service = *it;
+      transport_manager::ConnectionUID expected_connection_handle =
+          kDefaultConnectionHandle;
+      EXPECT_EQ(service.connection_id, expected_connection_handle);
+#ifdef ENABLE_SECURITY
       EXPECT_EQ(service.is_protected_, protection);
-    }
 #endif  // ENABLE_SECURITY
+    }
+  }
+  void AddNewSecondaryService(const ServiceType service_type) {
+    const bool result = connection_->AddNewService(
+        session_id, service_type, false, kSecondaryConnectionHandle);
+    EXPECT_EQ(result, true);
+
+    const SessionMap session_map = connection_->session_map();
+    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 bool found_result = it != newServiceList.end();
+    EXPECT_TRUE(found_result);
+    if (found_result) {
+      const Service& service = *it;
+      transport_manager::ConnectionUID expected_secondary_connection_handle =
+          kSecondaryConnectionHandle;
+      EXPECT_EQ(service.connection_id, expected_secondary_connection_handle);
+    }
   }
 
   void RemoveService(const ServiceType service_type,
@@ -142,6 +169,7 @@ class ConnectionTest : public ::testing::Test {
   ConnectionHandlerImpl* connection_handler_;
   uint32_t session_id;
   static const transport_manager::ConnectionUID kDefaultConnectionHandle = 1;
+  static const transport_manager::ConnectionUID kSecondaryConnectionHandle = 2;
 };
 
 TEST_F(ConnectionTest, Session_TryGetProtocolVersionWithoutSession) {
@@ -414,6 +442,151 @@ TEST_F(ConnectionTest, RemoveSession) {
   EXPECT_EQ(0u, connection_->RemoveSession(session_id));
 }
 
+TEST_F(ConnectionTest, AddNewSession_VerifySessionConnectionMapAdded) {
+  MockConnectionHandler mock_connection_handler;
+
+  ConnectionHandle connection_handle = 123;
+  DeviceHandle device_handle = 0u;
+  uint32_t heart_beat = 10000u;
+  Connection* connection = new Connection(
+      connection_handle, device_handle, &mock_connection_handler, heart_beat);
+
+  SessionConnectionMap session_connection_map;
+  sync_primitives::Lock session_connection_map_lock;
+  EXPECT_CALL(mock_connection_handler, session_connection_map())
+      .WillRepeatedly(Return(NonConstDataAccessor<SessionConnectionMap>(
+          session_connection_map, session_connection_map_lock)));
+
+  transport_manager::ConnectionUID connection_handle_uid = 1;
+  uint32_t sid = connection->AddNewSession(connection_handle_uid);
+  EXPECT_NE(0u, sid);
+
+  // verify that SessionConnectionMap is updated
+  SessionConnectionMap::iterator it = session_connection_map.find(sid);
+  EXPECT_TRUE(session_connection_map.end() != it);
+
+  SessionTransports st = it->second;
+  EXPECT_EQ(connection_handle_uid, st.primary_transport);
+  EXPECT_EQ(0u, st.secondary_transport);
+
+  delete connection;
+}
+
+TEST_F(ConnectionTest, RemoveSession_VerifySessionConnectionMapRemoved) {
+  MockConnectionHandler mock_connection_handler;
+
+  ConnectionHandle connection_handle = 123;
+  DeviceHandle device_handle = 0u;
+  uint32_t heart_beat = 10000u;
+  Connection* connection = new Connection(
+      connection_handle, device_handle, &mock_connection_handler, heart_beat);
+
+  SessionConnectionMap session_connection_map;
+  sync_primitives::Lock session_connection_map_lock;
+  // input some dummy data
+  SessionTransports st1 = {1234, 0};
+  SessionTransports st2 = {2345, 0};
+  session_connection_map[0x12] = st1;
+  session_connection_map[0x23] = st2;
+
+  EXPECT_CALL(mock_connection_handler, session_connection_map())
+      .WillRepeatedly(Return(NonConstDataAccessor<SessionConnectionMap>(
+          session_connection_map, session_connection_map_lock)));
+
+  transport_manager::ConnectionUID connection_handle_uid = 1;
+  uint32_t sid = connection->AddNewSession(connection_handle_uid);
+
+  uint32_t ret = connection->RemoveSession(sid);
+  EXPECT_EQ(sid, ret);
+
+  // verify that SessionConnectionMap is updated
+  SessionConnectionMap::iterator it = session_connection_map.find(sid);
+  EXPECT_TRUE(session_connection_map.end() == it);
+
+  delete connection;
+}
+
+TEST_F(ConnectionTest, SecondarySessionTest) {
+  StartSession();
+  AddNewService(
+    kRpc, PROTECTION_OFF, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
+
+  const ConnectionHandle connectionHandle = 0;
+  const DeviceHandle device_handle = 0u;
+  const uint32_t heart_beat = 0u;
+  Connection* secondary_connection = new Connection(
+        connectionHandle, device_handle, connection_handler_, heart_beat);
+
+  secondary_connection->SetPrimaryConnectionHandle(kDefaultConnectionHandle);
+  connection_handler::ConnectionHandle expected_primary_connection_handle =
+      kDefaultConnectionHandle;
+  EXPECT_EQ(
+      secondary_connection->primary_connection_handle(),
+      expected_primary_connection_handle);
+
+  AddNewSecondaryService(kAudio);
+  AddNewSecondaryService(kMobileNav);
+
+  delete secondary_connection;
+}
+
+TEST_F(ConnectionTest, RemoveSecondaryServices_SUCCESS) {
+  StartSession();
+
+  ServiceType services[2] = {kMobileNav, kAudio};
+  AddNewSecondaryService(services[0]);
+  AddNewSecondaryService(services[1]);
+  size_t services_count = sizeof(services) / sizeof(services[0]);
+
+  std::list<ServiceType> removed_services;
+  uint8_t ret_session_id = connection_->RemoveSecondaryServices(
+      kSecondaryConnectionHandle, removed_services);
+
+  // check return value
+  EXPECT_EQ(session_id, ret_session_id);
+  // check returned list
+  EXPECT_EQ(services_count, removed_services.size());
+  std::list<protocol_handler::ServiceType>::iterator it;
+  it = std::find(removed_services.begin(), removed_services.end(), services[0]);
+  EXPECT_TRUE(it != removed_services.end());
+  it = std::find(removed_services.begin(), removed_services.end(), services[1]);
+  EXPECT_TRUE(it != removed_services.end());
+}
+
+TEST_F(ConnectionTest, RemoveSecondaryServices_NoService) {
+  StartSession();
+  /* do not call AddNewSecondaryService() */
+
+  std::list<ServiceType> removed_services;
+  uint8_t ret_session_id = connection_->RemoveSecondaryServices(
+      kSecondaryConnectionHandle, removed_services);
+
+  // check return value
+  EXPECT_EQ(0, ret_session_id);
+  // check returned list
+  EXPECT_EQ(0u, removed_services.size());
+}
+
+TEST_F(ConnectionTest, RemoveSecondaryServices_InvalidConnectionHandle) {
+  StartSession();
+
+  ServiceType services[2] = {kMobileNav, kAudio};
+  AddNewSecondaryService(services[0]);
+  AddNewSecondaryService(services[1]);
+
+  transport_manager::ConnectionUID invalid_connection_handle = 123;
+  ASSERT_TRUE(kSecondaryConnectionHandle != invalid_connection_handle);
+
+  std::list<ServiceType> removed_services;
+  uint8_t ret_session_id = connection_->RemoveSecondaryServices(
+      invalid_connection_handle, removed_services);
+
+  // check return value
+  EXPECT_EQ(0, ret_session_id);
+  // check returned list
+  EXPECT_EQ(0u, removed_services.size());
+}
+
 #ifdef ENABLE_SECURITY
 
 TEST_F(ConnectionTest, SetSSLContextWithoutSession) {
diff --git a/src/components/protocol_handler/test/protocol_handler_tm_test.cc b/src/components/protocol_handler/test/protocol_handler_tm_test.cc
index 4369ccfa8d..ad517ded5d 100644
--- a/src/components/protocol_handler/test/protocol_handler_tm_test.cc
+++ b/src/components/protocol_handler/test/protocol_handler_tm_test.cc
@@ -1861,7 +1861,7 @@ TEST_F(ProtocolHandlerImplTest,
   std::vector<int32_t> expected_video_service_transports;
   expected_video_service_transports.push_back(1);
 
-  connection_handler::SessionTransports dummy_st;
+  connection_handler::SessionTransports dummy_st = {0, 0};
   EXPECT_CALL(connection_handler_mock, SetSecondaryTransportID(_, 0xFFFFFFFF))
       .WillOnce(Return(dummy_st));
 
@@ -2001,7 +2001,7 @@ TEST_F(ProtocolHandlerImplTest,
       .WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(E_SUCCESS)));
   times++;
 
-  connection_handler::SessionTransports dummy_st;
+  connection_handler::SessionTransports dummy_st = {0, 0};
   EXPECT_CALL(connection_handler_mock, SetSecondaryTransportID(_, 0xFFFFFFFF))
       .WillOnce(Return(dummy_st));