Moved, Enabled and partially refactored Unit tests

22 files changed, 3190 insertions, 456 deletions

diff --git a/src/components/transport_manager/test/CMakeLists.txt b/src/components/transport_manager/test/CMakeLists.txt
index 226bfa1885..c38804e86c 100644
--- a/src/components/transport_manager/test/CMakeLists.txt
+++ b/src/components/transport_manager/test/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2014, Ford Motor Company
+# Copyright (c) 2015, Ford Motor Company
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -29,6 +29,7 @@
 # POSSIBILITY OF SUCH DAMAGE.
 
 if(BUILD_TESTS)
+set(TM_TEST_DIR ${COMPONENTS_DIR}/transport_manager/test)
 
 include_directories(
   ${LOG4CXX_INCLUDE_DIRECTORY}
@@ -43,14 +44,14 @@ include_directories(
 )
 
 set(LIBRARIES
-    gmock 
-    ConfigProfile 
-    transport_manager
-    ApplicationManagerTest 
-    Utils    
-    ConfigProfile
-    Resumption
-    jsoncpp     
+  gmock
+  ConfigProfile
+  transport_manager
+  Utils
+  ConfigProfile
+  ProtocolLibrary
+  Resumption
+  jsoncpp
 )
 
 if (BUILD_USB_SUPPORT)
@@ -65,20 +66,17 @@ if (BUILD_AVAHI_SUPPORT)
   list(APPEND LIBRARIES avahi-client avahi-common)
 endif()
 
-
 set(SOURCES
-  ${COMPONENTS_DIR}/transport_manager/test/mock_application.cc
-  ${COMPONENTS_DIR}/transport_manager/test/transport_manager_test.cc
-  ${COMPONENTS_DIR}/transport_manager/test/mock_connection_factory.cc
-  ${COMPONENTS_DIR}/transport_manager/test/mock_connection.cc
-  ${COMPONENTS_DIR}/transport_manager/test/mock_device.cc
-  ${COMPONENTS_DIR}/transport_manager/test/mock_device_scanner.cc
-  ${COMPONENTS_DIR}/transport_manager/test/raw_message_matcher.cc
-  ${COMPONENTS_DIR}/transport_manager/test/dnssd_service_browser_test.cc
-  ${COMPONENTS_DIR}/transport_manager/test/tcp_transport_adapter_test.cc
-  ${COMPONENTS_DIR}/transport_manager/test/mock_transport_adapter.cc
-)          
+  ${TM_TEST_DIR}/transport_manager_default_test.cc
+  #${TM_TEST_DIR}/transport_manager_impl_test.cc
+  #${TM_TEST_DIR}/dnssd_service_browser_test.cc
+  ${TM_TEST_DIR}/transport_adapter_test.cc
+  #${TM_TEST_DIR}/transport_adapter_listener_test.cc
+  ${TM_TEST_DIR}/tcp_transport_adapter_test.cc
+  ${TM_TEST_DIR}/tcp_device_test.cc
+  #${TM_TEST_DIR}/tcp_client_listener_test.cc
+)
 
 create_test("transport_manager_test" "${SOURCES}" "${LIBRARIES}")
-
+file(COPY smartDeviceLink_test.ini DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
 endif()
diff --git a/src/components/transport_manager/test/dnssd_service_browser_test.cc b/src/components/transport_manager/test/dnssd_service_browser_test.cc
index b496be58e2..6eb2ad45f6 100644
--- a/src/components/transport_manager/test/dnssd_service_browser_test.cc
+++ b/src/components/transport_manager/test/dnssd_service_browser_test.cc
@@ -32,90 +32,115 @@
 
 #include "gmock/gmock.h"
 
-#include <netinet/in.h>
-#include <sys/types.h>
-#include <ifaddrs.h>
-
 #include "transport_manager/transport_adapter/transport_adapter_controller.h"
 #include "transport_manager/tcp/dnssd_service_browser.h"
-#include "transport_manager/tcp/tcp_device.h"
 
 namespace transport_manager {
 namespace transport_adapter {
 
-class MockTransportAdapterController: public TransportAdapterController {
-public:
- MOCK_METHOD1(AddDevice,DeviceSptr(DeviceSptr device));
- MOCK_METHOD1(SearchDeviceDone, void(const DeviceVector& devices));
- MOCK_METHOD1(SearchDeviceFailed, void(const SearchDeviceError& error));
- MOCK_CONST_METHOD1(FindDevice, DeviceSptr(const DeviceUID& device_handle));
- MOCK_METHOD3(ConnectionCreated, void(ConnectionSPtr connection, const DeviceUID& device_handle, const ApplicationHandle& app_handle));
- MOCK_METHOD2(ConnectDone, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle));
- MOCK_METHOD3(ConnectFailed, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const ConnectError& error));
- MOCK_METHOD2(ConnectionFinished, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle));
- MOCK_METHOD3(ConnectionAborted,void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const CommunicationError& error));
- MOCK_METHOD2(DisconnectDone, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle));
- MOCK_METHOD3(DataReceiveDone, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const ::protocol_handler::RawMessagePtr message));
- MOCK_METHOD3(DataReceiveFailed, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const DataReceiveError& error));
- MOCK_METHOD3(DataSendDone, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const ::protocol_handler::RawMessagePtr message));
- MOCK_METHOD4(DataSendFailed, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const ::protocol_handler::RawMessagePtr message, const DataSendError& error));
- MOCK_METHOD0(FindNewApplicationsRequest, void());
- MOCK_METHOD1(ApplicationListUpdated, void(const DeviceUID& device_handle));
- MOCK_METHOD2(DeviceDisconnected, void (const DeviceUID& device_handle,const DisconnectDeviceError& error));
+class MockTransportAdapterController : public TransportAdapterController {
+ public:
+  MOCK_METHOD1(AddDevice, DeviceSptr(DeviceSptr device));
+  MOCK_METHOD1(SearchDeviceDone, void(const DeviceVector& devices));
+  MOCK_METHOD1(SearchDeviceFailed, void(const SearchDeviceError& error));
+  MOCK_CONST_METHOD1(FindDevice, DeviceSptr(const DeviceUID& device_handle));
+  MOCK_METHOD3(ConnectionCreated,
+               void(ConnectionSPtr connection, const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle));
+  MOCK_METHOD2(ConnectDone, void(const DeviceUID& device_handle,
+                                 const ApplicationHandle& app_handle));
+  MOCK_METHOD3(ConnectFailed, void(const DeviceUID& device_handle,
+                                   const ApplicationHandle& app_handle,
+                                   const ConnectError& error));
+  MOCK_METHOD2(ConnectionFinished, void(const DeviceUID& device_handle,
+                                        const ApplicationHandle& app_handle));
+  MOCK_METHOD3(ConnectionAborted, void(const DeviceUID& device_handle,
+                                       const ApplicationHandle& app_handle,
+                                       const CommunicationError& error));
+  MOCK_METHOD2(DisconnectDone, void(const DeviceUID& device_handle,
+                                    const ApplicationHandle& app_handle));
+  MOCK_METHOD3(DataReceiveDone,
+               void(const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    const ::protocol_handler::RawMessagePtr message));
+  MOCK_METHOD3(DataReceiveFailed, void(const DeviceUID& device_handle,
+                                       const ApplicationHandle& app_handle,
+                                       const DataReceiveError& error));
+  MOCK_METHOD3(DataSendDone,
+               void(const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    const ::protocol_handler::RawMessagePtr message));
+  MOCK_METHOD4(DataSendFailed,
+               void(const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    const ::protocol_handler::RawMessagePtr message,
+                    const DataSendError& error));
+  MOCK_METHOD0(FindNewApplicationsRequest, void());
+  MOCK_METHOD0(AckDevices, void());
+  MOCK_METHOD1(ApplicationListUpdated, void(const DeviceUID& device_handle));
+  MOCK_METHOD2(DeviceDisconnected, void(const DeviceUID& device_handle,
+                                        const DisconnectDeviceError& error));
 };
 
-in_addr_t GetIfaceAddress() {
-  in_addr_t result = 0;
-  ifaddrs* if_addrs = NULL;
-//  void * tmpAddrPtr = NULL;
+TEST(DnssdServiceBrowser, DISABLED_Init) {
+  // Arrange
+  MockTransportAdapterController controller;
+  DnssdServiceBrowser dnssd_service_browser(&controller);
+  // Check values after creation. Nothing is initialized
+  EXPECT_TRUE(NULL == dnssd_service_browser.avahi_service_browser());
+  EXPECT_TRUE(NULL == dnssd_service_browser.avahi_threaded_poll());
+  EXPECT_TRUE(NULL == dnssd_service_browser.avahi_client());
+  // Act
+  const TransportAdapter::Error error = dnssd_service_browser.Init();
+  ASSERT_EQ(TransportAdapter::OK, error);
 
-  getifaddrs(&if_addrs);
-  for (ifaddrs* ifa = if_addrs; ifa != NULL; ifa = ifa->ifa_next) {
-    if (ifa->ifa_addr->sa_family == AF_INET) {
-      result = ((struct sockaddr_in *) ifa->ifa_addr)->sin_addr.s_addr;
-      if (result != htonl(INADDR_LOOPBACK)) {
-        break;
-      }
-    }
+  while (!dnssd_service_browser.IsInitialised()) {
+    sleep(0);
   }
-  if (if_addrs)
-    freeifaddrs(if_addrs);
-  return result;
+  ASSERT_TRUE(dnssd_service_browser.IsInitialised());
+  // Check values are initialized and threaded poll started
+  EXPECT_FALSE(NULL == dnssd_service_browser.avahi_service_browser());
+  EXPECT_FALSE(NULL == dnssd_service_browser.avahi_threaded_poll());
+  EXPECT_FALSE(NULL == dnssd_service_browser.avahi_client());
 }
-static in_addr_t iface_address = GetIfaceAddress();
 
-MATCHER_P(HasService, service_port, ""){
-for(DeviceVector::const_iterator it = arg.begin(); it != arg.end(); ++it) {
-  TcpDevice* tcp_device = dynamic_cast<TcpDevice*>(it->get());
-  if(tcp_device && tcp_device->in_addr() == iface_address) {
-    ApplicationList app_list = tcp_device->GetApplicationList();
-    for(ApplicationList::const_iterator it = app_list.begin(); it != app_list.end(); ++it) {
-      if(tcp_device->GetApplicationPort(*it) == service_port) {
-        return true;
-      }
-    }
-  }
-}
-return false;
+TEST(DnssdServiceBrowser, DISABLED_IsInitialized_ExpectFalse) {
+  // Arrange
+  MockTransportAdapterController controller;
+  DnssdServiceBrowser dnssd_service_browser(&controller);
+  // Check
+  EXPECT_FALSE(dnssd_service_browser.IsInitialised());
 }
 
-// TODO{ALeshin} APPLINK-11090 - Infinite loop
-TEST(DnssdServiceBrowser, DISABLED_Basic) {
+TEST(DnssdServiceBrowser, DISABLED_Terminate_ExpectTerminated) {
+  // Arrange
   MockTransportAdapterController controller;
-
   DnssdServiceBrowser dnssd_service_browser(&controller);
-  DeviceScanner& device_scanner = dnssd_service_browser;
-
-  const TransportAdapter::Error error = device_scanner.Init();
+  // Init service browser and client
+  const TransportAdapter::Error error = dnssd_service_browser.Init();
   ASSERT_EQ(TransportAdapter::OK, error);
 
-  while (!device_scanner.IsInitialised()) {
+  while (!dnssd_service_browser.IsInitialised()) {
     sleep(0);
   }
-  ASSERT_TRUE(device_scanner.IsInitialised());
-
-  EXPECT_EQ(TransportAdapter::NOT_SUPPORTED, device_scanner.Scan());  //method Scan now returns only NOT_SUPPORTED value
+  ASSERT_TRUE(dnssd_service_browser.IsInitialised());
+  // Client & browser are initialized and successfully started
+  EXPECT_FALSE(NULL == dnssd_service_browser.avahi_service_browser());
+  EXPECT_FALSE(NULL == dnssd_service_browser.avahi_threaded_poll());
+  EXPECT_FALSE(NULL == dnssd_service_browser.avahi_client());
+  dnssd_service_browser.Terminate();
+  // Checks everything successfully terminated
+  EXPECT_TRUE(NULL == dnssd_service_browser.avahi_service_browser());
+  EXPECT_TRUE(NULL == dnssd_service_browser.avahi_threaded_poll());
+  EXPECT_TRUE(NULL == dnssd_service_browser.avahi_client());
+}
 
+TEST(DnssdServiceBrowser, DISABLED_Scan_ExpectNotSupported) {
+  // Arrange
+  MockTransportAdapterController controller;
+  DnssdServiceBrowser dnssd_service_browser(&controller);
+  // At this moment Scan() can only return NOT SUPPORTED value
+  EXPECT_EQ(TransportAdapter::NOT_SUPPORTED, dnssd_service_browser.Scan());
 }
 
 }  // namespace transport_adapter
diff --git a/src/components/transport_manager/test/include/client_connection_listener_mock.h b/src/components/transport_manager/test/include/client_connection_listener_mock.h
new file mode 100644
index 0000000000..009814f531
--- /dev/null
+++ b/src/components/transport_manager/test/include/client_connection_listener_mock.h
@@ -0,0 +1,62 @@
+/*
+ * 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_TRANSPORT_MANAGER_TEST_INCLUDE_CLIENT_CONNECTION_LISTENER_MOCK_H_
+#define SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_CLIENT_CONNECTION_LISTENER_MOCK_H_
+
+#include "gmock/gmock.h"
+#include "transport_manager/transport_adapter/client_connection_listener.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+class ClientConnectionListenerMock
+    : public ::transport_manager::transport_adapter::ClientConnectionListener {
+ public:
+  MOCK_METHOD0(
+      Init, ::transport_manager::transport_adapter::TransportAdapter::Error());
+  MOCK_METHOD0(Terminate, void());
+  MOCK_CONST_METHOD0(IsInitialised, bool());
+  MOCK_METHOD0(
+      StartListening,
+      ::transport_manager::transport_adapter::TransportAdapter::Error());
+  MOCK_METHOD0(
+      StopListening,
+      ::transport_manager::transport_adapter::TransportAdapter::Error());
+};
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_CLIENT_CONNECTION_LISTENER_MOCK_H_
diff --git a/src/components/transport_manager/test/include/connection_mock.h b/src/components/transport_manager/test/include/connection_mock.h
new file mode 100644
index 0000000000..9e35e9a008
--- /dev/null
+++ b/src/components/transport_manager/test/include/connection_mock.h
@@ -0,0 +1,56 @@
+/*
+ * 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_TRANSPORT_MANAGER_TEST_INCLUDE_CONNECTION_MOCK_H_
+#define SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_CONNECTION_MOCK_H_
+
+#include "gmock/gmock.h"
+#include "transport_manager/transport_adapter/connection.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+using namespace ::transport_manager::transport_adapter;
+
+class ConnectionMock : public Connection {
+ public:
+  MOCK_METHOD1(SendData, TransportAdapter::Error(
+                             ::protocol_handler::RawMessagePtr message));
+  MOCK_METHOD0(Disconnect, TransportAdapter::Error());
+};
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_CONNECTION_MOCK_H_
diff --git a/src/components/transport_manager/test/include/device_mock.h b/src/components/transport_manager/test/include/device_mock.h
new file mode 100644
index 0000000000..53a0ca53fc
--- /dev/null
+++ b/src/components/transport_manager/test/include/device_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_TRANSPORT_MANAGER_TEST_INCLUDE_DEVICE_MOCK_H_
+#define SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_DEVICE_MOCK_H_
+
+#include "gmock/gmock.h"
+#include "transport_manager/transport_adapter/device.h"
+#include "transport_manager/common.h"
+#include "transport_manager/tcp/tcp_device.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+class DeviceMock : public ::transport_manager::transport_adapter::Device {
+ public:
+  DeviceMock(const std::string& name, const std::string& unique_device_id)
+      : Device(name, unique_device_id) {}
+  MOCK_CONST_METHOD1(IsSameAs, bool(const Device* other_device));
+  MOCK_CONST_METHOD0(GetApplicationList, std::vector<int>());
+  MOCK_METHOD0(Stop, void());
+};
+
+class TCPDeviceMock : public ::transport_manager::transport_adapter::TcpDevice {
+ public:
+  TCPDeviceMock(const uint32_t& in_addr_t, const std::string& name)
+      : TcpDevice(in_addr_t, name) {}
+  MOCK_CONST_METHOD1(IsSameAs, bool(const Device* other_device));
+  MOCK_CONST_METHOD0(GetApplicationList, std::vector<int>());
+  MOCK_METHOD0(Stop, void());
+  MOCK_CONST_METHOD1(
+      GetApplicationPort,
+      int(const ::transport_manager::ApplicationHandle app_handle));
+};
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_DEVICE_MOCK_H_
diff --git a/src/components/transport_manager/test/include/device_scanner_mock.h b/src/components/transport_manager/test/include/device_scanner_mock.h
new file mode 100644
index 0000000000..ea98af7f23
--- /dev/null
+++ b/src/components/transport_manager/test/include/device_scanner_mock.h
@@ -0,0 +1,58 @@
+/*
+ * 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_TRANSPORT_MANAGER_TEST_INCLUDE_DEVICE_SCANNER_MOCK_H_
+#define SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_DEVICE_SCANNER_MOCK_H_
+
+#include "gmock/gmock.h"
+#include "transport_manager/transport_adapter/device_scanner.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+class DeviceScannerMock
+    : public ::transport_manager::transport_adapter::DeviceScanner {
+ public:
+  MOCK_METHOD0(
+      Init, ::transport_manager::transport_adapter::TransportAdapter::Error());
+  MOCK_METHOD0(
+      Scan, ::transport_manager::transport_adapter::TransportAdapter::Error());
+  MOCK_METHOD0(Terminate, void());
+  MOCK_CONST_METHOD0(IsInitialised, bool());
+};
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_DEVICE_SCANNER_MOCK_H_
diff --git a/src/components/transport_manager/test/include/mock_transport_adapter_listener.h b/src/components/transport_manager/test/include/mock_transport_adapter_listener.h
index e45564d275..5b68cadaa3 100644
--- a/src/components/transport_manager/test/include/mock_transport_adapter_listener.h
+++ b/src/components/transport_manager/test/include/mock_transport_adapter_listener.h
@@ -53,6 +53,7 @@ class MockTransportAdapterListener : public TransportAdapterListener {
  public:
   MOCK_METHOD1(OnSearchDeviceDone,
       void(const TransportAdapter* transport_adapter));
+  MOCK_METHOD0(AckDevices,void());
   MOCK_METHOD2(OnSearchDeviceFailed,
       void(const TransportAdapter* transport_adapter, const SearchDeviceError& error));
   MOCK_METHOD1(OnFindNewApplicationsRequest,
diff --git a/src/components/transport_manager/test/include/server_connection_factory_mock.h b/src/components/transport_manager/test/include/server_connection_factory_mock.h
new file mode 100644
index 0000000000..cbf922e464
--- /dev/null
+++ b/src/components/transport_manager/test/include/server_connection_factory_mock.h
@@ -0,0 +1,57 @@
+/*
+ * 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_TRANSPORT_MANAGER_TEST_INCLUDE_SERVER_CONNECTION_FACTORY_MOCK_H_
+#define SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_SERVER_CONNECTION_FACTORY_MOCK_H_
+
+#include "gmock/gmock.h"
+#include "transport_manager/transport_adapter/server_connection_factory.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+class ServerConnectionFactoryMock : public ::transport_manager::transport_adapter::ServerConnectionFactory {
+ public:
+  MOCK_METHOD0(Init, ::transport_manager::transport_adapter::TransportAdapter::Error());
+  MOCK_METHOD0(Terminate, void());
+  MOCK_CONST_METHOD0(IsInitialised, bool());
+  MOCK_METHOD2(CreateConnection,
+               ::transport_manager::transport_adapter::TransportAdapter::Error(const std::string&,
+                                       const int& app_handle));
+};
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_SERVER_CONNECTION_FACTORY_MOCK_H_
diff --git a/src/components/transport_manager/test/include/time_metric_observer_mock.h b/src/components/transport_manager/test/include/time_metric_observer_mock.h
new file mode 100644
index 0000000000..5936f8c655
--- /dev/null
+++ b/src/components/transport_manager/test/include/time_metric_observer_mock.h
@@ -0,0 +1,55 @@
+/*
+ * 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_TRANSPORT_MANAGER_TEST_INCLUDE_TIME_METRIC_OBSERVER_MOCK_H_
+#define SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_TIME_METRIC_OBSERVER_MOCK_H_
+
+#include <string>
+#include "gmock/gmock.h"
+#include "transport_manager/time_metric_observer.h"
+#include "protocol/raw_message.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+class TMMetricObserverMock: public ::transport_manager::TMMetricObserver {
+ public:
+  MOCK_METHOD1(StartRawMsg,
+               void(const protocol_handler::RawMessage* ptr));
+  MOCK_METHOD1(StopRawMsg,
+               void(const protocol_handler::RawMessage* ptr));
+};
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
+#endif  // SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_TIME_METRIC_OBSERVER_MOCK_H_
diff --git a/src/components/transport_manager/test/include/transport_adapter_controller_mock.h b/src/components/transport_manager/test/include/transport_adapter_controller_mock.h
new file mode 100644
index 0000000000..c0c7155e43
--- /dev/null
+++ b/src/components/transport_manager/test/include/transport_adapter_controller_mock.h
@@ -0,0 +1,92 @@
+/*
+ * 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_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_ADAPTER_CONTROLLER_MOCK_H_
+#define SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_ADAPTER_CONTROLLER_MOCK_H_
+
+#include "gmock/gmock.h"
+#include "transport_manager/transport_adapter/transport_adapter_controller.h"
+
+namespace test {
+namespace components {
+namespace transport_manager {
+
+using namespace ::transport_manager::transport_adapter;
+
+class TransportAdapterControllerMock : public TransportAdapterController {
+ public:
+  MOCK_METHOD1(AddDevice, DeviceSptr(DeviceSptr device));
+  MOCK_METHOD1(SearchDeviceDone, void(DeviceVector device));
+  MOCK_METHOD1(ApplicationListUpdated,
+               ApplicationListUpdated(const DeviceUID& device_handle));
+  MOCK_METHOD0(FindNewApplicationsRequest, void());
+  MOCK_METHOD1(SearchDeviceFailed, void(const SearchDeviceError& error));
+  MOCK_CONST_METHOD1(FindDevice, DeviceSptr(const DeviceUID& device_handle));
+  MOCK_CONST_METHOD3(FindDevice, void(ConnectionSPtr connection,
+                                      const DeviceUID& device_handle,
+                                      const ApplicationHandle& app_handle));
+  MOCK_METHOD2(ConnectDone, void(const DeviceUID& device_handle,
+                                 const ApplicationHandle& app_handle));
+  MOCK_METHOD3(ConnectFailed, void(const DeviceUID& device_handle,
+                                   const ApplicationHandle& app_handle,
+                                   const ConnectError& error));
+  MOCK_METHOD2(ConnectionFinished, void(const DeviceUID& device_handle,
+                                        const ApplicationHandle& app_handle));
+  MOCK_METHOD3(ConnectionAborted, void(const DeviceUID& device_handle,
+                                       const ApplicationHandle& app_handle,
+                                       const CommunicationError& error));
+  MOCK_METHOD2(DeviceDisconnected, void(const DeviceUID& device_handle,
+                                        const DisconnectDeviceError& error));
+  MOCK_METHOD2(DisconnectDone, void(const DeviceUID& device_handle,
+                                    const ApplicationHandle& app_handle));
+  MOCK_METHOD3(DataReceiveDone,
+               void(const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    ::protocol_handler::RawMessagePtr message));
+  MOCK_METHOD3(DataReceiveFailed, void(const DeviceUID& device_handle,
+                                       const ApplicationHandle& app_handle,
+                                       const DataReceiveError& error));
+  MOCK_METHOD3(DataSendDone, void(const DeviceUID& device_handle,
+                                  const ApplicationHandle& app_handle,
+                                  ::protocol_handler::RawMessagePtr message));
+  MOCK_METHOD3(DataReceiveFailed,
+               void(const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    ::protocol_handler::RawMessagePtr message,
+                    const DataSendError& error));
+};
+
+}  // namespace transport_manager
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_ADAPTER_CONTROLLER_MOCK_H_
diff --git a/src/components/transport_manager/test/include/transport_adapter_listener_mock.h b/src/components/transport_manager/test/include/transport_adapter_listener_mock.h
new file mode 100644
index 0000000000..88b5cf4b66
--- /dev/null
+++ b/src/components/transport_manager/test/include/transport_adapter_listener_mock.h
@@ -0,0 +1,123 @@
+/*
+ * 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_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_ADAPTER_LISTENER_MOCK_H_
+#define SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_ADAPTER_LISTENER_MOCK_H_
+
+#include "gmock/gmock.h"
+#include "transport_manager/transport_adapter/transport_adapter_listener.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+using namespace transport_manager;
+using transport_adapter::TransportAdapter;
+using transport_adapter::TransportAdapterListener;
+
+class TransportAdapterListenerMock : public TransportAdapterListener {
+ public:
+  MOCK_METHOD1(OnSearchDeviceDone,
+               void(const TransportAdapter* transport_adapter));
+  MOCK_METHOD2(OnSearchDeviceFailed,
+               void(const TransportAdapter* transport_adapter,
+                    const SearchDeviceError& error));
+  MOCK_METHOD1(OnDeviceListUpdated,
+               void(const TransportAdapter* transport_adapter));
+  MOCK_METHOD1(OnFindNewApplicationsRequest,
+               void(const TransportAdapter* transport_adapter));
+  MOCK_METHOD3(OnConnectDone,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle));
+  MOCK_METHOD4(OnConnectFailed,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    const ConnectError& error));
+  MOCK_METHOD3(OnConnectRequested,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle));
+  MOCK_METHOD4(OnUnexpectedDisconnect,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    const CommunicationError& error));
+  MOCK_METHOD3(OnDisconnectDone,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle));
+  MOCK_METHOD4(OnDisconnectFailed,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    const DisconnectError& error));
+  MOCK_METHOD2(OnDisconnectDeviceDone,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle));
+  MOCK_METHOD3(OnDisconnectDeviceFailed,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const DisconnectDeviceError& error));
+  MOCK_METHOD4(OnDataSendDone,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    const ::protocol_handler::RawMessagePtr data_container));
+  MOCK_METHOD5(OnDataSendFailed,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    const ::protocol_handler::RawMessagePtr data_container,
+                    const DataSendError& error));
+  MOCK_METHOD4(OnDataReceiveDone,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    const ::protocol_handler::RawMessagePtr data_container));
+  MOCK_METHOD4(OnDataReceiveFailed,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle,
+                    const DataReceiveError& error));
+  MOCK_METHOD3(OnCommunicationError,
+               void(const TransportAdapter* transport_adapter,
+                    const DeviceUID& device_handle,
+                    const ApplicationHandle& app_handle));
+};
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_ADAPTER_LISTENER_MOCK_H_
diff --git a/src/components/transport_manager/test/include/transport_adapter_mock.h b/src/components/transport_manager/test/include/transport_adapter_mock.h
new file mode 100644
index 0000000000..86e044d13b
--- /dev/null
+++ b/src/components/transport_manager/test/include/transport_adapter_mock.h
@@ -0,0 +1,104 @@
+/*
+ * 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_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_ADAPTER_MOCK_H_
+#define SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_ADAPTER_MOCK_H_
+
+#include "gmock/gmock.h"
+#include "transport_manager/transport_adapter/transport_adapter.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+class TransportAdapterMock
+    : public ::transport_manager::transport_adapter::TransportAdapter {
+ public:
+  MOCK_CONST_METHOD0(GetDeviceType,
+                     ::transport_manager::transport_adapter::DeviceType());
+  MOCK_CONST_METHOD0(GetConnectionType, ::transport_manager::ConnectionType());
+  MOCK_CONST_METHOD0(IsInitialised, bool());
+  MOCK_METHOD0(
+      Init, ::transport_manager::transport_adapter::TransportAdapter::Error());
+  MOCK_METHOD0(Terminate, void());
+  MOCK_METHOD1(
+      AddListener,
+      void(::transport_manager::transport_adapter::TransportAdapterListener*
+               listener));
+  MOCK_CONST_METHOD0(IsSearchDevicesSupported, bool());
+  MOCK_METHOD0(
+      SearchDevices,
+      ::transport_manager::transport_adapter::TransportAdapter::Error());
+  MOCK_CONST_METHOD0(IsServerOriginatedConnectSupported, bool());
+  MOCK_METHOD2(Connect,
+               ::transport_manager::transport_adapter::TransportAdapter::Error(
+                   const ::transport_manager::DeviceUID& device_handle,
+                   const ::transport_manager::ApplicationHandle& app_handle));
+  MOCK_METHOD1(ConnectDevice,
+               ::transport_manager::transport_adapter::TransportAdapter::Error(
+                   const ::transport_manager::DeviceUID& device_handle));
+  MOCK_CONST_METHOD0(IsClientOriginatedConnectSupported, bool());
+  MOCK_METHOD0(
+      StartClientListening,
+      ::transport_manager::transport_adapter::TransportAdapter::Error());
+  MOCK_METHOD0(
+      StopClientListening,
+      ::transport_manager::transport_adapter::TransportAdapter::Error());
+  MOCK_METHOD2(Disconnect,
+               ::transport_manager::transport_adapter::TransportAdapter::Error(
+                   const ::transport_manager::DeviceUID& device_handle,
+                   const ::transport_manager::ApplicationHandle& app_handle));
+  MOCK_METHOD1(DisconnectDevice,
+               Error(const ::transport_manager::DeviceUID& device_handle));
+  MOCK_METHOD3(SendData,
+               ::transport_manager::transport_adapter::TransportAdapter::Error(
+                   const ::transport_manager::DeviceUID& device_handle,
+                   const ::transport_manager::ApplicationHandle& app_handle,
+                   const protocol_handler::RawMessagePtr data));
+  MOCK_CONST_METHOD0(GetDeviceList, ::transport_manager::DeviceList());
+  MOCK_CONST_METHOD1(GetApplicationList,
+                     ::transport_manager::ApplicationList(
+                         const ::transport_manager::DeviceUID& device_handle));
+  MOCK_CONST_METHOD1(
+      DeviceName,
+      std::string(const ::transport_manager::DeviceUID& device_handle));
+
+#ifdef TIME_TESTER
+  MOCK_METHOD0(GetTimeMetricObserver, ::transport_manager::TMMetricObserver*());
+#endif  // TIME_TESTER
+};
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_ADAPTER_MOCK_H_
diff --git a/src/components/transport_manager/test/include/transport_manager_impl_mock.h b/src/components/transport_manager/test/include/transport_manager_impl_mock.h
new file mode 100644
index 0000000000..bb73f1fa49
--- /dev/null
+++ b/src/components/transport_manager/test/include/transport_manager_impl_mock.h
@@ -0,0 +1,54 @@
+/*
+ * 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 APPLINK_TEST_COMPONENTS_TRANSPORTMANAGER_INCLUDE_TRANSPORT_MANAGER_IMPL_MOCK_H_
+#define APPLINK_TEST_COMPONENTS_TRANSPORTMANAGER_INCLUDE_TRANSPORT_MANAGER_IMPL_MOCK_H_
+
+#include "gmock/gmock.h"
+#include "transport_manager/transport_manager_impl.h"
+
+namespace test {
+namespace components {
+namespace transport_manager {
+
+using namespace ::transport_manager;
+
+class TransportManagerImplMock : public TransportManagerImpl {
+ public:
+  MOCK_METHOD1(ReceiveEventFromDevice, int(const TransportAdapterEvent& event));
+};
+
+}  // namespace transport_manager
+}  // namespace components
+}  // namespace test
+
+#endif // APPLINK_TEST_COMPONENTS_TRANSPORTMANAGER_INCLUDE_TRANSPORT_MANAGER_IMPL_MOCK_H_
diff --git a/src/components/transport_manager/test/include/transport_manager_listener_mock.h b/src/components/transport_manager/test/include/transport_manager_listener_mock.h
new file mode 100644
index 0000000000..29758159f1
--- /dev/null
+++ b/src/components/transport_manager/test/include/transport_manager_listener_mock.h
@@ -0,0 +1,89 @@
+/*
+ * 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_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_MANAGER_LISTENER_MOCK_H_
+#define SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_MANAGER_LISTENER_MOCK_H_
+
+#include <vector>
+#include <gmock/gmock.h>
+#include "transport_manager/transport_manager_listener.h"
+#include "protocol/raw_message.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+using namespace transport_manager;
+using ::protocol_handler::RawMessage;
+using ::protocol_handler::RawMessagePtr;
+
+class TransportManagerListenerMock : public TransportManagerListener {
+ public:
+  MOCK_METHOD1(OnDeviceListUpdated, void(const std::vector<DeviceInfo>&));
+  MOCK_METHOD0(OnFindNewApplicationsRequest, void());
+  MOCK_METHOD1(OnDeviceFound, void(const DeviceInfo& device_info));
+  MOCK_METHOD1(OnDeviceAdded, void(const DeviceInfo& device_info));
+  MOCK_METHOD1(OnDeviceRemoved, void(const DeviceInfo& device_info));
+  MOCK_METHOD0(OnNoDeviceFound, void());
+  MOCK_METHOD0(OnScanDevicesFinished, void());
+  MOCK_METHOD1(OnScanDevicesFailed, void(const SearchDeviceError& error));
+
+  MOCK_METHOD2(OnConnectionEstablished,
+               void(const DeviceInfo& device_info,
+                    const ConnectionUID& connection_id));
+  MOCK_METHOD2(OnConnectionFailed,
+               void(const DeviceInfo& device_info, const ConnectError& error));
+
+  MOCK_METHOD1(OnConnectionClosed, void(ConnectionUID connection_id));
+  MOCK_METHOD2(OnConnectionClosedFailure,
+               void(ConnectionUID connection_id, const DisconnectError& error));
+  MOCK_METHOD2(OnUnexpectedDisconnect, void(ConnectionUID connection_id,
+                                            const CommunicationError& error));
+  MOCK_METHOD2(OnDeviceConnectionLost,
+               void(const DeviceHandle& device,
+                    const DisconnectDeviceError& error));
+  MOCK_METHOD2(OnDisconnectFailed, void(const DeviceHandle& device,
+                                        const DisconnectDeviceError& error));
+
+  MOCK_METHOD1(OnTMMessageReceived, void(const RawMessagePtr data_container));
+  MOCK_METHOD2(OnTMMessageReceiveFailed, void(ConnectionUID connection_id,
+                                              const DataReceiveError& error));
+  MOCK_METHOD1(OnTMMessageSend, void(const RawMessagePtr message));
+  MOCK_METHOD2(OnTMMessageSendFailed,
+               void(const DataSendError& error, const RawMessagePtr message));
+};
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_TRANSPORT_MANAGER_TEST_INCLUDE_TRANSPORT_MANAGER_LISTENER_MOCK_H_
diff --git a/src/components/transport_manager/test/smartDeviceLink_test.ini b/src/components/transport_manager/test/smartDeviceLink_test.ini
new file mode 100644
index 0000000000..40aeb5a019
--- /dev/null
+++ b/src/components/transport_manager/test/smartDeviceLink_test.ini
@@ -0,0 +1,55 @@
+  ; The INI-file consists of different chapters.
+; Each chapter begins with the line containing
+; the name in square brackets. Syntax:
+; [chapter]
+; The chapters consists of a set of items with a
+; assinged value. The syntax is:
+; item=value
+; All white spaces an second encounters of chapters
+; or items will be ignored.
+; Remarks start with semicolon or star as first character.
+; It is alowed for names of chapters and items to
+; contain semicolon and star. Possible syntax is:
+; [ chapter ]       ;Remark
+;    item = value   ;Remark
+
+[HMI]
+LaunchHMI = false
+LinkToWebHMI = "HMI/index.html"
+ServerAddress = 127.0.0.1
+ServerPort = 8087
+VideoStreamingPort = 5050
+AudioStreamingPort = 5080
+
+[MAIN]
+SDLVersion = 
+LogsEnabled = false
+; Contains .json/.ini files
+AppConfigFolder =
+; Contains output files, e.g. .wav
+AppStorageFolder = storage
+; Contains resourses, e.g. audio8bit.wav
+AppResourceFolder =
+
+
+UseLastState = true
+
+
+[Resumption]
+
+# Timeout in milliseconds for resumption Application HMILevel
+# and resolving conflicts in case if multiple applications initiate resumption
+ApplicationResumingTimeout = 3000
+
+# Timeout in milliseconds for periodical saving resumption persistent data
+AppSavePersistentDataTimeout = 10000
+
+# Timeout in seconds to store hmi_level for media app before ign_off
+ResumptionDelayBeforeIgn = 30;
+
+# Timeout in seconds to restore hmi_level for media app after sdl run
+ResumptionDelayAfterIgn = 30;
+
+# Resumption ctrl uses JSON if UseDBForResumption=false for store data otherwise uses DB
+UseDBForResumption = false
+
diff --git a/src/components/transport_manager/test/tcp_client_listener_test.cc b/src/components/transport_manager/test/tcp_client_listener_test.cc
new file mode 100644
index 0000000000..916f8bac58
--- /dev/null
+++ b/src/components/transport_manager/test/tcp_client_listener_test.cc
@@ -0,0 +1,101 @@
+/*
+ * 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 "include/transport_adapter_mock.h"
+#include "transport_manager/tcp/tcp_client_listener.h"
+#include "include/transport_manager_mock.h"
+#include "transport_manager/transport_adapter/transport_adapter_controller.h"
+#include "transport_manager/transport_adapter/device.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+using ::testing::Return;
+using namespace ::transport_manager;
+using namespace ::transport_manager::transport_adapter;
+
+class MockTransportAdapterController: public TransportAdapterController {
+public:
+ MOCK_METHOD1(AddDevice,DeviceSptr(DeviceSptr device));
+ MOCK_METHOD0(AckDevices,void());
+ MOCK_METHOD1(SearchDeviceDone, void(const DeviceVector& devices));
+ MOCK_METHOD1(SearchDeviceFailed, void(const SearchDeviceError& error));
+ MOCK_CONST_METHOD1(FindDevice, DeviceSptr(const DeviceUID& device_handle));
+ MOCK_METHOD3(ConnectionCreated, void(ConnectionSPtr connection, const DeviceUID& device_handle, const ApplicationHandle& app_handle));
+ MOCK_METHOD2(ConnectDone, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle));
+ MOCK_METHOD3(ConnectFailed, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const ConnectError& error));
+ MOCK_METHOD2(ConnectionFinished, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle));
+ MOCK_METHOD3(ConnectionAborted,void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const CommunicationError& error));
+ MOCK_METHOD2(DisconnectDone, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle));
+ MOCK_METHOD3(DataReceiveDone, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const ::protocol_handler::RawMessagePtr message));
+ MOCK_METHOD3(DataReceiveFailed, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const DataReceiveError& error));
+ MOCK_METHOD3(DataSendDone, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const ::protocol_handler::RawMessagePtr message));
+ MOCK_METHOD4(DataSendFailed, void(const DeviceUID& device_handle, const ApplicationHandle& app_handle, const ::protocol_handler::RawMessagePtr message, const DataSendError& error));
+ MOCK_METHOD0(FindNewApplicationsRequest, void());
+ MOCK_METHOD1(ApplicationListUpdated, void(const DeviceUID& device_handle));
+ MOCK_METHOD2(DeviceDisconnected, void (const DeviceUID& device_handle,const DisconnectDeviceError& error));
+};
+
+class TcpClientListenerTest : public ::testing::Test {
+ public:
+  TcpClientListenerTest()
+      : port_(0),
+        enable_keep_alive_(false),
+        tcp_client_listener_(&adapter_controller_mock_, port_, enable_keep_alive_) {}
+
+ protected:
+  uint16_t port_;
+  bool enable_keep_alive_;
+  MockTransportAdapterController adapter_controller_mock_;
+  TcpClientListener tcp_client_listener_;
+};
+
+TEST_F(TcpClientListenerTest, Ctor_test) {
+  EXPECT_EQ(0, tcp_client_listener_.port());
+  EXPECT_TRUE(NULL != tcp_client_listener_.thread());
+  EXPECT_EQ(-1, tcp_client_listener_.get_socket());
+}
+
+TEST_F(TcpClientListenerTest, IsInitialised) {
+ EXPECT_TRUE(tcp_client_listener_.IsInitialised());
+}
+
+TEST_F(TcpClientListenerTest, Init) {
+  EXPECT_EQ(TransportAdapter::OK, tcp_client_listener_.Init());
+}
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
+
diff --git a/src/components/transport_manager/test/tcp_device_test.cc b/src/components/transport_manager/test/tcp_device_test.cc
new file mode 100644
index 0000000000..961ebe6954
--- /dev/null
+++ b/src/components/transport_manager/test/tcp_device_test.cc
@@ -0,0 +1,105 @@
+/*
+ * 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 "transport_manager/tcp/tcp_device.h"
+#include "transport_manager/transport_adapter/device.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+using namespace ::transport_manager;
+using namespace ::transport_manager::transport_adapter;
+
+class TestDevice : public Device {
+ public:
+  TestDevice(const uint32_t& in_addr, const std::string& name)
+      : Device(name, name), in_addr_(in_addr) {}
+  bool IsSameAs(const Device* other_device) const { return true; }
+  ApplicationList GetApplicationList() const {
+    ApplicationList app_list;
+    return app_list;
+  }
+  const uint32_t in_addr_;
+};
+
+TEST(TcpDeviceTest, CompareWithOtherTCPDevice) {
+  uint32_t in_addr = 10;
+  std::string name = "tcp_device";
+  TcpDevice test_tcp_device(in_addr, name);
+  TcpDevice other(in_addr, "other");
+
+  EXPECT_TRUE(test_tcp_device.IsSameAs(&other));
+}
+
+TEST(TcpDeviceTest, CompareWithOtherNotTCPDevice) {
+  uint32_t in_addr = 10;
+  std::string name = "tcp_device";
+  TcpDevice test_tcp_device(in_addr, name);
+  TestDevice other(in_addr, "other");
+
+  EXPECT_FALSE(test_tcp_device.IsSameAs(&other));
+}
+
+TEST(TcpDeviceTest, AddApplications) {
+  uint32_t in_addr = 1;
+  std::string name = "tcp_device";
+
+  TcpDevice test_tcp_device(in_addr, name);
+
+  // App will be with socket = 0, incoming = false;
+  int port = 12345;
+
+  EXPECT_EQ(1, test_tcp_device.AddDiscoveredApplication(port));
+
+  // App.incoming = true; app.port = 0;
+  int socket = 10;
+  EXPECT_EQ(2, test_tcp_device.AddIncomingApplication(socket));
+
+  ApplicationList applist = test_tcp_device.GetApplicationList();
+  ASSERT_EQ(2u, applist.size());
+  EXPECT_EQ(1, applist[0]);
+  EXPECT_EQ(2, applist[1]);
+
+  // Because incoming = false
+  EXPECT_EQ(-1, test_tcp_device.GetApplicationSocket(applist[0]));
+  EXPECT_EQ(10, test_tcp_device.GetApplicationSocket(applist[1]));
+
+  EXPECT_EQ(port, test_tcp_device.GetApplicationPort(applist[0]));
+  // Because incoming = true
+  EXPECT_EQ(-1, test_tcp_device.GetApplicationPort(applist[1]));
+}
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/transport_manager/test/tcp_transport_adapter_test.cc b/src/components/transport_manager/test/tcp_transport_adapter_test.cc
index c91736b9f4..d849d94d48 100644
--- a/src/components/transport_manager/test/tcp_transport_adapter_test.cc
+++ b/src/components/transport_manager/test/tcp_transport_adapter_test.cc
@@ -30,430 +30,329 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sys/time.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <netinet/in.h>
-
+#include "gtest/gtest.h"
 #include "transport_manager/tcp/tcp_transport_adapter.h"
-#include "transport_manager/transport_adapter/transport_adapter_listener.h"
-#include "include/mock_transport_adapter_listener.h"
+#include "transport_manager/transport_adapter/connection.h"
+#include "config_profile/profile.h"
+#include "resumption/last_state.h"
 #include "protocol/raw_message.h"
-#include "utils/logger.h"
-
-namespace transport_manager {
-namespace transport_adapter {
-
-using namespace ::protocol_handler;
-
-TEST(TcpAdapterBasicTest, GetDeviceType_Return_sdltcp) {
-
-  //arrange
-  TransportAdapter* transport_adapter = new TcpTransportAdapter(12345);
-
-  // Assert
-  EXPECT_EQ(TCP, transport_adapter->GetDeviceType());
-
-  delete transport_adapter;
-}
-
-TEST(TcpAdapterBasicTest, isServerOriginatedConnectSupported_Return_True) {
-
-  //arrange
-  TransportAdapter* transport_adapter = new TcpTransportAdapter(12345);
-
-  //assert
-  EXPECT_TRUE(transport_adapter->IsServerOriginatedConnectSupported());
-
-  delete transport_adapter;
-}
-
-TEST(TcpAdapterBasicTest, isClientOriginatedConnectSupported_Return_True) {
-
-  //arrange
-  TransportAdapter* transport_adapter = new TcpTransportAdapter(12345);
-
-  //assert
-  EXPECT_TRUE(transport_adapter->IsClientOriginatedConnectSupported());
-
-  delete transport_adapter;
-}
-
-TEST(TcpAdapterBasicTest, isSearchDevicesSupported_Return_True) {
-
-  //arrange
-  TransportAdapter* transport_adapter = new TcpTransportAdapter(12345);
-
-  //assert
-  EXPECT_TRUE(transport_adapter->IsSearchDevicesSupported());
+#include "include/transport_adapter_listener_mock.h"
+#include "include/device_mock.h"
+#include "include/connection_mock.h"
 
-  delete transport_adapter;
-}
-
-TEST(TcpAdapterBasicTest, NotInitialised_Return_BAD_STATE) {
-
-  //arrange
-  TransportAdapter* transport_adapter = new TcpTransportAdapter(12345);
-
-  //assert
-  EXPECT_EQ(TransportAdapter::BAD_STATE, transport_adapter->SearchDevices());
-
-  delete transport_adapter;
-}
-
-//TODO(KKolodiy)APPLINK-11045
-TEST(TcpAdapterBasicTest, DISABLED_NotInitialised_Return_OK_InConnect) {
-
-  //arrange
-  TransportAdapter* transport_adapter = new TcpTransportAdapter(12345);
-
-  //assert
-  EXPECT_EQ(TransportAdapter::OK,
-            transport_adapter->Connect(DeviceUID("xxx"), 2));
-  delete transport_adapter;
-}
-
-TEST(TcpAdapterBasicTest, NotInitialised_Return_BAD_STATE_inDisconnect) {
+namespace test {
+namespace components {
+namespace transport_manager_test {
 
-  //arrange
-  TransportAdapter* transport_adapter = new TcpTransportAdapter(12345);
-
-  //assert
-  EXPECT_EQ(TransportAdapter::BAD_STATE,
-            transport_adapter->Disconnect(DeviceUID("xxx"), 2));
-  delete transport_adapter;
-}
-
-TEST(TcpAdapterBasicTest, NotInitialised_Return_BAD_STATE_in_DisconnectDevice) {
-
-  //arrange
-  TransportAdapter* transport_adapter = new TcpTransportAdapter(12345);
+using ::testing::Return;
+using ::testing::_;
 
-  //assert
-  EXPECT_EQ(TransportAdapter::BAD_STATE,
-            transport_adapter->DisconnectDevice(DeviceUID("xxx")));
-  delete transport_adapter;
-}
+using namespace ::protocol_handler;
+using namespace ::transport_manager;
+using namespace transport_manager::transport_adapter;
 
-class ClientTcpSocket {
+class TestTCPTransportAdapter : public TcpTransportAdapter {
  public:
-  bool Connect(uint16_t server_port) {
-
-    socket_ = socket(AF_INET, SOCK_STREAM, 0);
-    std::cout << "socket is " << socket_ << "\n\n";
-    if (socket_ < 0)
-      return false;
-
-    struct sockaddr_in addr;
-    memset((char*) &addr, 0, sizeof(addr));
-    addr.sin_family = AF_INET;
-    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-    addr.sin_port = htons(server_port);
-
-    if (::connect(socket_, (struct sockaddr*) &addr, sizeof(addr)) < 0)
-      return false;
-    else
-      return true;
+  TestTCPTransportAdapter(uint16_t port) : TcpTransportAdapter(port) {
+    ::profile::Profile::instance()->config_file_name(
+        "smartDeviceLink_test.ini");
   }
+  MOCK_CONST_METHOD2(FindEstablishedConnection,
+                     ConnectionSPtr(const DeviceUID& device_handle,
+                                    const ApplicationHandle& app_handle));
+
+  MOCK_CONST_METHOD1(FindDevice, DeviceSptr(const DeviceUID& device_handle));
+  MOCK_METHOD2(Connect,
+               TransportAdapter::Error(const DeviceUID& device_handle,
+                                       const ApplicationHandle& app_handle));
+  void CallStore() { Store(); }
+  bool CallRestore() { return Restore(); }
+};
 
-  bool Send(const std::string& str) {
-    size_t size = str.size();
-    ssize_t written = write(socket_, str.c_str(), size);
-    if (written != -1) {
-      size_t count = static_cast<size_t>(written);
-      return count == size;
-    } else {
-      return false;
-    }
+class TcpAdapterTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    ::profile::Profile::instance()->config_file_name(
+        "smartDeviceLink_test.ini");
   }
-
-  std::string receive(size_t size) {
-    char* buf = new char[size];
-    ssize_t read = recv(socket_, buf, size, MSG_WAITALL);
-    if (read != -1) {
-      return std::string(buf, buf + read);
-    } else {
-      return std::string();
-    }
+   virtual void SetUp() {
+       resumption::LastState::instance()->dictionary = Json::Value();
   }
 
-  void Disconnect() {
-    close(socket_);
-  }
+  virtual void TearDown() { resumption::LastState::destroy(); }
 
- private:
-  uint16_t port_;
-  int socket_;
+  const uint32_t port = 12345;
+  const std::string string_port = "12345";
 };
 
-using ::testing::_;
-using ::testing::Invoke;
-
-void Disconnect(const TransportAdapter* transport_adapter,
-                const DeviceUID device_handle,
-                const ApplicationHandle app_handle) {
-  EXPECT_EQ(
-      TransportAdapter::OK,
-      const_cast<TransportAdapter*>(transport_adapter)->Disconnect(
-          device_handle, app_handle));
-
-  std::cout << "adapter is disconnected" << "\n";
+TEST_F(TcpAdapterTest, DISABLED_StoreDataWithOneDeviceAndOneApplication) {
+  // Prepare
+  TestTCPTransportAdapter transport_adapter(port);
+  std::string uniq_id = "unique_device_name";
+  utils::SharedPtr<TCPDeviceMock> mockdev = new TCPDeviceMock(port, uniq_id);
+  transport_adapter.AddDevice(mockdev);
+
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(1u, devList.size());
+  EXPECT_EQ(uniq_id, devList[0]);
+
+  const int app_handle = 1;
+  std::vector<int> intList = {app_handle};
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList));
+
+  ConnectionSPtr mock_connection = new ConnectionMock();
+  EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev));
+  EXPECT_CALL(transport_adapter, FindEstablishedConnection(uniq_id, app_handle))
+      .WillOnce(Return(mock_connection));
+
+  EXPECT_CALL(*mockdev, GetApplicationPort(app_handle)).WillOnce(Return(port));
+
+  transport_adapter.CallStore();
+
+  // Check that value is saved
+  Json::Value& tcp_dict = resumption::LastState::instance()
+                              ->dictionary["TransportManager"]["TcpAdapter"];
+
+  ASSERT_TRUE(tcp_dict.isObject());
+  ASSERT_FALSE(tcp_dict["devices"].isNull());
+  ASSERT_FALSE(tcp_dict["devices"][0]["applications"].isNull());
+  ASSERT_FALSE(tcp_dict["devices"][0]["address"].isNull());
+  EXPECT_EQ(1u, tcp_dict["devices"][0]["applications"].size());
+  EXPECT_EQ(string_port,
+            tcp_dict["devices"][0]["applications"][0]["port"].asString());
+  EXPECT_EQ(uniq_id, tcp_dict["devices"][0]["name"].asString());
 }
 
-class TcpAdapterTest : public ::testing::Test {
- public:
-  TcpAdapterTest()
-      : port_(ChoosePort()),
-        transport_adapter_(new TcpTransportAdapter(port_)),
-        suspended_(false),
-        finished_(false) {
-    pthread_mutex_init(&suspend_mutex_, 0);
-    pthread_cond_init(&suspend_cond_, 0);
+TEST_F(TcpAdapterTest, DISABLED_StoreDataWithSeveralDevicesAndOneApplication) {
+  // Prepare
+  TestTCPTransportAdapter transport_adapter(port);
+  const uint32_t count_dev = 10;
+  utils::SharedPtr<TCPDeviceMock> mockdev[count_dev];
+  std::string uniq_id[count_dev];
+  for (uint32_t i = 0; i < count_dev; i++) {
+    char numb[12];
+    std::snprintf(numb, 12, "%d", i);
+    uniq_id[i] = "unique_device_name" + std::string(numb);
+    mockdev[i] = new TCPDeviceMock(port, uniq_id[i]);
+    EXPECT_CALL(*(mockdev[i]), IsSameAs(_)).WillRepeatedly(Return(false));
+    transport_adapter.AddDevice(mockdev[i]);
   }
 
-  uint16_t ChoosePort() {
-    return getpid() % 1000 + 3000;
-  }
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(count_dev, devList.size());
+  EXPECT_EQ(uniq_id[0], devList[0]);
 
-  virtual void SetUp() {
-    const TransportAdapter::Error error = transport_adapter_->Init();
-    ASSERT_EQ(TransportAdapter::OK, error);
-    transport_adapter_->AddListener(&mock_dal_);
-    time_t end_time = time(NULL) + 5;
-    while (!transport_adapter_->IsInitialised() && time(NULL) < end_time)
-      sleep(0);
-    ASSERT_TRUE(transport_adapter_->IsInitialised());
-  }
+  const int app_handle = 1;
+  std::vector<int> intList = {app_handle};
 
-  virtual void TearDown() {
-    transport_adapter_->StopClientListening();
-  }
+  ConnectionSPtr mock_connection = new ConnectionMock();
+  for (uint32_t i = 0; i < count_dev; i++) {
+    EXPECT_CALL(transport_adapter, FindDevice(uniq_id[i]))
+        .WillOnce(Return(mockdev[i]));
+    EXPECT_CALL(*(mockdev[i]), GetApplicationList()).WillOnce(Return(intList));
 
-  virtual ~TcpAdapterTest() {
-    pthread_mutex_lock(&suspend_mutex_);
-    if (!finished_)
-      suspended_ = true;
-    struct timeval now;
-    gettimeofday(&now, NULL);
-    timespec abs_time;
-    abs_time.tv_sec = now.tv_sec + 1;
-    abs_time.tv_nsec = now.tv_usec * 1000;
-    while (suspended_) {
-      if (ETIMEDOUT
-          == pthread_cond_timedwait(&suspend_cond_, &suspend_mutex_,
-                                    &abs_time)) {
-        break;
-      }
-    }
-    pthread_mutex_unlock(&suspend_mutex_);
-    delete transport_adapter_;
+    EXPECT_CALL(transport_adapter,
+                FindEstablishedConnection(uniq_id[i], app_handle))
+        .WillOnce(Return(mock_connection));
 
-    pthread_mutex_destroy(&suspend_mutex_);
-    pthread_cond_destroy(&suspend_cond_);
+    EXPECT_CALL(*(mockdev[i]), GetApplicationPort(app_handle))
+        .WillOnce(Return(port));
   }
-
-  void wakeUp() {
-    pthread_mutex_lock(&suspend_mutex_);
-    finished_ = true;
-    suspended_ = false;
-    pthread_cond_signal(&suspend_cond_);
-    pthread_mutex_unlock(&suspend_mutex_);
+  transport_adapter.CallStore();
+
+  // Check that values are saved
+  Json::Value& tcp_dict = resumption::LastState::instance()
+                              ->dictionary["TransportManager"]["TcpAdapter"];
+  ASSERT_TRUE(tcp_dict.isObject());
+  ASSERT_FALSE(tcp_dict["devices"].isNull());
+  for (uint32_t i = 0; i < count_dev; i++) {
+    ASSERT_FALSE(tcp_dict["devices"][i]["applications"].isNull());
+    ASSERT_FALSE(tcp_dict["devices"][i]["address"].isNull());
+    EXPECT_EQ(1u, tcp_dict["devices"][i]["applications"].size());
+    EXPECT_EQ(string_port,
+              tcp_dict["devices"][i]["applications"][0]["port"].asString());
+    EXPECT_EQ(uniq_id[i], tcp_dict["devices"][i]["name"].asString());
   }
+}
 
-  uint16_t port() const {
-    return port_;
+TEST_F(TcpAdapterTest, DISABLED_StoreDataWithSeveralDevicesAndSeveralApplications) {
+  // Prepare
+  TestTCPTransportAdapter transport_adapter(port);
+  const uint32_t count_dev = 10;
+
+  utils::SharedPtr<TCPDeviceMock> mockdev[count_dev];
+  std::string uniq_id[count_dev];
+  for (uint32_t i = 0; i < count_dev; i++) {
+    char numb[12];
+    std::snprintf(numb, 12, "%d", i);
+    uniq_id[i] = "unique_device_name" + std::string(numb);
+    mockdev[i] = new TCPDeviceMock(port, uniq_id[i]);
+    EXPECT_CALL(*(mockdev[i]), IsSameAs(_)).WillRepeatedly(Return(false));
+    transport_adapter.AddDevice(mockdev[i]);
   }
 
-  const uint16_t port_;
-  TransportAdapter* transport_adapter_;
-  ::test::components::transport_manager::MockTransportAdapterListener mock_dal_;
-  ClientTcpSocket client_;
-
-  pthread_cond_t suspend_cond_;
-  pthread_mutex_t suspend_mutex_;
-  bool suspended_;
-  bool finished_;
-
-};
-
-class TcpAdapterTestWithListenerAutoStart : public TcpAdapterTest {
-  virtual void SetUp() {
-    TcpAdapterTest::SetUp();
-    transport_adapter_->StartClientListening();
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(count_dev, devList.size());
+  EXPECT_EQ(uniq_id[0], devList[0]);
+
+  const uint32_t connection_count = 3;
+  const int app_handle[connection_count] = {1, 2, 3};
+  std::vector<int> intList = {app_handle[0], app_handle[1], app_handle[2]};
+  const std::string ports[connection_count] = {"11111", "67890", "98765"};
+  const int int_port[connection_count] = {11111, 67890, 98765};
+  ConnectionSPtr mock_connection = new ConnectionMock();
+  for (uint32_t i = 0; i < count_dev; i++) {
+    EXPECT_CALL(transport_adapter, FindDevice(uniq_id[i]))
+        .WillOnce(Return(mockdev[i]));
+    EXPECT_CALL(*(mockdev[i]), GetApplicationList()).WillOnce(Return(intList));
+
+    for (uint32_t j = 0; j < connection_count; j++) {
+      EXPECT_CALL(transport_adapter,
+                  FindEstablishedConnection(uniq_id[i], app_handle[j]))
+          .WillOnce(Return(mock_connection));
+      EXPECT_CALL(*(mockdev[i]), GetApplicationPort(app_handle[j]))
+          .WillOnce(Return(int_port[j]));
+    }
   }
-
-};
-
-MATCHER_P(ContainsMessage, str, ""){ return strlen(str) == arg->data_size() && 0 == memcmp(str, arg->data(), arg->data_size());}
-
-// TODO{ALeshin} APPLINK-11090 - transport_adapter_->IsInitialised() doesn't return true as expected
-TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_Connect_Return_True) {
-  {
-    ::testing::InSequence seq;
-    EXPECT_CALL(mock_dal_, OnDeviceListUpdated(_));
-    EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce(
-        InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp));
+  transport_adapter.CallStore();
+
+  // Check that value is saved
+  Json::Value& tcp_dict = resumption::LastState::instance()
+                              ->dictionary["TransportManager"]["TcpAdapter"];
+
+  ASSERT_TRUE(tcp_dict.isObject());
+  ASSERT_FALSE(tcp_dict["devices"].isNull());
+  for (uint32_t i = 0; i < count_dev; i++) {
+    ASSERT_FALSE(tcp_dict["devices"][i]["applications"].isNull());
+    ASSERT_FALSE(tcp_dict["devices"][i]["address"].isNull());
+    for (uint32_t j = 0; j < intList.size(); j++) {
+      EXPECT_EQ(ports[j],
+                tcp_dict["devices"][i]["applications"][j]["port"].asString());
+      EXPECT_EQ(uniq_id[i], tcp_dict["devices"][i]["name"].asString());
+    }
   }
-  EXPECT_TRUE(client_.Connect(port()));
 }
 
-// TODO{ALeshin} APPLINK-11090 - transport_adapter_->IsInitialised() doesn't return true as expected
-TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_SecondConnect_Return_True) {
-  {
-    ::testing::InSequence seq;
-    EXPECT_CALL(mock_dal_, OnDeviceListUpdated(_));
-    EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce(
-        InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp));
-  }
-  EXPECT_TRUE(client_.Connect(port()));
+TEST_F(TcpAdapterTest, StoreData_ConnectionNotExist_DataNotStored) {
+  // Prepare
+  TestTCPTransportAdapter transport_adapter(port);
+  std::string uniq_id = "unique_device_name";
+  utils::SharedPtr<TCPDeviceMock> mockdev = new TCPDeviceMock(port, uniq_id);
+  transport_adapter.AddDevice(mockdev);
+
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(1u, devList.size());
+  EXPECT_EQ(uniq_id, devList[0]);
+  std::vector<int> intList = {};
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList));
+
+  EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev));
+  EXPECT_CALL(transport_adapter, FindEstablishedConnection(uniq_id, _))
+      .Times(0);
+  EXPECT_CALL(*mockdev, GetApplicationPort(_)).Times(0);
+  transport_adapter.CallStore();
+
+  // Check that value is not saved
+  Json::Value& tcp_dict =
+      resumption::LastState::instance()
+          ->dictionary["TransportManager"]["TcpAdapter"]["devices"];
+  ASSERT_TRUE(tcp_dict.isNull());
 }
 
-// TODO{ALeshin} APPLINK-11090 - transport_adapter_->IsInitialised() doesn't return true as expected
-TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_Receive_Return_True) {
-  {
-    ::testing::InSequence seq;
-
-    EXPECT_CALL(mock_dal_, OnDeviceListUpdated(_));
-    EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _));
-
-    EXPECT_CALL(
-        mock_dal_,
-        OnDataReceiveDone(transport_adapter_, _, _, ContainsMessage("abcd"))).
-        WillOnce(InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp));
-  }
-  EXPECT_TRUE(client_.Connect(port()));
-  EXPECT_TRUE(client_.Send("abcd"));
+TEST_F(TcpAdapterTest, RestoreData_DataNotStored) {
+  Json::Value& tcp_adapter_dictionary =
+      resumption::LastState::instance()
+          ->dictionary["TransportManager"]["TcpAdapter"];
+  tcp_adapter_dictionary = Json::Value();
+  TestTCPTransportAdapter transport_adapter(port);
+  EXPECT_CALL(transport_adapter, Connect(_, _)).Times(0);
+  EXPECT_TRUE(transport_adapter.CallRestore());
 }
 
-struct SendHelper {
-  explicit SendHelper(TransportAdapter::Error expected_error)
-      : expected_error_(expected_error),
-        message_(
-            new RawMessage(
-                1,
-                1,
-                const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>("efgh")),
-                4)) {
-  }
-  void sendMessage(const TransportAdapter* transport_adapter,
-                   const DeviceUID device_handle,
-                   const ApplicationHandle app_handle) {
-    EXPECT_EQ(
-        expected_error_,
-        const_cast<TransportAdapter*>(transport_adapter)->SendData(
-            device_handle, app_handle, message_));
-  }
-  TransportAdapter::Error expected_error_;
-  RawMessagePtr message_;
-};
+TEST_F(TcpAdapterTest, DISABLED_StoreDataWithOneDevice_RestoreData) {
+  TestTCPTransportAdapter transport_adapter(port);
+  std::string uniq_id = "unique_device_name";
+  utils::SharedPtr<TCPDeviceMock> mockdev = new TCPDeviceMock(port, uniq_id);
+  transport_adapter.AddDevice(mockdev);
 
-// TODO{ALeshin} APPLINK-11090 - transport_adapter_->IsInitialised() doesn't return true as expected
-TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_Send_Message) {
-  SendHelper helper(TransportAdapter::OK);
-  {
-    ::testing::InSequence seq;
-
-    EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce(
-        Invoke(&helper, &SendHelper::sendMessage));
-    EXPECT_CALL(mock_dal_,
-        OnDataSendDone(transport_adapter_, _, _, helper.message_)).WillOnce(
-        InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp));
-  }
-
-  EXPECT_TRUE(client_.Connect(port()));
-  EXPECT_EQ("efgh", client_.receive(4));
-}
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(1u, devList.size());
+  EXPECT_EQ(uniq_id, devList[0]);
 
-TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_DisconnectFromClient) {
-  {
-    ::testing::InSequence seq;
+  const int app_handle = 1;
+  std::vector<int> intList = {app_handle};
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList));
 
-    EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _));
-    EXPECT_CALL(mock_dal_, OnUnexpectedDisconnect(transport_adapter_, _, _, _));
-    EXPECT_CALL(mock_dal_, OnDisconnectDone(transport_adapter_, _, _)).WillOnce(
-        InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp));
-  }
-  EXPECT_TRUE(client_.Connect(port()));
-  client_.Disconnect();
-}
+  ConnectionSPtr mock_connection = new ConnectionMock();
+  EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev));
+  EXPECT_CALL(transport_adapter, FindEstablishedConnection(uniq_id, app_handle))
+      .WillOnce(Return(mock_connection));
 
-TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_DisconnectFromServer) {
-  {
-    ::testing::InSequence seq;
+  EXPECT_CALL(*mockdev, GetApplicationPort(app_handle)).WillOnce(Return(port));
 
-    EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce(
-        Invoke(Disconnect));
-    EXPECT_CALL(mock_dal_, OnDisconnectDone(transport_adapter_, _, _)).WillOnce(
-        InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp));
-  }
-  EXPECT_TRUE(client_.Connect(port()));
+  transport_adapter.CallStore();
 
-}
+  EXPECT_CALL(transport_adapter, Connect(uniq_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
 
-TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_SendToDisconnected) {
-  SendHelper* helper = new SendHelper(TransportAdapter::BAD_PARAM);
-  {
-    ::testing::InSequence seq;
+  EXPECT_TRUE(transport_adapter.CallRestore());
 
-    EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce(
-        Invoke(Disconnect));
-    EXPECT_CALL(mock_dal_, OnDisconnectDone(transport_adapter_, _, _)).WillOnce(
-        ::testing::DoAll(Invoke(helper, &SendHelper::sendMessage),
-                         InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp)));
-  }
-  EXPECT_TRUE(client_.Connect(port()));
+  devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(1u, devList.size());
+  EXPECT_EQ(uniq_id, devList[0]);
 }
 
-TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_SendFailed) {
-//  static unsigned char zzz[2000000];  //message will send without fail because socket buffer can contain it
-  //this test works correctly starting with number 2539009
-  static unsigned char zzz[2600000];
-  SendHelper* helper = new SendHelper(TransportAdapter::OK);
-  helper->message_ = new RawMessage(1, 1, zzz, sizeof(zzz));
-  {
-    ::testing::InSequence seq;
-    EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce(
-        Invoke(helper, &SendHelper::sendMessage));
-    EXPECT_CALL(
-        mock_dal_,
-        OnDataSendFailed(transport_adapter_, _, _, helper->message_, _));
-    EXPECT_CALL(mock_dal_, OnDisconnectDone(transport_adapter_, _, _)).WillOnce(
-        InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp));
+TEST_F(TcpAdapterTest, DISABLED_StoreDataWithSeveralDevices_RestoreData) {
+  TestTCPTransportAdapter transport_adapter(port);
+  const uint32_t count_dev = 10;
+
+  utils::SharedPtr<TCPDeviceMock> mockdev[count_dev];
+  std::string uniq_id[count_dev];
+  for (uint32_t i = 0; i < count_dev; i++) {
+    char numb[12];
+    std::snprintf(numb, 12, "%d", i);
+    uniq_id[i] = "unique_device_name" + std::string(numb);
+    mockdev[i] = new TCPDeviceMock(port, uniq_id[i]);
+    EXPECT_CALL(*(mockdev[i]), IsSameAs(_)).WillRepeatedly(Return(false));
+    transport_adapter.AddDevice(mockdev[i]);
   }
-  EXPECT_TRUE(client_.Connect(port()));
-  client_.receive(2);
-  client_.Disconnect();
-}
 
-// TODO{ALeshin} APPLINK-11090 - transport_adapter_->IsInitialised() doesn't return true as expected
-TEST_F(TcpAdapterTest, DISABLED_StartStop) {
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(count_dev, devList.size());
+  EXPECT_EQ(uniq_id[0], devList[0]);
 
-  //assert
-  EXPECT_EQ(TransportAdapter::BAD_STATE,
-            transport_adapter_->StopClientListening());
-  EXPECT_TRUE(client_.Connect(port()));
-  EXPECT_EQ(TransportAdapter::OK, transport_adapter_->StartClientListening());
-  EXPECT_TRUE(client_.Connect(port()));
+  const int app_handle = 1;
+  std::vector<int> intList = {app_handle};
 
-  //act
-  client_.Disconnect();
+  ConnectionSPtr mock_connection = new ConnectionMock();
+  for (uint32_t i = 0; i < count_dev; i++) {
+    EXPECT_CALL(transport_adapter, FindDevice(uniq_id[i]))
+        .WillOnce(Return(mockdev[i]));
+    EXPECT_CALL(*(mockdev[i]), GetApplicationList()).WillOnce(Return(intList));
 
-  //assert
-  EXPECT_EQ(TransportAdapter::BAD_STATE,
-            transport_adapter_->StartClientListening());
-  EXPECT_TRUE(client_.Connect(port()));
+    EXPECT_CALL(transport_adapter,
+                FindEstablishedConnection(uniq_id[i], app_handle))
+        .WillOnce(Return(mock_connection));
 
-  //act
-  client_.Disconnect();
+    EXPECT_CALL(*(mockdev[i]), GetApplicationPort(app_handle))
+        .WillOnce(Return(port));
+  }
+  transport_adapter.CallStore();
 
-  //assert
-  EXPECT_EQ(TransportAdapter::OK, transport_adapter_->StopClientListening());
-  EXPECT_TRUE(client_.Connect(port()));
+  for (uint32_t i = 0; i < count_dev; i++) {
+    EXPECT_CALL(transport_adapter, Connect(uniq_id[i], app_handle))
+        .WillOnce(Return(TransportAdapter::OK));
+  }
 
-  //act
-  wakeUp();
-}
+  EXPECT_TRUE(transport_adapter.CallRestore());
 
-}  // namespace
-}  // namespace
+  devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(count_dev, devList.size());
+  for (uint32_t i = 0; i < count_dev; i++) {
+    EXPECT_EQ(uniq_id[i], devList[i]);
+  }
+}
 
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/transport_manager/test/transport_adapter_listener_test.cc b/src/components/transport_manager/test/transport_adapter_listener_test.cc
new file mode 100644
index 0000000000..4d0ff4ec20
--- /dev/null
+++ b/src/components/transport_manager/test/transport_adapter_listener_test.cc
@@ -0,0 +1,224 @@
+/*
+ * 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 "include/transport_adapter_mock.h"
+#include "transport_manager/transport_adapter/transport_adapter_listener_impl.h"
+#include "include/transport_manager_mock.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+using ::testing::Return;
+using namespace ::transport_manager;
+
+class TransportAdapterListenerTest : public ::testing::Test {
+ public:
+  TransportAdapterListenerTest()
+      : app_handle(1),
+        dev_id("device_id"),
+        transport_listener(&tr_mock, &adapter_mock) {}
+
+ protected:
+  const int app_handle;
+  const std::string dev_id;
+  TransportManagerMock tr_mock;
+  TransportAdapterMock adapter_mock;
+  TransportAdapterListenerImpl transport_listener;
+};
+
+MATCHER_P4(IsEvent, eventType, adapter, dev_id, app_id, "") {
+  TransportAdapterEvent event = arg;
+  return event.application_id == app_id && event.device_uid == dev_id &&
+         event.event_type == eventType && event.transport_adapter == adapter;
+}
+
+MATCHER_P5(IsEvent, eventType, adapter, dev_id, app_id, data, "") {
+  TransportAdapterEvent event = arg;
+  return event.application_id == app_id && event.device_uid == dev_id &&
+         event.event_type == eventType && event.transport_adapter == adapter &&
+         event.event_data == data;
+}
+
+TEST_F(TransportAdapterListenerTest, OnCommunicationError) {
+  EXPECT_CALL(
+      tr_mock,
+      ReceiveEventFromDevice(IsEvent(
+          TransportAdapterListenerImpl::EventTypeEnum::ON_COMMUNICATION_ERROR,
+          &adapter_mock, dev_id, app_handle))).WillOnce(Return(E_SUCCESS));
+  transport_listener.OnCommunicationError(&adapter_mock, dev_id, app_handle);
+}
+
+TEST_F(TransportAdapterListenerTest, OnConnectDone) {
+  EXPECT_CALL(tr_mock,
+              ReceiveEventFromDevice(IsEvent(
+                  TransportAdapterListenerImpl::EventTypeEnum::ON_CONNECT_DONE,
+                  &adapter_mock, dev_id, app_handle)))
+      .WillOnce(Return(E_SUCCESS));
+  transport_listener.OnConnectDone(&adapter_mock, dev_id, app_handle);
+}
+
+TEST_F(TransportAdapterListenerTest, OnConnectFailed) {
+  ConnectError er;
+
+  EXPECT_CALL(tr_mock,
+              ReceiveEventFromDevice(IsEvent(
+                  TransportAdapterListenerImpl::EventTypeEnum::ON_CONNECT_FAIL,
+                  &adapter_mock, dev_id, app_handle)))
+      .WillOnce(Return(E_SUCCESS));
+  transport_listener.OnConnectFailed(&adapter_mock, dev_id, app_handle, er);
+}
+
+TEST_F(TransportAdapterListenerTest, OnDataReceiveDone) {
+  ::protocol_handler::RawMessagePtr data_container;
+
+  EXPECT_CALL(tr_mock,
+              ReceiveEventFromDevice(IsEvent(
+                  TransportAdapterListenerImpl::EventTypeEnum::ON_RECEIVED_DONE,
+                  &adapter_mock, dev_id, app_handle, data_container)))
+      .WillOnce(Return(E_SUCCESS));
+  transport_listener.OnDataReceiveDone(&adapter_mock, dev_id, app_handle,
+                                       data_container);
+}
+
+TEST_F(TransportAdapterListenerTest, OnDataReceiveFailed) {
+  DataReceiveError err;
+
+  EXPECT_CALL(tr_mock,
+              ReceiveEventFromDevice(IsEvent(
+                  TransportAdapterListenerImpl::EventTypeEnum::ON_RECEIVED_FAIL,
+                  &adapter_mock, dev_id, app_handle)))
+      .WillOnce(Return(E_SUCCESS));
+  transport_listener.OnDataReceiveFailed(&adapter_mock, dev_id, app_handle,
+                                         err);
+}
+
+TEST_F(TransportAdapterListenerTest, OnDataSendDone) {
+  unsigned char data[3] = {0x20, 0x07, 0x01};
+  ::protocol_handler::RawMessagePtr data_container =
+      new ::protocol_handler::RawMessage(1, 1, data, 3);
+
+  EXPECT_CALL(tr_mock,
+              ReceiveEventFromDevice(IsEvent(
+                  TransportAdapterListenerImpl::EventTypeEnum::ON_SEND_DONE,
+                  &adapter_mock, dev_id, app_handle, data_container)))
+      .WillOnce(Return(E_SUCCESS));
+  transport_listener.OnDataSendDone(&adapter_mock, dev_id, app_handle,
+                                    data_container);
+}
+
+TEST_F(TransportAdapterListenerTest, OnDataSendFailed) {
+  unsigned char data[3] = {0x20, 0x07, 0x01};
+  ::protocol_handler::RawMessagePtr data_container =
+      new ::protocol_handler::RawMessage(1, 1, data, 3);
+  DataSendError err;
+
+  EXPECT_CALL(tr_mock,
+              ReceiveEventFromDevice(IsEvent(
+                  TransportAdapterListenerImpl::EventTypeEnum::ON_SEND_FAIL,
+                  &adapter_mock, dev_id, app_handle, data_container)))
+      .WillOnce(Return(E_SUCCESS));
+  transport_listener.OnDataSendFailed(&adapter_mock, dev_id, app_handle,
+                                      data_container, err);
+}
+
+TEST_F(TransportAdapterListenerTest, OnDeviceListUpdated) {
+  EXPECT_CALL(
+      tr_mock,
+      ReceiveEventFromDevice(IsEvent(
+          TransportAdapterListenerImpl::EventTypeEnum::ON_DEVICE_LIST_UPDATED,
+          &adapter_mock, "", 0))).WillOnce(Return(E_SUCCESS));
+  transport_listener.OnDeviceListUpdated(&adapter_mock);
+}
+
+TEST_F(TransportAdapterListenerTest, OnDisconnectDeviceDone) {
+  EXPECT_CALL(
+      tr_mock,
+      ReceiveEventFromDevice(IsEvent(
+          TransportAdapterListenerImpl::EventTypeEnum::ON_DISCONNECT_DONE,
+          &adapter_mock, dev_id, app_handle))).WillOnce(Return(E_SUCCESS));
+  transport_listener.OnDisconnectDone(&adapter_mock, dev_id, app_handle);
+}
+
+TEST_F(TransportAdapterListenerTest, OnDisconnectFailed) {
+  DisconnectError err;
+
+  EXPECT_CALL(
+      tr_mock,
+      ReceiveEventFromDevice(IsEvent(
+          TransportAdapterListenerImpl::EventTypeEnum::ON_DISCONNECT_FAIL,
+          &adapter_mock, dev_id, app_handle))).WillOnce(Return(E_SUCCESS));
+  transport_listener.OnDisconnectFailed(&adapter_mock, dev_id, app_handle, err);
+}
+
+TEST_F(TransportAdapterListenerTest, OnFindNewApplicationsRequest) {
+  EXPECT_CALL(tr_mock, ReceiveEventFromDevice(IsEvent(
+                           TransportAdapterListenerImpl::EventTypeEnum::
+                               ON_FIND_NEW_APPLICATIONS_REQUEST,
+                           &adapter_mock, "", 0))).WillOnce(Return(E_SUCCESS));
+  transport_listener.OnFindNewApplicationsRequest(&adapter_mock);
+}
+
+TEST_F(TransportAdapterListenerTest, OnSearchDeviceDone) {
+  EXPECT_CALL(tr_mock,
+              ReceiveEventFromDevice(IsEvent(
+                  TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_DONE,
+                  &adapter_mock, "", 0))).WillOnce(Return(E_SUCCESS));
+  transport_listener.OnSearchDeviceDone(&adapter_mock);
+}
+
+TEST_F(TransportAdapterListenerTest, OnSearchDeviceFailed) {
+  SearchDeviceError er;
+
+  EXPECT_CALL(tr_mock,
+              ReceiveEventFromDevice(IsEvent(
+                  TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_FAIL,
+                  &adapter_mock, "", 0))).WillOnce(Return(E_SUCCESS));
+  transport_listener.OnSearchDeviceFailed(&adapter_mock, er);
+}
+
+TEST_F(TransportAdapterListenerTest, OnUnexpectedDisconnect) {
+  CommunicationError err;
+
+  EXPECT_CALL(
+      tr_mock,
+      ReceiveEventFromDevice(IsEvent(
+          TransportAdapterListenerImpl::EventTypeEnum::ON_UNEXPECTED_DISCONNECT,
+          &adapter_mock, dev_id, app_handle))).WillOnce(Return(E_SUCCESS));
+  transport_listener.OnUnexpectedDisconnect(&adapter_mock, dev_id, app_handle,
+                                            err);
+}
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/transport_manager/test/transport_adapter_test.cc b/src/components/transport_manager/test/transport_adapter_test.cc
new file mode 100644
index 0000000000..679cd90643
--- /dev/null
+++ b/src/components/transport_manager/test/transport_adapter_test.cc
@@ -0,0 +1,743 @@
+/*
+ * 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 "include/device_scanner_mock.h"
+#include "include/client_connection_listener_mock.h"
+#include "include/server_connection_factory_mock.h"
+#include "include/device_mock.h"
+#include "include/connection_mock.h"
+#include "include/transport_adapter_listener_mock.h"
+
+#include "transport_manager/transport_adapter/transport_adapter_impl.h"
+#include "transport_manager/transport_adapter/transport_adapter_listener.h"
+#include "transport_manager/transport_adapter/transport_adapter_controller.h"
+#include "transport_manager/transport_adapter/connection.h"
+#include "config_profile/profile.h"
+#include "protocol/raw_message.h"
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+using ::testing::Return;
+using ::testing::_;
+
+using namespace ::transport_manager;
+using namespace ::protocol_handler;
+
+
+class TestTransportAdapter : public TransportAdapterImpl {
+ public:
+  TestTransportAdapter(DeviceScanner* device_scanner,
+                       ServerConnectionFactory* server_connection_factory,
+                       ClientConnectionListener* client_connection_listener)
+      : TransportAdapterImpl(device_scanner, server_connection_factory,
+                             client_connection_listener) {
+  }
+
+  ConnectionSPtr FindStatedConnection(const DeviceUID& device_handle,
+                                        const ApplicationHandle& app_handle) {
+    return this->FindEstablishedConnection(device_handle, app_handle);
+  }
+  virtual ~TestTransportAdapter(){};
+
+  virtual DeviceType GetDeviceType() const { return UNKNOWN; }
+
+  MOCK_CONST_METHOD0(Store, void());
+  MOCK_METHOD0(Restore, bool());
+};
+
+class TransportAdapterTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    dev_id = "device_id";
+    uniq_id = "unique_device_id";
+    app_handle = 1;
+  }
+
+  static void SetUpTestCase() {
+    ::profile::Profile::instance()->config_file_name(
+        "smartDeviceLink_test.ini");
+  }
+
+  std::string dev_id;
+  std::string uniq_id;
+  int app_handle;
+};
+
+TEST_F(TransportAdapterTest, Init) {
+  DeviceScannerMock* dev_mock = new DeviceScannerMock();
+  ClientConnectionListenerMock* clientMock = new ClientConnectionListenerMock();
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(dev_mock, serverMock, clientMock);
+
+  EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  EXPECT_EQ(TransportAdapter::OK, transport_adapter.Init());
+
+  // Expect terminate because at the end of test transport_adapter will be
+  // destroyed. That will call Terminate() for connections and device scanner.
+  EXPECT_CALL(*dev_mock, Terminate());
+  EXPECT_CALL(*clientMock, Terminate());
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, SearchDevices_WithoutScanner) {
+  ClientConnectionListenerMock* clientMock = new ClientConnectionListenerMock();
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, clientMock);
+
+  EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  EXPECT_EQ(TransportAdapter::OK, transport_adapter.Init());
+
+  EXPECT_EQ(TransportAdapter::NOT_SUPPORTED, transport_adapter.SearchDevices());
+
+  EXPECT_CALL(*clientMock, Terminate());
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, SearchDevices_DeviceNotInitialized) {
+  DeviceScannerMock* dev_mock = new DeviceScannerMock();
+  TestTransportAdapter transport_adapter(dev_mock, NULL, NULL);
+
+  EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  EXPECT_CALL(*dev_mock, IsInitialised()).WillRepeatedly(Return(false));
+  EXPECT_CALL(*dev_mock, Scan()).Times(0);
+  EXPECT_EQ(TransportAdapter::BAD_STATE, transport_adapter.SearchDevices());
+  EXPECT_CALL(*dev_mock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, SearchDevices_DeviceInitialized) {
+  DeviceScannerMock* dev_mock = new DeviceScannerMock();
+  TestTransportAdapter transport_adapter(dev_mock, NULL, NULL);
+
+  EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  EXPECT_CALL(*dev_mock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*dev_mock, Scan()).WillRepeatedly(Return(TransportAdapter::OK));
+  EXPECT_EQ(TransportAdapter::OK, transport_adapter.SearchDevices());
+
+  EXPECT_CALL(*dev_mock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, SearchDeviceDone_DeviceExisting) {
+  TestTransportAdapter transport_adapter(NULL, NULL, NULL);
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+
+  utils::SharedPtr<DeviceMock> mockdev = new DeviceMock(dev_id, uniq_id);
+  transport_adapter.AddDevice(mockdev);
+
+  std::vector<utils::SharedPtr<Device>> devList;
+  devList.push_back(mockdev);
+
+  EXPECT_CALL(*mockdev, IsSameAs(_)).WillOnce(Return(true));
+  transport_adapter.SearchDeviceDone(devList);
+}
+
+TEST_F(TransportAdapterTest, SearchDeviceFailed) {
+  TestTransportAdapter transport_adapter(NULL, NULL, NULL);
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  TransportAdapterListenerMock mock_listener;
+  transport_adapter.AddListener(&mock_listener);
+
+  SearchDeviceError er;
+  EXPECT_CALL(mock_listener, OnSearchDeviceFailed(_, _));
+  transport_adapter.SearchDeviceFailed(er);
+}
+
+TEST_F(TransportAdapterTest, AddDevice) {
+  TestTransportAdapter transport_adapter(NULL, NULL, NULL);
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+
+
+  TransportAdapterListenerMock mock_listener;
+  transport_adapter.AddListener(&mock_listener);
+
+  DeviceMock* mockdev = new DeviceMock(dev_id, uniq_id);
+
+  EXPECT_CALL(mock_listener, OnDeviceListUpdated(_));
+  transport_adapter.AddDevice(mockdev);
+}
+
+TEST_F(TransportAdapterTest, Connect_ServerNotSupported) {
+  ClientConnectionListenerMock* clientMock = new ClientConnectionListenerMock();
+  TestTransportAdapter transport_adapter(NULL, NULL, clientMock);
+
+  EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  int app_handle = 1;
+
+  TransportAdapter::Error res = transport_adapter.Connect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::NOT_SUPPORTED, res);
+
+  EXPECT_CALL(*clientMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, Connect_ServerNotInitialized) {
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, NULL);
+
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(false));
+  EXPECT_CALL(*serverMock, CreateConnection(dev_id, app_handle)).Times(0);
+  TransportAdapter::Error res = transport_adapter.Connect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::BAD_STATE, res);
+
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, Connect_Success) {
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, NULL);
+
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(dev_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.Connect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, Connect_DeviceAddedTwice) {
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, NULL);
+
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(dev_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.Connect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  TransportAdapter::Error newres =
+      transport_adapter.Connect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::ALREADY_EXISTS, newres);
+
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, ConnectDevice_ServerNotAdded_DeviceAdded) {
+  TestTransportAdapter transport_adapter(NULL, NULL, NULL);
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+
+
+  DeviceMock* mockdev = new DeviceMock(dev_id, uniq_id);
+  transport_adapter.AddDevice(mockdev);
+
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(1u, devList.size());
+  EXPECT_EQ(uniq_id, devList[0]);
+
+  int app_handle = 1;
+  std::vector<int> intList = {app_handle};
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList));
+
+  TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id);
+  EXPECT_EQ(TransportAdapter::FAIL, res);
+}
+
+TEST_F(TransportAdapterTest, ConnectDevice_DeviceNotAdded) {
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, NULL);
+
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  std::string uniq_id = "unique_device_id";
+
+  EXPECT_CALL(*serverMock, IsInitialised()).Times(0);
+  EXPECT_CALL(*serverMock, CreateConnection(_, _)).Times(0);
+  TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id);
+  EXPECT_EQ(TransportAdapter::BAD_PARAM, res);
+
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, ConnectDevice_DeviceAdded) {
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, NULL);
+
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+
+
+  DeviceMock* mockdev = new DeviceMock(dev_id, uniq_id);
+  transport_adapter.AddDevice(mockdev);
+
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(1u, devList.size());
+  EXPECT_EQ(uniq_id, devList[0]);
+
+
+  int app_handle = 1;
+  std::vector<int> intList = {app_handle};
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList));
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(uniq_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, ConnectDevice_DeviceAddedTwice) {
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, NULL);
+
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+
+
+  DeviceMock* mockdev = new DeviceMock(dev_id, uniq_id);
+  transport_adapter.AddDevice(mockdev);
+
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(1u, devList.size());
+  EXPECT_EQ(uniq_id, devList[0]);
+
+
+  int app_handle = 1;
+  std::vector<int> intList = {app_handle};
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList));
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(uniq_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  // Try to connect device second time
+
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList));
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(uniq_id, app_handle)).Times(0);
+  TransportAdapter::Error newres = transport_adapter.ConnectDevice(uniq_id);
+  EXPECT_EQ(TransportAdapter::OK, newres);
+
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, Disconnect_ConnectDoneSuccess) {
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, NULL);
+
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(dev_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.Connect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  ConnectionMock* mock_connection = new ConnectionMock();
+  transport_adapter.ConnectionCreated(mock_connection, dev_id, app_handle);
+
+  EXPECT_CALL(transport_adapter, Store());
+  transport_adapter.ConnectDone(dev_id, app_handle);
+
+  EXPECT_CALL(*mock_connection, Disconnect())
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error new_res =
+      transport_adapter.Disconnect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::OK, new_res);
+
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, DisconnectDevice_DeviceAddedConnectionCreated) {
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, NULL);
+
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  DeviceMock* mockdev = new DeviceMock(dev_id, uniq_id);
+  transport_adapter.AddDevice(mockdev);
+
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(1u, devList.size());
+  EXPECT_EQ(uniq_id, devList[0]);
+
+
+  std::vector<int> intList = {app_handle};
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList));
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(uniq_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  ConnectionMock* mock_connection = new ConnectionMock();
+  transport_adapter.ConnectionCreated(mock_connection, uniq_id, app_handle);
+
+  EXPECT_CALL(*mock_connection, Disconnect())
+      .WillOnce(Return(TransportAdapter::OK));
+
+  TransportAdapter::Error new_res = transport_adapter.DisconnectDevice(uniq_id);
+  EXPECT_EQ(TransportAdapter::OK, new_res);
+
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, DeviceDisconnected) {
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, NULL);
+
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  TransportAdapterListenerMock mock_listener;
+  transport_adapter.AddListener(&mock_listener);
+
+  DeviceMock* mockdev = new DeviceMock(dev_id, uniq_id);
+  EXPECT_CALL(mock_listener, OnDeviceListUpdated(_));
+  transport_adapter.AddDevice(mockdev);
+
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(1u, devList.size());
+  EXPECT_EQ(uniq_id, devList[0]);
+
+  std::vector<int> intList = {app_handle};
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList));
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(uniq_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  ConnectionMock* mock_connection = new ConnectionMock();
+  transport_adapter.ConnectionCreated(mock_connection, uniq_id, app_handle);
+
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList));
+  EXPECT_CALL(mock_listener, OnUnexpectedDisconnect(&transport_adapter, uniq_id,
+                                                    app_handle, _));
+  EXPECT_CALL(mock_listener,
+              OnDisconnectDeviceDone(&transport_adapter, uniq_id));
+  EXPECT_CALL(mock_listener, OnDeviceListUpdated(&transport_adapter));
+  DisconnectDeviceError error;
+  transport_adapter.DeviceDisconnected(uniq_id, error);
+
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, AbortedConnectSuccess) {
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, NULL);
+
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(dev_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.Connect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  TransportAdapterListenerMock mock_listener;
+  transport_adapter.AddListener(&mock_listener);
+
+  CommunicationError ce;
+  EXPECT_CALL(mock_listener, OnUnexpectedDisconnect(_, dev_id, app_handle, _));
+  transport_adapter.ConnectionAborted(dev_id, app_handle, ce);
+
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, SendData) {
+  DeviceScannerMock* dev_mock = new DeviceScannerMock();
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(dev_mock, serverMock, NULL);
+
+  EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(dev_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.Connect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  ConnectionMock* mock_connection = new ConnectionMock();
+  transport_adapter.ConnectionCreated(mock_connection, dev_id, app_handle);
+
+  EXPECT_CALL(transport_adapter, Store());
+  transport_adapter.ConnectDone(dev_id, app_handle);
+
+  const unsigned int kSize = 3;
+  unsigned char data[kSize] = {0x20, 0x07, 0x01};
+  const RawMessagePtr kMessage = new RawMessage(1, 1, data, kSize);
+
+  EXPECT_CALL(*mock_connection, SendData(kMessage))
+      .WillOnce(Return(TransportAdapter::OK));
+  res = transport_adapter.SendData(dev_id, app_handle, kMessage);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  EXPECT_CALL(*dev_mock, Terminate());
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, SendData_ConnectionNotEstablished) {
+  DeviceScannerMock* dev_mock = new DeviceScannerMock();
+  ClientConnectionListenerMock* clientMock = new ClientConnectionListenerMock();
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(dev_mock, serverMock, clientMock);
+
+  EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(dev_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.Connect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  ConnectionMock* mock_connection = new ConnectionMock();
+  transport_adapter.ConnectionCreated(mock_connection, dev_id, app_handle);
+
+  const unsigned int kSize = 3;
+  unsigned char data[kSize] = {0x20, 0x07, 0x01};
+  const RawMessagePtr kMessage = new RawMessage(1, 1, data, kSize);
+
+  EXPECT_CALL(*mock_connection, SendData(kMessage)).Times(0);
+  res = transport_adapter.SendData(dev_id, app_handle, kMessage);
+  EXPECT_EQ(TransportAdapter::BAD_PARAM, res);
+
+  EXPECT_CALL(*dev_mock, Terminate());
+  EXPECT_CALL(*clientMock, Terminate());
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, StartClientListening_ClientNotInitialized) {
+  DeviceScannerMock* dev_mock = new DeviceScannerMock();
+  ClientConnectionListenerMock* clientMock = new ClientConnectionListenerMock();
+  TestTransportAdapter transport_adapter(dev_mock, NULL, clientMock);
+
+  EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  EXPECT_CALL(*clientMock, IsInitialised()).WillOnce(Return(false));
+  EXPECT_CALL(*clientMock, StartListening()).Times(0);
+
+  TransportAdapter::Error res = transport_adapter.StartClientListening();
+  EXPECT_EQ(TransportAdapter::BAD_STATE, res);
+
+  EXPECT_CALL(*dev_mock, Terminate());
+  EXPECT_CALL(*clientMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, StartClientListening) {
+  DeviceScannerMock* dev_mock = new DeviceScannerMock();
+  ClientConnectionListenerMock* clientMock = new ClientConnectionListenerMock();
+  TestTransportAdapter transport_adapter(dev_mock, NULL, clientMock);
+
+  EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  EXPECT_CALL(*clientMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*clientMock, StartListening())
+      .WillOnce(Return(TransportAdapter::OK));
+
+  TransportAdapter::Error res = transport_adapter.StartClientListening();
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  EXPECT_CALL(*dev_mock, Terminate());
+  EXPECT_CALL(*clientMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, StopClientListening_Success) {
+  DeviceScannerMock* dev_mock = new DeviceScannerMock();
+  ClientConnectionListenerMock* clientMock = new ClientConnectionListenerMock();
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(dev_mock, serverMock, clientMock);
+
+  EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(dev_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.Connect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  EXPECT_CALL(*clientMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*clientMock, StopListening())
+      .WillOnce(Return(TransportAdapter::OK));
+
+  res = transport_adapter.StopClientListening();
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  EXPECT_CALL(*dev_mock, Terminate());
+  EXPECT_CALL(*clientMock, Terminate());
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, FindNewApplicationsRequest) {
+  DeviceScannerMock* dev_mock = new DeviceScannerMock();
+  ClientConnectionListenerMock* clientMock = new ClientConnectionListenerMock();
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(dev_mock, serverMock, clientMock);
+
+  EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  TransportAdapterListenerMock mock_listener;
+  transport_adapter.AddListener(&mock_listener);
+
+  EXPECT_CALL(mock_listener, OnFindNewApplicationsRequest(&transport_adapter));
+  transport_adapter.FindNewApplicationsRequest();
+
+  EXPECT_CALL(*dev_mock, Terminate());
+  EXPECT_CALL(*clientMock, Terminate());
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+TEST_F(TransportAdapterTest, GetDeviceAndApplicationLists) {
+  TestTransportAdapter transport_adapter(NULL, NULL, NULL);
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  DeviceMock* mockdev = new DeviceMock(dev_id, uniq_id);
+  transport_adapter.AddDevice(mockdev);
+
+  std::vector<std::string> devList = transport_adapter.GetDeviceList();
+  ASSERT_EQ(1u, devList.size());
+  EXPECT_EQ(uniq_id, devList[0]);
+
+  int app_handle = 1;
+  std::vector<int> intList = {app_handle};
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList));
+  std::vector<int> res = transport_adapter.GetApplicationList(uniq_id);
+  ASSERT_EQ(1u, res.size());
+  EXPECT_EQ(intList[0], res[0]);
+
+}
+
+TEST_F(TransportAdapterTest, FindEstablishedConnection) {
+  ServerConnectionFactoryMock* serverMock = new ServerConnectionFactoryMock();
+  TestTransportAdapter transport_adapter(NULL, serverMock, NULL);
+
+  EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*serverMock, CreateConnection(dev_id, app_handle))
+      .WillOnce(Return(TransportAdapter::OK));
+  TransportAdapter::Error res = transport_adapter.Connect(dev_id, app_handle);
+  EXPECT_EQ(TransportAdapter::OK, res);
+
+  ConnectionSPtr mock_connection = new ConnectionMock();
+  transport_adapter.ConnectionCreated(mock_connection, dev_id, app_handle);
+
+  EXPECT_CALL(transport_adapter, Store());
+  transport_adapter.ConnectDone(dev_id, app_handle);
+
+  ConnectionSPtr conn =
+      transport_adapter.FindStatedConnection(dev_id, app_handle);
+  EXPECT_EQ(mock_connection, conn);
+
+  EXPECT_CALL(*serverMock, Terminate());
+}
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/transport_manager/test/transport_manager_default_test.cc b/src/components/transport_manager/test/transport_manager_default_test.cc
new file mode 100644
index 0000000000..4e0bd94845
--- /dev/null
+++ b/src/components/transport_manager/test/transport_manager_default_test.cc
@@ -0,0 +1,46 @@
+/*
+ * 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 "transport_manager/transport_manager.h"
+#include "transport_manager/transport_manager_default.h"
+
+namespace test {
+namespace test_transport_manager_instance {
+TEST(TestTransportManagerDefault, CreateOnlyInstance) {
+  transport_manager::TransportManager* instance =
+      transport_manager::TransportManagerDefault::instance();
+  ASSERT_EQ(instance, transport_manager::TransportManagerDefault::instance());
+  transport_manager::TransportManagerDefault::destroy();
+}
+
+}  // namespace test
+}  // namespace test_transport_manager_instance
diff --git a/src/components/transport_manager/test/transport_manager_impl_test.cc b/src/components/transport_manager/test/transport_manager_impl_test.cc
new file mode 100644
index 0000000000..8ee1d70887
--- /dev/null
+++ b/src/components/transport_manager/test/transport_manager_impl_test.cc
@@ -0,0 +1,717 @@
+/*
+ * 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 "protocol/raw_message.h"
+#include "transport_manager/common.h"
+#include "transport_manager/transport_manager_impl.h"
+
+#include "include/transport_adapter_mock.h"
+#include "include/transport_manager_listener_mock.h"
+#include "include/transport_adapter_listener_mock.h"
+#include "include/time_metric_observer_mock.h"
+
+#include "transport_manager/transport_adapter/transport_adapter_event.h"
+
+using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::Return;
+
+using ::protocol_handler::RawMessage;
+using ::protocol_handler::RawMessagePtr;
+
+namespace test {
+namespace components {
+namespace transport_manager_test {
+
+using namespace ::transport_manager;
+
+class TransportManagerTest : public TransportManagerImpl {
+ public:
+  void TestHandle(TransportAdapterEvent test_event) { Handle(test_event); }
+};
+
+class TransportManagerImplTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    tm.Init();
+    mock_adapter = new TransportAdapterMock();
+    tm_listener = new TransportManagerListenerMock();
+
+    EXPECT_EQ(E_SUCCESS, tm.AddEventListener(tm_listener));
+    EXPECT_CALL(*mock_adapter, AddListener(_));
+    EXPECT_CALL(*mock_adapter, IsInitialised()).WillOnce(Return(true));
+    EXPECT_EQ(::transport_manager::E_SUCCESS,
+              tm.AddTransportAdapter(mock_adapter));
+
+    device_handle_ = 1;
+    connection_key_ = 1;
+    mac_address_ = "MA:CA:DR:ES:S";
+    error_ = new BaseError();
+
+    const unsigned int version_protocol_ = 1;
+    const unsigned int kSize = 12;
+    unsigned char data[kSize] = {0x20, 0x07, 0x01, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+    test_message_ =
+        new RawMessage(connection_key_, version_protocol_, data, kSize);
+  }
+
+  virtual void TearDown() { delete tm_listener; }
+
+  void HandleDeviceListUpdated();
+  void HandleConnection();
+  void HandleSendDone();
+  void HandleSendFailed();
+  void HandleSearchDone();
+  void HandleSearchFail();
+  void HandleFindNewApplicationsRequest();
+  void HandleConnectionFailed();
+  void HandleConnectionClosed();
+  void HandleDisconnectionFailed();
+  void HandleReceiveDone();
+
+  TransportManagerTest tm;
+  TransportAdapterMock* mock_adapter;
+
+  TransportManagerListenerMock* tm_listener;
+
+  const ApplicationHandle application_id = 1;
+
+  // count of connections
+  ConnectionUID connection_key_;
+  RawMessagePtr test_message_;
+  DeviceHandle device_handle_;
+  std::string mac_address_;
+
+  DeviceList dev;
+  BaseErrorPtr error_;
+};
+
+void TransportManagerImplTest::HandleDeviceListUpdated() {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_DEVICE_LIST_UPDATED);
+  const DeviceInfo dev_info(device_handle_, mac_address_, "TestDeviceName",
+                            "BTMAC");
+
+  TransportAdapterEvent test_event(type, mock_adapter, dev_info.mac_address(),
+                                   application_id, test_message_, error_);
+  dev.push_back(dev_info.mac_address());
+  std::vector<DeviceInfo> vector_dev_info;
+  std::vector<DeviceInfo>::iterator it = vector_dev_info.begin();
+  vector_dev_info.insert(it, dev_info);
+
+  EXPECT_CALL(*mock_adapter, GetDeviceList())
+      .Times(AtLeast(1))
+      .WillRepeatedly(Return(dev));
+  EXPECT_CALL(*mock_adapter, DeviceName(dev_info.mac_address()))
+      .Times(AtLeast(1))
+      .WillRepeatedly(Return(dev_info.name()));
+  EXPECT_CALL(*mock_adapter, GetConnectionType())
+      .Times(AtLeast(1))
+      .WillRepeatedly(Return(dev_info.connection_type()));
+
+  EXPECT_CALL(*tm_listener, OnDeviceFound(dev_info));
+  EXPECT_CALL(*tm_listener, OnDeviceAdded(dev_info));
+  EXPECT_CALL(*tm_listener, OnDeviceListUpdated(vector_dev_info));
+
+  tm.TestHandle(test_event);
+  dev.pop_back();
+}
+
+void TransportManagerImplTest::HandleConnection() {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_CONNECT_DONE);
+  const DeviceInfo dev_info(device_handle_, mac_address_, "TestDeviceName",
+                            "BTMAC");
+
+  TransportAdapterEvent test_event(type, mock_adapter, dev_info.mac_address(),
+                                   application_id, test_message_, error_);
+
+  EXPECT_CALL(*mock_adapter, DeviceName(dev_info.mac_address()))
+      .WillOnce(Return(dev_info.name()));
+  EXPECT_CALL(*mock_adapter, GetConnectionType())
+      .WillOnce(Return(dev_info.connection_type()));
+
+  EXPECT_CALL(*tm_listener, OnConnectionEstablished(dev_info, connection_key_));
+
+  tm.TestHandle(test_event);
+}
+
+void TransportManagerImplTest::HandleConnectionFailed() {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_CONNECT_FAIL);
+
+  const DeviceInfo dev_info(device_handle_, mac_address_, "TestDeviceName",
+                            "BTMAC");
+
+  TransportAdapterEvent test_event(type, mock_adapter, dev_info.mac_address(),
+                                   application_id, test_message_, error_);
+
+  EXPECT_CALL(*mock_adapter, DeviceName(dev_info.mac_address()))
+      .WillOnce(Return(dev_info.name()));
+  EXPECT_CALL(*mock_adapter, GetConnectionType())
+      .WillOnce(Return(dev_info.connection_type()));
+
+  EXPECT_CALL(*tm_listener, OnConnectionFailed(dev_info, _));
+
+  tm.TestHandle(test_event);
+}
+
+void TransportManagerImplTest::HandleSendDone() {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_SEND_DONE);
+  TransportAdapterEvent test_event(type, mock_adapter, mac_address_,
+                                   application_id, test_message_, error_);
+
+  EXPECT_CALL(*tm_listener, OnTMMessageSend(test_message_));
+
+  tm.TestHandle(test_event);
+}
+
+void TransportManagerImplTest::HandleReceiveDone() {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_RECEIVED_DONE);
+  TransportAdapterEvent test_event(type, mock_adapter, mac_address_,
+                                   application_id, test_message_, error_);
+
+  EXPECT_CALL(*tm_listener, OnTMMessageReceived(test_message_));
+
+  tm.TestHandle(test_event);
+}
+
+void TransportManagerImplTest::HandleSendFailed() {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_SEND_FAIL);
+
+  TransportAdapterEvent test_event(type, mock_adapter, mac_address_,
+                                   application_id, test_message_, error_);
+
+  tm.TestHandle(test_event);
+}
+
+void TransportManagerImplTest::HandleSearchDone() {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_DONE);
+
+  TransportAdapterEvent test_event(type, mock_adapter, mac_address_,
+                                   application_id, test_message_, error_);
+
+  EXPECT_CALL(*tm_listener, OnScanDevicesFinished());
+
+  tm.TestHandle(test_event);
+}
+
+void TransportManagerImplTest::HandleSearchFail() {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_FAIL);
+
+  TransportAdapterEvent test_event(type, mock_adapter, mac_address_,
+                                   application_id, test_message_, error_);
+
+  EXPECT_CALL(*tm_listener, OnScanDevicesFailed(_));
+
+  tm.TestHandle(test_event);
+}
+
+void TransportManagerImplTest::HandleFindNewApplicationsRequest() {
+  int type = static_cast<int>(TransportAdapterListenerImpl::EventTypeEnum::
+                                  ON_FIND_NEW_APPLICATIONS_REQUEST);
+
+  TransportAdapterEvent test_event(type, mock_adapter, mac_address_,
+                                   application_id, test_message_, error_);
+
+  EXPECT_CALL(*tm_listener, OnFindNewApplicationsRequest());
+
+  tm.TestHandle(test_event);
+}
+
+void TransportManagerImplTest::HandleConnectionClosed() {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_DISCONNECT_DONE);
+
+  TransportAdapterEvent test_event(type, mock_adapter, mac_address_,
+                                   application_id, test_message_, error_);
+
+  EXPECT_CALL(*tm_listener, OnConnectionClosed(application_id));
+
+  tm.TestHandle(test_event);
+}
+
+void TransportManagerImplTest::HandleDisconnectionFailed() {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_DISCONNECT_FAIL);
+
+  TransportAdapterEvent test_event(type, mock_adapter, mac_address_,
+                                   application_id, test_message_, error_);
+
+  EXPECT_CALL(*tm_listener, OnDisconnectFailed(device_handle_, _));
+
+  tm.TestHandle(test_event);
+}
+
+TEST(TransportManagerTest, SearchDevices_AdaptersNotAdded) {
+  TransportManagerTest tm;
+  tm.Init();
+
+  EXPECT_EQ(E_SUCCESS, tm.SearchDevices());
+}
+
+TEST(TransportManagerTest, AddTransportAdapter) {
+  TransportManagerTest tm;
+  tm.Init();
+
+  TransportAdapterMock* mock_adapter = new TransportAdapterMock();
+  TransportManagerListenerMock* tm_listener =
+      new TransportManagerListenerMock();
+
+  EXPECT_EQ(E_SUCCESS, tm.AddEventListener(tm_listener));
+  EXPECT_CALL(*mock_adapter, AddListener(_));
+  EXPECT_CALL(*mock_adapter, IsInitialised()).WillOnce(Return(false));
+  EXPECT_CALL(*mock_adapter, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_EQ(::transport_manager::E_SUCCESS,
+            tm.AddTransportAdapter(mock_adapter));
+}
+
+TEST_F(TransportManagerImplTest, AddTransportAdapterSecondTime) {
+  EXPECT_EQ(E_ADAPTER_EXISTS, tm.AddTransportAdapter(mock_adapter));
+}
+
+TEST_F(TransportManagerImplTest, ConnectDevice) {
+  HandleDeviceListUpdated();
+  EXPECT_CALL(*mock_adapter, ConnectDevice(mac_address_))
+      .WillOnce(Return(TransportAdapter::OK));
+  EXPECT_EQ(E_SUCCESS, tm.ConnectDevice(device_handle_));
+}
+
+TEST_F(TransportManagerImplTest, ConnectDevice_DeviceNotHandled) {
+  EXPECT_CALL(*mock_adapter, ConnectDevice(mac_address_)).Times(0);
+  EXPECT_EQ(E_INVALID_HANDLE, tm.ConnectDevice(device_handle_));
+}
+
+TEST_F(TransportManagerImplTest, ConnectDevice_DeviceNotConnected) {
+  HandleDeviceListUpdated();
+  EXPECT_CALL(*mock_adapter, ConnectDevice(mac_address_))
+      .WillOnce(Return(TransportAdapter::FAIL));
+  EXPECT_EQ(E_INTERNAL_ERROR, tm.ConnectDevice(device_handle_));
+}
+
+TEST_F(TransportManagerImplTest, DisconnectDevice) {
+  HandleDeviceListUpdated();
+  EXPECT_CALL(*mock_adapter, ConnectDevice(mac_address_))
+      .WillOnce(Return(TransportAdapter::OK));
+  EXPECT_EQ(E_SUCCESS, tm.ConnectDevice(device_handle_));
+
+  EXPECT_CALL(*mock_adapter, DisconnectDevice(mac_address_))
+      .WillOnce(Return(TransportAdapter::OK));
+
+  EXPECT_EQ(E_SUCCESS, tm.DisconnectDevice(device_handle_));
+}
+
+TEST_F(TransportManagerImplTest, DisconnectDevice_ConnectionFailed) {
+  HandleDeviceListUpdated();
+  EXPECT_CALL(*mock_adapter, ConnectDevice(mac_address_))
+      .WillOnce(Return(TransportAdapter::FAIL));
+  EXPECT_EQ(E_INTERNAL_ERROR, tm.ConnectDevice(device_handle_));
+
+  EXPECT_CALL(*mock_adapter, DisconnectDevice(mac_address_))
+      .WillOnce(Return(TransportAdapter::FAIL));
+
+  EXPECT_EQ(E_INTERNAL_ERROR, tm.DisconnectDevice(device_handle_));
+}
+
+TEST_F(TransportManagerImplTest, DisconnectDevice_DeviceNotConnected) {
+  EXPECT_CALL(*mock_adapter, DisconnectDevice(mac_address_)).Times(0);
+  EXPECT_EQ(E_INVALID_HANDLE, tm.DisconnectDevice(device_handle_));
+}
+
+TEST_F(TransportManagerImplTest, Disconnect) {
+  // Arrange
+  HandleConnection();
+
+  EXPECT_CALL(*mock_adapter, Disconnect(mac_address_, application_id))
+      .WillOnce(Return(TransportAdapter::OK));
+  // Assert
+  EXPECT_EQ(E_SUCCESS, tm.Disconnect(connection_key_));
+}
+
+TEST_F(TransportManagerImplTest, Disconnect_DisconnectionFailed) {
+  // Arrange
+  HandleConnection();
+
+  EXPECT_CALL(*mock_adapter, Disconnect(mac_address_, application_id))
+      .WillOnce(Return(TransportAdapter::FAIL));
+  // Assert
+  EXPECT_EQ(E_INTERNAL_ERROR, tm.Disconnect(connection_key_));
+}
+
+TEST_F(TransportManagerImplTest, Disconnect_ConnectionNotExist) {
+  EXPECT_CALL(*mock_adapter, Disconnect(mac_address_, application_id)).Times(0);
+  // Assert
+  EXPECT_EQ(E_INVALID_HANDLE, tm.Disconnect(connection_key_));
+}
+
+TEST_F(TransportManagerImplTest, Disconnect_ConnectionDoesNotExists) {
+  // Arrange
+  HandleDeviceListUpdated();
+
+  EXPECT_CALL(*mock_adapter, ConnectDevice(mac_address_))
+      .WillRepeatedly(Return(TransportAdapter::OK));
+  EXPECT_EQ(E_SUCCESS, tm.ConnectDevice(device_handle_));
+
+  EXPECT_CALL(*mock_adapter, Disconnect(mac_address_, application_id))
+      .WillRepeatedly(Return(TransportAdapter::OK));
+  // Assert
+  EXPECT_EQ(E_INVALID_HANDLE, tm.Disconnect(connection_key_));
+}
+
+TEST_F(TransportManagerImplTest, DisconnectForce) {
+  // Arrange
+  HandleConnection();
+
+  EXPECT_CALL(*mock_adapter, Disconnect(mac_address_, application_id))
+      .WillRepeatedly(Return(TransportAdapter::OK));
+  // Assert
+  EXPECT_EQ(E_SUCCESS, tm.DisconnectForce(connection_key_));
+}
+
+TEST_F(TransportManagerImplTest, DisconnectForce_) {
+  // Arrange
+  HandleConnection();
+
+  EXPECT_CALL(*mock_adapter, Disconnect(mac_address_, application_id))
+      .WillRepeatedly(Return(TransportAdapter::OK));
+  // Assert
+  EXPECT_EQ(E_SUCCESS, tm.DisconnectForce(connection_key_));
+}
+
+TEST_F(TransportManagerImplTest, SearchDevices_DeviceConnected) {
+  HandleDeviceListUpdated();
+
+  EXPECT_CALL(*mock_adapter, SearchDevices())
+      .WillOnce(Return(TransportAdapter::OK));
+  EXPECT_EQ(E_SUCCESS, tm.SearchDevices());
+
+  HandleSearchDone();
+}
+
+TEST_F(TransportManagerImplTest, SearchDevices_DeviceNotFound) {
+  HandleDeviceListUpdated();
+
+  EXPECT_CALL(*mock_adapter, SearchDevices())
+      .WillOnce(Return(TransportAdapter::FAIL));
+  EXPECT_EQ(E_ADAPTERS_FAIL, tm.SearchDevices());
+}
+
+TEST_F(TransportManagerImplTest, SearchDevices_AdapterNotSupported) {
+  HandleDeviceListUpdated();
+
+  EXPECT_CALL(*mock_adapter, SearchDevices())
+      .WillOnce(Return(TransportAdapter::NOT_SUPPORTED));
+  EXPECT_EQ(E_ADAPTERS_FAIL, tm.SearchDevices());
+}
+
+TEST_F(TransportManagerImplTest, SearchDevices_AdapterWithBadState) {
+  HandleDeviceListUpdated();
+
+  EXPECT_CALL(*mock_adapter, SearchDevices())
+      .WillOnce(Return(TransportAdapter::BAD_STATE));
+  EXPECT_EQ(E_ADAPTERS_FAIL, tm.SearchDevices());
+}
+
+TEST_F(TransportManagerImplTest, SendMessageToDevice) {
+  // Arrange
+  HandleConnection();
+
+  EXPECT_CALL(*mock_adapter,
+              SendData(mac_address_, application_id, test_message_))
+      .WillOnce(Return(TransportAdapter::OK));
+
+  EXPECT_EQ(E_SUCCESS, tm.SendMessageToDevice(test_message_));
+  testing::Mock::AsyncVerifyAndClearExpectations(10000);
+}
+
+TEST_F(TransportManagerImplTest, SendMessageToDevice_SendingFailed) {
+  // Arrange
+  HandleConnection();
+
+  TMMetricObserverMock* mock_metric_observer = new TMMetricObserverMock();
+  tm.SetTimeMetricObserver(mock_metric_observer);
+  EXPECT_CALL(*mock_metric_observer, StartRawMsg(_));
+
+  EXPECT_CALL(*mock_adapter,
+              SendData(mac_address_, application_id, test_message_))
+      .WillOnce(Return(TransportAdapter::FAIL));
+
+  EXPECT_CALL(*tm_listener, OnTMMessageSendFailed(_, test_message_));
+  EXPECT_EQ(E_SUCCESS, tm.SendMessageToDevice(test_message_));
+
+  EXPECT_CALL(*mock_metric_observer, StopRawMsg(_)).Times(0);
+
+  delete mock_metric_observer;
+  testing::Mock::AsyncVerifyAndClearExpectations(10000);
+}
+
+TEST_F(TransportManagerImplTest, SendMessageToDevice_StartTimeObserver) {
+  // Arrange
+  HandleConnection();
+
+  TMMetricObserverMock* mock_metric_observer = new TMMetricObserverMock();
+  tm.SetTimeMetricObserver(mock_metric_observer);
+  EXPECT_CALL(*mock_adapter,
+              SendData(mac_address_, application_id, test_message_))
+      .WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*mock_metric_observer, StartRawMsg(_));
+
+  EXPECT_EQ(E_SUCCESS, tm.SendMessageToDevice(test_message_));
+  delete mock_metric_observer;
+  testing::Mock::AsyncVerifyAndClearExpectations(10000);
+}
+
+TEST_F(TransportManagerImplTest, SendMessageToDevice_SendDone) {
+  // Arrange
+  HandleConnection();
+
+  TMMetricObserverMock* mock_metric_observer = new TMMetricObserverMock();
+  tm.SetTimeMetricObserver(mock_metric_observer);
+  EXPECT_CALL(*mock_adapter,
+              SendData(mac_address_, application_id, test_message_))
+      .WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(*mock_metric_observer, StartRawMsg(_));
+
+  EXPECT_EQ(E_SUCCESS, tm.SendMessageToDevice(test_message_));
+
+  EXPECT_CALL(*mock_metric_observer, StopRawMsg(_));
+  HandleSendDone();
+
+  delete mock_metric_observer;
+  testing::Mock::AsyncVerifyAndClearExpectations(10000);
+}
+
+TEST_F(TransportManagerImplTest, SendMessageFailed_GetHandleSendFailed) {
+  // Arrange
+  HandleConnection();
+
+  TMMetricObserverMock* mock_metric_observer = new TMMetricObserverMock();
+  tm.SetTimeMetricObserver(mock_metric_observer);
+  EXPECT_CALL(*mock_metric_observer, StartRawMsg(_));
+
+  EXPECT_CALL(*mock_adapter,
+              SendData(mac_address_, application_id, test_message_))
+      .WillOnce(Return(TransportAdapter::FAIL));
+
+  EXPECT_CALL(*tm_listener, OnTMMessageSendFailed(_, test_message_));
+  EXPECT_EQ(E_SUCCESS, tm.SendMessageToDevice(test_message_));
+
+  EXPECT_CALL(*mock_metric_observer, StopRawMsg(_));
+
+  HandleSendFailed();
+  delete mock_metric_observer;
+  testing::Mock::AsyncVerifyAndClearExpectations(10000);
+}
+
+TEST_F(TransportManagerImplTest, RemoveDevice_DeviceWasAdded) {
+  // Arrange
+  HandleDeviceListUpdated();
+  EXPECT_CALL(*mock_adapter, ConnectDevice(mac_address_))
+      .WillOnce(Return(TransportAdapter::OK));
+  EXPECT_EQ(E_SUCCESS, tm.ConnectDevice(device_handle_));
+
+  // Assert
+  EXPECT_EQ(E_SUCCESS, tm.RemoveDevice(device_handle_));
+}
+
+TEST_F(TransportManagerImplTest, SetVisibilityOn_StartClientListening) {
+  EXPECT_CALL(*mock_adapter, StartClientListening())
+      .WillOnce(Return(TransportAdapter::OK));
+  EXPECT_EQ(::transport_manager::E_SUCCESS, tm.Visibility(true));
+}
+
+TEST_F(TransportManagerImplTest, SetVisibilityOff_StopClientListening) {
+  EXPECT_CALL(*mock_adapter, StopClientListening())
+      .WillOnce(Return(TransportAdapter::OK));
+  EXPECT_EQ(::transport_manager::E_SUCCESS, tm.Visibility(false));
+}
+
+TEST_F(TransportManagerImplTest, StopTransportManager) {
+  HandleDeviceListUpdated();
+  EXPECT_CALL(*mock_adapter, ConnectDevice(mac_address_))
+      .WillRepeatedly(Return(TransportAdapter::OK));
+  EXPECT_EQ(E_SUCCESS, tm.ConnectDevice(device_handle_));
+
+  EXPECT_CALL(*mock_adapter, DisconnectDevice(mac_address_))
+      .WillRepeatedly(Return(TransportAdapter::OK));
+
+  EXPECT_CALL(*mock_adapter, Terminate());
+  EXPECT_EQ(E_SUCCESS, tm.Stop());
+}
+
+TEST_F(TransportManagerImplTest, Reinit) {
+  EXPECT_CALL(*mock_adapter, Terminate());
+  EXPECT_CALL(*mock_adapter, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_EQ(E_SUCCESS, tm.Reinit());
+}
+
+TEST_F(TransportManagerImplTest, Reinit_InitAdapterFailed) {
+  EXPECT_CALL(*mock_adapter, Terminate());
+  EXPECT_CALL(*mock_adapter, Init()).WillOnce(Return(TransportAdapter::FAIL));
+  EXPECT_EQ(E_ADAPTERS_FAIL, tm.Reinit());
+}
+
+TEST_F(TransportManagerImplTest, UpdateDeviceList_AddNewDevice) {
+  const DeviceInfo dev_info(device_handle_, mac_address_, "TestDeviceName",
+                            "BTMAC");
+
+  dev.push_back(dev_info.mac_address());
+  std::vector<DeviceInfo> vector_dev_info;
+  std::vector<DeviceInfo>::iterator it = vector_dev_info.begin();
+  vector_dev_info.insert(it, dev_info);
+
+  EXPECT_CALL(*mock_adapter, GetDeviceList()).WillOnce(Return(dev));
+  EXPECT_CALL(*mock_adapter, DeviceName(dev_info.mac_address()))
+      .WillOnce(Return(dev_info.name()));
+  EXPECT_CALL(*mock_adapter, GetConnectionType())
+      .WillOnce(Return(dev_info.connection_type()));
+  EXPECT_CALL(*tm_listener, OnDeviceAdded(dev_info));
+
+  tm.UpdateDeviceList(mock_adapter);
+  dev.pop_back();
+}
+
+TEST_F(TransportManagerImplTest, UpdateDeviceList_RemoveDevice) {
+  const DeviceInfo dev_info(device_handle_, mac_address_, "TestDeviceName",
+                            "BTMAC");
+
+  dev.push_back(dev_info.mac_address());
+  std::vector<DeviceInfo> vector_dev_info;
+  std::vector<DeviceInfo>::iterator it = vector_dev_info.begin();
+  vector_dev_info.insert(it, dev_info);
+
+  ::testing::InSequence seq;
+  EXPECT_CALL(*mock_adapter, GetDeviceList()).WillOnce(Return(dev));
+  EXPECT_CALL(*mock_adapter, GetConnectionType())
+      .WillOnce(Return(dev_info.connection_type()));
+  EXPECT_CALL(*mock_adapter, DeviceName(dev_info.mac_address()))
+      .WillOnce(Return(dev_info.name()));
+  EXPECT_CALL(*tm_listener, OnDeviceAdded(dev_info));
+  tm.UpdateDeviceList(mock_adapter);
+  dev.pop_back();
+
+  // Device list is empty now
+  EXPECT_CALL(*mock_adapter, GetDeviceList()).WillOnce(Return(dev));
+  EXPECT_CALL(*tm_listener, OnDeviceRemoved(dev_info));
+  tm.UpdateDeviceList(mock_adapter);
+}
+
+/*
+ * Tests which check correct handling and receiving events
+ */
+TEST_F(TransportManagerImplTest, ReceiveEventFromDevice_OnSearchDeviceDone) {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_DONE);
+
+  TransportAdapterEvent test_event(type, mock_adapter, mac_address_,
+                                   application_id, test_message_, error_);
+
+  EXPECT_CALL(*tm_listener, OnScanDevicesFinished());
+
+  tm.ReceiveEventFromDevice(test_event);
+  testing::Mock::AsyncVerifyAndClearExpectations(10000);
+}
+
+TEST_F(TransportManagerImplTest, ReceiveEventFromDevice_OnSearchDeviceFail) {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_FAIL);
+
+  TransportAdapterEvent test_event(type, mock_adapter, mac_address_,
+                                   application_id, test_message_, error_);
+
+  EXPECT_CALL(*tm_listener, OnScanDevicesFailed(_));
+
+  tm.ReceiveEventFromDevice(test_event);
+  testing::Mock::AsyncVerifyAndClearExpectations(10000);
+}
+
+TEST_F(TransportManagerImplTest, ReceiveEventFromDevice_DeviceListUpdated) {
+  int type = static_cast<int>(
+      TransportAdapterListenerImpl::EventTypeEnum::ON_DEVICE_LIST_UPDATED);
+  const DeviceInfo dev_info(device_handle_, mac_address_, "TestDeviceName",
+                            "BTMAC");
+
+  TransportAdapterEvent test_event(type, mock_adapter, dev_info.mac_address(),
+                                   application_id, test_message_, error_);
+  dev.push_back(dev_info.mac_address());
+  std::vector<DeviceInfo> vector_dev_info;
+  std::vector<DeviceInfo>::iterator it = vector_dev_info.begin();
+  vector_dev_info.insert(it, dev_info);
+
+  EXPECT_CALL(*mock_adapter, GetDeviceList())
+      .Times(AtLeast(1))
+      .WillRepeatedly(Return(dev));
+  EXPECT_CALL(*mock_adapter, DeviceName(dev_info.mac_address()))
+      .Times(AtLeast(1))
+      .WillRepeatedly(Return(dev_info.name()));
+  EXPECT_CALL(*mock_adapter, GetConnectionType())
+      .Times(AtLeast(1))
+      .WillRepeatedly(Return(dev_info.connection_type()));
+
+  EXPECT_CALL(*tm_listener, OnDeviceFound(dev_info));
+  EXPECT_CALL(*tm_listener, OnDeviceAdded(dev_info));
+  EXPECT_CALL(*tm_listener, OnDeviceListUpdated(vector_dev_info));
+
+  tm.ReceiveEventFromDevice(test_event);
+  dev.pop_back();
+  testing::Mock::AsyncVerifyAndClearExpectations(10000);
+}
+
+TEST_F(TransportManagerImplTest, CheckEvents) {
+  HandleDeviceListUpdated();
+  HandleConnection();
+  HandleSendDone();
+  HandleSendFailed();
+  HandleSearchDone();
+  HandleSearchFail();
+  HandleFindNewApplicationsRequest();
+  HandleConnectionFailed();
+  HandleConnectionClosed();
+
+  HandleDisconnectionFailed();
+}
+
+TEST_F(TransportManagerImplTest, CheckReceiveEvent) {
+  HandleConnection();
+  HandleReceiveDone();
+}
+
+}  // namespace transport_manager_test
+}  // namespace components
+}  // namespace test