Correctives in ApplicationManager tests

Correctives after removing ConnectionHandler, ProtocolHandler, HMIMessageHandler singletones Related to : APPLINK-21440
author: Kozoriz <kozorizandriy@gmail.com> 2016-02-29 10:31:36 +0200
committer: Kozoriz <kozorizandriy@gmail.com> 2016-03-04 10:11:53 +0200
commit: 0699659c50ffdbb4f8f7308032ece33f3675abbe (patch)
tree: 2d783d6384eb2887d0f6cb3abbd71b1012db2618 /src/components/application_manager/test
parent: 6b1559b8659ec8d20777c29a714797fa3b649804 (diff)
download: sdl_core-0699659c50ffdbb4f8f7308032ece33f3675abbe.tar.gz
14 files changed, 711 insertions, 792 deletions
diff --git a/src/components/application_manager/test/CMakeLists.txt b/src/components/application_manager/test/CMakeLists.txt
index 963f9649d6..8f74c53ac1 100644
--- a/src/components/application_manager/test/CMakeLists.txt
+++ b/src/components/application_manager/test/CMakeLists.txt
@@ -230,4 +230,5 @@ target_link_libraries("application_manager_test"
   file(COPY smartDeviceLink_test.ini DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/resumption)
   create_test("resumption/data_resumption_test" "${ResumptionData_SOURCES}" "${testLibraries}")
 
+  add_subdirectory(state_controller)
 endif()
diff --git a/src/components/application_manager/test/message_helper/message_helper_test.cc b/src/components/application_manager/test/message_helper/message_helper_test.cc
index 9e1d76bb46..b6ed63b101 100755
--- a/src/components/application_manager/test/message_helper/message_helper_test.cc
+++ b/src/components/application_manager/test/message_helper/message_helper_test.cc
@@ -47,8 +47,8 @@ namespace HmiLanguage = hmi_apis::Common_Language;
 namespace HmiResults = hmi_apis::Common_Result;
 namespace MobileResults = mobile_apis::Result;
 
-typedef ::test::components::resumption_test::ApplicationMock AppMock;
-typedef utils::SharedPtr<AppMock> ApplicationMockSharedPtr;
+typedef ::test::components::resumption_test::MockApplication AppMock;
+typedef utils::SharedPtr<AppMock> MockApplicationSharedPtr;
 typedef std::vector<std::string> StringArray;
 typedef ::application_manager::Application App;
 typedef utils::SharedPtr<App> ApplicationSharedPtr;
@@ -133,7 +133,7 @@ TEST(MessageHelperTestCreate,
 
 TEST(MessageHelperTestCreate,
    CreateGlobalPropertiesRequestsToHMI_SmartObject_EmptyList) {
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   
   EXPECT_CALL(*appSharedMock, vr_help_title()).Times(AtLeast(1));
   EXPECT_CALL(*appSharedMock, vr_help()).Times(AtLeast(1));
@@ -148,7 +148,7 @@ TEST(MessageHelperTestCreate,
 
 TEST(MessageHelperTestCreate,
    CreateGlobalPropertiesRequestsToHMI_SmartObject_NotEmpty) {
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   smart_objects::SmartObjectSPtr objPtr =
       MakeShared<smart_objects::SmartObject>();
 
@@ -195,7 +195,7 @@ TEST(MessageHelperTestCreate,
 
 TEST(MessageHelperTestCreate,
    CreateShowRequestToHMI_SendSmartObject_Equal) {
-  ApplicationMockSharedPtr appSharedMock =
+  MockApplicationSharedPtr appSharedMock =
           utils::MakeShared<AppMock>();
   
   smart_objects::SmartObjectSPtr smartObjectPtr =
@@ -221,7 +221,7 @@ TEST(MessageHelperTestCreate,
 
 TEST(MessageHelperTestCreate,
    CreateAddCommandRequestToHMI_SendSmartObject_Empty) {
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   CommandsMap vis;
   DataAccessor< CommandsMap> data_accessor(vis, true);
   
@@ -236,7 +236,7 @@ TEST(MessageHelperTestCreate,
 
 TEST(MessageHelperTestCreate,
     CreateAddCommandRequestToHMI_SendSmartObject_Equal) {
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   CommandsMap vis;
   DataAccessor< CommandsMap> data_accessor(vis, true);
   smart_objects::SmartObjectSPtr smartObjectPtr =
@@ -278,7 +278,7 @@ TEST(MessageHelperTestCreate,
 
 TEST(MessageHelperTestCreate,
    CreateAddVRCommandRequestFromChoiceToHMI_SendEmptyData_EmptyList) {
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   application_manager::ChoiceSetMap vis;
   DataAccessor< ::application_manager::ChoiceSetMap> data_accessor(vis, true);
   
@@ -293,7 +293,7 @@ TEST(MessageHelperTestCreate,
 
 TEST(MessageHelperTestCreate,
   CreateAddVRCommandRequestFromChoiceToHMI_SendObject_EqualList) {
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   application_manager::ChoiceSetMap vis;
   DataAccessor< ::application_manager::ChoiceSetMap> data_accessor(vis, true);
   smart_objects::SmartObjectSPtr smartObjectPtr =
@@ -343,7 +343,7 @@ TEST(MessageHelperTestCreate,
 }
 
 TEST(MessageHelperTestCreate, CreateAddSubMenuRequestToHMI_SendObject_Equal) {
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   application_manager::SubMenuMap vis;
   DataAccessor< ::application_manager::SubMenuMap> data_accessor(vis, true);
   smart_objects::SmartObjectSPtr smartObjectPtr =
@@ -386,7 +386,7 @@ TEST(MessageHelperTestCreate, CreateAddSubMenuRequestToHMI_SendObject_Equal) {
 
 TEST(MessageHelperTestCreate,
   CreateAddSubMenuRequestToHMI_SendEmptyMap_EmptySmartObjectList) {
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   application_manager::SubMenuMap vis;
   DataAccessor< ::application_manager::SubMenuMap> data_accessor(vis, true);
 
@@ -657,8 +657,8 @@ TEST_F(MessageHelperTest, VerifySoftButtonString_CorrectStrings_True) {
 
 TEST_F(MessageHelperTest,
     GetIVISubscriptionRequests_ValidApplication_HmiRequestNotEmpty) {
-  // Creating sharedPtr to ApplicationMock
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  // Creating sharedPtr to MockApplication
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   // Creating data acessor
   application_manager::VehicleInfoSubscriptions vis;
   DataAccessor<application_manager::VehicleInfoSubscriptions>
@@ -676,8 +676,8 @@ TEST_F(MessageHelperTest,
 
 TEST_F(MessageHelperTest,
     ProcessSoftButtons_SmartObjectWithoutButtonsKey_Success) {
-  // Creating sharedPtr to ApplicationMock
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  // Creating sharedPtr to MockApplication
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   // Creating input data for method
   smart_objects::SmartObject object;
   // Method call
@@ -689,8 +689,8 @@ TEST_F(MessageHelperTest,
 
 TEST_F(MessageHelperTest,
     ProcessSoftButtons_IncorectSoftButonValue_InvalidData) {
-  // Creating sharedPtr to ApplicationMock
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  // Creating sharedPtr to MockApplication
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   // Creating input data for method
   smart_objects::SmartObject object;
   smart_objects::SmartObject& buttons = object[strings::soft_buttons];
@@ -705,8 +705,8 @@ TEST_F(MessageHelperTest,
 
 TEST_F(MessageHelperTest,
     VerifyImage_ImageTypeIsStatic_Success) {
-  // Creating sharedPtr to ApplicationMock
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  // Creating sharedPtr to MockApplication
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   // Creating input data for method
   smart_objects::SmartObject image;
   image[strings::image_type] = mobile_apis::ImageType::STATIC;
@@ -719,8 +719,8 @@ TEST_F(MessageHelperTest,
 
 TEST_F(MessageHelperTest,
     VerifyImage_ImageValueNotValid_InvalidData) {
-  // Creating sharedPtr to ApplicationMock
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  // Creating sharedPtr to MockApplication
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   // Creating input data for method
   smart_objects::SmartObject image;
   image[strings::image_type] = mobile_apis::ImageType::DYNAMIC;
@@ -736,8 +736,8 @@ TEST_F(MessageHelperTest,
 
 TEST_F(MessageHelperTest,
     VerifyImageFiles_SmartObjectWithValidData_Success) {
-  // Creating sharedPtr to ApplicationMock
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  // Creating sharedPtr to MockApplication
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   // Creating input data for method
   smart_objects::SmartObject images;
   images[0][strings::image_type] = mobile_apis::ImageType::STATIC;
@@ -751,8 +751,8 @@ TEST_F(MessageHelperTest,
 
 TEST_F(MessageHelperTest,
     VerifyImageFiles_SmartObjectWithInvalidData_NotSuccsess) {
-  // Creating sharedPtr to ApplicationMock
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  // Creating sharedPtr to MockApplication
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   // Creating input data for method
   smart_objects::SmartObject images;
   images[0][strings::image_type] = mobile_apis::ImageType::DYNAMIC;
@@ -769,8 +769,8 @@ TEST_F(MessageHelperTest,
 
 TEST_F(MessageHelperTest,
     VerifyImageVrHelpItems_SmartObjectWithSeveralValidImages_Succsess) {
-  // Creating sharedPtr to ApplicationMock
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  // Creating sharedPtr to MockApplication
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   // Creating input data for method
   smart_objects::SmartObject message;
   message[0][strings::image][strings::image_type] =
@@ -786,8 +786,8 @@ TEST_F(MessageHelperTest,
 
 TEST_F(MessageHelperTest,
     VerifyImageVrHelpItems_SmartObjWithSeveralInvalidImages_NotSuccsess) {
-  // Creating sharedPtr to ApplicationMock
-  ApplicationMockSharedPtr appSharedMock = utils::MakeShared<AppMock>();
+  // Creating sharedPtr to MockApplication
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   // Creating input data for method
   smart_objects::SmartObject message;
   message[0][strings::image][strings::image_type] =
@@ -850,7 +850,7 @@ TEST_F(MessageHelperTest,
 TEST_F(MessageHelperTest,
     SubscribeApplicationToSoftButton_CallFromApp) {
   // Create application mock
-  ApplicationMockSharedPtr appSharedPtr = utils::MakeShared<AppMock>();
+  MockApplicationSharedPtr appSharedPtr = utils::MakeShared<AppMock>();
   // Prepare data for method
   smart_objects::SmartObject message_params;
   size_t function_id = 1;
diff --git a/src/components/application_manager/test/mock/include/application_manager/application_manager_impl.h b/src/components/application_manager/test/mock/include/application_manager/application_manager_impl.h
index 13f1bd9965..a62117648f 100644
--- a/src/components/application_manager/test/mock/include/application_manager/application_manager_impl.h
+++ b/src/components/application_manager/test/mock/include/application_manager/application_manager_impl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Ford Motor Company
+ * Copyright (c) 2016, Ford Motor Company
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,7 +38,6 @@
 #include <map>
 #include <set>
 
-#include "gtest/gtest.h"
 #include "gmock/gmock.h"
 
 #include "application_manager/hmi_command_factory.h"
@@ -49,6 +48,7 @@
 #include "application_manager/resumption/resume_ctrl.h"
 #include "application_manager/vehicle_info_data.h"
 #include "application_manager/state_controller.h"
+#include "application_manager/commands/command.h"
 #include "protocol_handler/protocol_observer.h"
 #include "protocol_handler/protocol_handler.h"
 #include "hmi_message_handler/hmi_message_observer.h"
@@ -174,6 +174,8 @@ class ApplicationManagerImpl
   MOCK_METHOD1(set_protocol_handler, void(protocol_handler::ProtocolHandler*));
   MOCK_METHOD1(set_connection_handler,
                void(connection_handler::ConnectionHandler*));
+  MOCK_CONST_METHOD0(connection_handler,
+                     connection_handler::ConnectionHandler&());
 
   MOCK_CONST_METHOD0(applications, DataAccessor<ApplicationSet>());
 
@@ -222,16 +224,16 @@ class ApplicationManagerImpl
   MOCK_METHOD0(hmi_capabilities, HMICapabilities&());
   MOCK_METHOD0(is_attenuated_supported, bool());
   MOCK_METHOD1(ManageHMICommand,
-               bool(const utils::SharedPtr<smart_objects::SmartObject>&));
+               bool(const application_manager::commands::MessageSharedPtr message));
   MOCK_METHOD2(ManageMobileCommand,
-               bool(const utils::SharedPtr<smart_objects::SmartObject>& message,
+               bool(const smart_objects::SmartObjectSPtr message,
                     commands::Command::CommandOrigin));
   MOCK_METHOD1(SendMessageToHMI,
-               bool(const utils::SharedPtr<smart_objects::SmartObject>&));
+               void(const application_manager::commands::MessageSharedPtr));
   MOCK_METHOD2(SendMessageToMobile,
-               bool(const utils::SharedPtr<smart_objects::SmartObject>&, bool));
+               void(const application_manager::commands::MessageSharedPtr, bool));
   MOCK_METHOD1(SendMessageToMobile,
-               bool(const utils::SharedPtr<smart_objects::SmartObject>&));
+               void(const application_manager::commands::MessageSharedPtr));
   MOCK_METHOD1(GetDeviceName, std::string(connection_handler::DeviceHandle));
   MOCK_METHOD1(GetDeviceTransportType,
                hmi_apis::Common_TransportType::eType(const std::string&));
@@ -384,6 +386,8 @@ class ApplicationManagerImpl
                     mobile_apis::AudioStreamingState::eType));
   MOCK_CONST_METHOD1(GetDefaultHmiLevel,
                      mobile_apis::HMILevel::eType(ApplicationConstSharedPtr));
+  MOCK_CONST_METHOD1(application, ApplicationSharedPtr(uint32_t app_id));
+
   bool IsHMICooperating() const {
     return true;
   };
diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc
index 8adfd3a8b9..01a4ff6091 100644
--- a/src/components/application_manager/test/mock_message_helper.cc
+++ b/src/components/application_manager/test/mock_message_helper.cc
@@ -114,29 +114,12 @@ smart_objects::SmartObjectSPtr CreateDeviceListSO(
   return MockMessageHelper::message_helper_mock()->CreateDeviceListSO(devices);
 }
 
-uint32_t MessageHelper::GetDeviceHandleForMac(const std::string& device_mac) {
-  return MockMessageHelper::message_helper_mock()->GetDeviceHandleForMac(
-      device_mac);
-}
-
-void MessageHelper::GetDeviceInfoForApp(uint32_t connection_key,
-                                        policy::DeviceParams* device_info) {
-  MockMessageHelper::message_helper_mock()->GetDeviceInfoForApp(connection_key,
-                                                                device_info);
-}
-
 void MessageHelper::SendOnAppPermissionsChangedNotification(
     uint32_t connection_key, const policy::AppPermissions& permissions) {
   MockMessageHelper::message_helper_mock()
       ->SendOnAppPermissionsChangedNotification(connection_key, permissions);
 }
 
-void MessageHelper::GetDeviceInfoForHandle(const uint32_t device_handle,
-                                           policy::DeviceParams* device_info) {
-  MockMessageHelper::message_helper_mock()->GetDeviceInfoForHandle(
-      device_handle, device_info);
-}
-
 void MessageHelper::SendGetUserFriendlyMessageResponse(
     const std::vector<policy::UserFriendlyMessage>& msg,
     uint32_t correlation_id) {
@@ -171,11 +154,6 @@ void MessageHelper::SendGetListOfPermissionsResponse(
       permissions, correlation_id);
 }
 
-void MessageHelper::GetConnectedDevicesMAC(
-    std::vector<std::string>& device_macs) {
-  MockMessageHelper::message_helper_mock()->GetConnectedDevicesMAC(device_macs);
-}
-
 void MessageHelper::SendOnPermissionsChangeNotification(
     uint32_t connection_key, const policy::Permissions& permissions) {
   MockMessageHelper::message_helper_mock()->SendOnPermissionsChangeNotification(
@@ -262,14 +240,6 @@ void MessageHelper::SendAllOnButtonSubscriptionNotificationsForApp(
       ->SendAllOnButtonSubscriptionNotificationsForApp(app);
 }
 
-uint32_t MessageHelper::SendActivateAppToHMI(
-    uint32_t const app_id,
-    hmi_apis::Common_HMILevel::eType level,
-    bool send_policy_priority) {
-  return MockMessageHelper::message_helper_mock()->SendActivateAppToHMI(
-      app_id, level, send_policy_priority);
-}
-
 void MessageHelper::SendOnResumeAudioSourceToHMI(const uint32_t app_id) {
   MockMessageHelper::message_helper_mock()->SendOnResumeAudioSourceToHMI(
       app_id);
@@ -319,7 +289,15 @@ bool MessageHelper::CheckWithPolicy(
     mobile_apis::SystemAction::eType system_action,
     const std::string& app_mobile_id) {
   return MockMessageHelper::message_helper_mock()->CheckWithPolicy(
-      system_action, app_mobile_id);
+        system_action, app_mobile_id);
+}
+
+smart_objects::SmartObjectSPtr MessageHelper::GetBCActivateAppRequestToHMI(
+    ApplicationConstSharedPtr app,
+    hmi_apis::Common_HMILevel::eType hmi_level,
+    bool send_policy_priority) {
+  return MockMessageHelper::message_helper_mock()->
+      GetBCActivateAppRequestToHMI(app, hmi_level, send_policy_priority);
 }
 
 }  // namespace application_manager
diff --git a/src/components/application_manager/test/mock_message_helper.h b/src/components/application_manager/test/mock_message_helper.h
index 64054baaaf..db6c9ec840 100644
--- a/src/components/application_manager/test/mock_message_helper.h
+++ b/src/components/application_manager/test/mock_message_helper.h
@@ -64,13 +64,6 @@ class MockMessageHelper {
   MOCK_METHOD1(CreateDeviceListSO,
                smart_objects::SmartObjectSPtr(
                    const connection_handler::DeviceMap& devices));
-  MOCK_METHOD1(GetDeviceHandleForMac, uint32_t(const std::string& device_mac));
-  MOCK_METHOD2(GetDeviceInfoForHandle,
-               void(const uint32_t device_handle,
-                    policy::DeviceParams* device_info));
-  MOCK_METHOD2(GetDeviceInfoForApp,
-               void(uint32_t connection_key,
-                    policy::DeviceParams* device_info));
   MOCK_METHOD1(SendNaviStartStream, void(int32_t connection_key));
   MOCK_METHOD1(SendNaviStopStream, void(int32_t connection_key));
   MOCK_METHOD2(SendOnAppPermissionsChangedNotification,
@@ -105,8 +98,6 @@ class MockMessageHelper {
       SendGetListOfPermissionsResponse,
       void(const std::vector<policy::FunctionalGroupPermission>& permissions,
            uint32_t correlation_id));
-  MOCK_METHOD1(GetConnectedDevicesMAC,
-               void(std::vector<std::string>& device_macs));
   MOCK_METHOD2(SendOnPermissionsChangeNotification,
                void(uint32_t connection_key,
                     const policy::Permissions& permissions));
@@ -137,11 +128,6 @@ class MockMessageHelper {
   MOCK_METHOD1(SendAllOnButtonSubscriptionNotificationsForApp,
                void(ApplicationConstSharedPtr app));
 
-  MOCK_METHOD3(SendActivateAppToHMI,
-               uint32_t(uint32_t const app_id,
-                        hmi_apis::Common_HMILevel::eType level,
-                        bool send_policy_priority));
-
   MOCK_METHOD1(SendOnResumeAudioSourceToHMI, void(uint32_t app_id));
   MOCK_METHOD1(CreateAddSubMenuRequestToHMI,
                smart_objects::SmartObjectList(ApplicationConstSharedPtr app));
@@ -158,6 +144,10 @@ class MockMessageHelper {
   MOCK_METHOD2(CheckWithPolicy,
                bool(mobile_apis::SystemAction::eType, const std::string&));
 
+  MOCK_METHOD3(GetBCActivateAppRequestToHMI, smart_objects::SmartObjectSPtr (ApplicationConstSharedPtr app,
+                                                   hmi_apis::Common_HMILevel::eType level,
+                                                   bool send_policy_priority));
+
   static MockMessageHelper* message_helper_mock();
 };
 
diff --git a/src/components/application_manager/test/resumption/include/application_mock.h b/src/components/application_manager/test/resumption/include/application_mock.h
deleted file mode 100644
index e510930242..0000000000
--- a/src/components/application_manager/test/resumption/include/application_mock.h
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
-* 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_APPLICATION_MANAGER_TEST_RESUMPTION_INCLUDE_APPLICATION_MOCK_H_
-#define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_RESUMPTION_INCLUDE_APPLICATION_MOCK_H_
-#include <string>
-#include "gmock/gmock.h"
-#include "application_manager/application.h"
-#include "utils/custom_string.h"
-
-namespace test {
-namespace components {
-namespace resumption_test {
-
-namespace custom_str = utils::custom_string;
-
-class ApplicationMock : public ::application_manager::Application {
- public:
-  MOCK_CONST_METHOD0(mobile_app_id, std::string());
-  MOCK_CONST_METHOD0(is_foreground, bool());
-  MOCK_METHOD1(set_foreground, void(bool is_foreground));
-  MOCK_METHOD1(set_mobile_app_id, void(const std::string& mobile_app_id));
-  MOCK_CONST_METHOD0(active_message, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(curHash, const std::string&());
-  MOCK_METHOD0(UpdateHash, void());
-  MOCK_CONST_METHOD0(flag_sending_hash_change_after_awake, bool());
-  MOCK_METHOD1(set_flag_sending_hash_change_after_awake, void(bool flag));
-  MOCK_CONST_METHOD0(is_application_data_changed, bool());
-  MOCK_METHOD1(set_is_application_data_changed,
-               void(bool state_application_data));
-  MOCK_METHOD0(CloseActiveMessage, void());
-  MOCK_CONST_METHOD0(IsFullscreen, bool());
-  MOCK_METHOD0(ChangeSupportingAppHMIType, void());
-  MOCK_CONST_METHOD0(is_navi, bool());
-  MOCK_METHOD1(set_is_navi, void(bool allow));
-  MOCK_CONST_METHOD0(video_streaming_approved, bool());
-  MOCK_METHOD1(set_video_streaming_approved, void(bool state));
-  MOCK_CONST_METHOD0(audio_streaming_approved, bool());
-  MOCK_METHOD1(set_audio_streaming_approved, void(bool state));
-  MOCK_CONST_METHOD0(video_streaming_allowed, bool());
-  MOCK_METHOD1(set_video_streaming_allowed, void(bool state));
-  MOCK_CONST_METHOD0(audio_streaming_allowed, bool());
-  MOCK_METHOD1(set_audio_streaming_allowed, void(bool state));
-  MOCK_METHOD1(StartStreaming,
-               void(protocol_handler::ServiceType service_type));
-  MOCK_METHOD1(StopStreaming, void(protocol_handler::ServiceType service_type));
-  MOCK_METHOD1(SuspendStreaming,
-               void(protocol_handler::ServiceType service_type));
-  MOCK_METHOD1(WakeUpStreaming,
-               void(protocol_handler::ServiceType service_type));
-  MOCK_CONST_METHOD0(is_voice_communication_supported, bool());
-  MOCK_METHOD1(set_voice_communication_supported,
-               void(bool is_voice_communication_supported));
-  MOCK_CONST_METHOD0(app_allowed, bool());
-  MOCK_CONST_METHOD0(has_been_activated, bool());
-  MOCK_METHOD1(set_activated, bool(bool is_active));
-  MOCK_CONST_METHOD0(version, const ::application_manager::Version&());
-  MOCK_METHOD1(set_hmi_application_id, void(uint32_t hmi_app_id));
-  MOCK_CONST_METHOD0(hmi_app_id, uint32_t());
-  MOCK_CONST_METHOD0(name, const custom_str::CustomString&());
-  MOCK_METHOD1(set_folder_name, void(const std::string& folder_name));
-  MOCK_CONST_METHOD0(folder_name, const std::string());
-  MOCK_CONST_METHOD0(is_media_application, bool());
-  MOCK_CONST_METHOD0(hmi_level, const mobile_apis::HMILevel::eType());
-  MOCK_CONST_METHOD0(put_file_in_none_count, const uint32_t());
-  MOCK_CONST_METHOD0(delete_file_in_none_count, const uint32_t());
-  MOCK_CONST_METHOD0(list_files_in_none_count, const uint32_t());
-  MOCK_CONST_METHOD0(system_context, const mobile_apis::SystemContext::eType());
-  MOCK_CONST_METHOD0(audio_streaming_state,
-                     const mobile_apis::AudioStreamingState::eType());
-  MOCK_CONST_METHOD0(app_icon_path, const std::string&());
-  MOCK_CONST_METHOD0(device, connection_handler::DeviceHandle());
-  MOCK_CONST_METHOD0(CurrentHmiState, ::application_manager::HmiStatePtr());
-  MOCK_CONST_METHOD0(RegularHmiState, ::application_manager::HmiStatePtr());
-  MOCK_CONST_METHOD0(PostponedHmiState, ::application_manager::HmiStatePtr());
-  MOCK_METHOD1(set_tts_properties_in_none, void(bool active));
-  MOCK_METHOD0(tts_properties_in_none, bool());
-  MOCK_METHOD1(set_tts_properties_in_full, void(bool active));
-  MOCK_METHOD0(tts_properties_in_full, bool());
-  MOCK_METHOD1(set_version,
-               void(const ::application_manager::Version& version));
-  MOCK_METHOD1(set_name, void(const custom_str::CustomString& name));
-  MOCK_METHOD1(set_is_media_application, void(bool is_media));
-  MOCK_METHOD0(increment_put_file_in_none_count, void());
-  MOCK_METHOD0(increment_delete_file_in_none_count, void());
-  MOCK_METHOD0(increment_list_files_in_none_count, void());
-  MOCK_METHOD1(set_app_icon_path, bool(const std::string& file_name));
-  MOCK_METHOD1(set_app_allowed, void(const bool& allowed));
-  MOCK_METHOD1(set_device, void(connection_handler::DeviceHandle device));
-  MOCK_CONST_METHOD0(get_grammar_id, uint32_t());
-  MOCK_METHOD1(set_grammar_id, void(uint32_t value));
-  MOCK_METHOD1(
-      set_protocol_version,
-      void(const ::application_manager::ProtocolVersion& protocol_version));
-  MOCK_CONST_METHOD0(protocol_version,
-                     ::application_manager::ProtocolVersion());
-  MOCK_METHOD1(set_is_resuming, void(bool));
-  MOCK_CONST_METHOD0(is_resuming, bool());
-  MOCK_METHOD1(AddFile, bool(const ::application_manager::AppFile& file));
-  MOCK_CONST_METHOD0(getAppFiles, const ::application_manager::AppFilesMap&());
-  MOCK_METHOD1(UpdateFile, bool(const ::application_manager::AppFile& file));
-  MOCK_METHOD1(DeleteFile, bool(const std::string& file_name));
-  MOCK_METHOD1(
-      GetFile,
-      const ::application_manager::AppFile*(const std::string& file_name));
-  MOCK_METHOD1(SubscribeToButton,
-               bool(mobile_apis::ButtonName::eType btn_name));
-  MOCK_METHOD1(IsSubscribedToButton,
-               bool(mobile_apis::ButtonName::eType btn_name));
-  MOCK_METHOD1(UnsubscribeFromButton,
-               bool(mobile_apis::ButtonName::eType btn_name));
-  MOCK_METHOD1(SubscribeToIVI, bool(uint32_t vehicle_info_type));
-  MOCK_CONST_METHOD1(IsSubscribedToIVI, bool(uint32_t vehicle_info_type));
-  MOCK_METHOD1(UnsubscribeFromIVI, bool(uint32_t vehicle_info_type));
-  MOCK_METHOD0(ResetDataInNone, void());
-  MOCK_METHOD2(IsCommandLimitsExceeded,
-               bool(mobile_apis::FunctionID::eType cmd_id,
-                    ::application_manager::TLimitSource source));
-  MOCK_METHOD0(usage_report, ::application_manager::UsageStatistics&());
-  MOCK_METHOD1(SetRegularState, void(::application_manager::HmiStatePtr state));
-  MOCK_METHOD1(SetPostponedState,
-               void(::application_manager::HmiStatePtr state));
-  MOCK_METHOD1(AddHMIState, void(::application_manager::HmiStatePtr state));
-  MOCK_METHOD1(RemoveHMIState,
-               void(::application_manager::HmiState::StateID state_id));
-  MOCK_METHOD2(SubscribeToSoftButtons,
-               void(int32_t cmd_id,
-                    const ::application_manager::SoftButtonID& softbuttons_id));
-  MOCK_METHOD1(IsSubscribedToSoftButton, bool(const uint32_t softbutton_id));
-  MOCK_METHOD1(UnsubscribeFromSoftButtons, void(int32_t cmd_id));
-  MOCK_CONST_METHOD0(IsAudioApplication, bool());
-  MOCK_METHOD0(LoadPersistentFiles, void());
-  // InitialApplicationData methods
-  MOCK_CONST_METHOD0(app_types, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(vr_synonyms, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(policy_app_id, std::string());
-  MOCK_CONST_METHOD0(tts_name, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(ngn_media_screen_name,
-                     const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(language, const mobile_apis::Language::eType&());
-  MOCK_CONST_METHOD0(ui_language, const mobile_apis::Language::eType&());
-  MOCK_METHOD1(set_app_types,
-               void(const smart_objects::SmartObject& app_types));
-  MOCK_METHOD1(set_vr_synonyms,
-               void(const smart_objects::SmartObject& vr_synonyms));
-  MOCK_METHOD1(set_policy_app_id, void(const std::string& policy_app_id));
-  MOCK_METHOD1(set_tts_name, void(const smart_objects::SmartObject& tts_name));
-  MOCK_METHOD1(set_ngn_media_screen_name,
-               void(const smart_objects::SmartObject& ngn_name));
-  MOCK_METHOD1(set_language,
-               void(const mobile_apis::Language::eType& language));
-  MOCK_METHOD1(set_ui_language,
-               void(const mobile_apis::Language::eType& ui_language));
-  // DynamicApplicationData methods
-  MOCK_CONST_METHOD0(help_prompt, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(timeout_prompt, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(vr_help_title, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(vr_help, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(tbt_state, const mobile_apis::TBTState::eType&());
-  MOCK_CONST_METHOD0(show_command, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(tbt_show_command, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(
-      SubscribedButtons,
-      DataAccessor<::application_manager::ButtonSubscriptions>());
-  MOCK_CONST_METHOD0(
-      SubscribedIVI,
-      DataAccessor<::application_manager::VehicleInfoSubscriptions>());
-  MOCK_CONST_METHOD0(keyboard_props, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(menu_title, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(menu_icon, const smart_objects::SmartObject*());
-  MOCK_METHOD1(load_global_properties,
-               void(const smart_objects::SmartObject& so));
-  MOCK_METHOD1(set_help_prompt,
-               void(const smart_objects::SmartObject& help_prompt));
-  MOCK_METHOD1(set_timeout_prompt,
-               void(const smart_objects::SmartObject& timeout_prompt));
-  MOCK_METHOD1(set_vr_help_title,
-               void(const smart_objects::SmartObject& vr_help_title));
-  MOCK_METHOD0(reset_vr_help_title, void());
-  MOCK_METHOD1(set_vr_help, void(const smart_objects::SmartObject& vr_help));
-  MOCK_METHOD0(reset_vr_help, void());
-  MOCK_METHOD1(set_tbt_state,
-               void(const mobile_apis::TBTState::eType& tbt_state));
-  MOCK_METHOD1(set_show_command,
-               void(const smart_objects::SmartObject& show_command));
-  MOCK_METHOD1(set_tbt_show_command,
-               void(const smart_objects::SmartObject& tbt_show));
-  MOCK_METHOD1(set_keyboard_props,
-               void(const smart_objects::SmartObject& keyboard_props));
-  MOCK_METHOD1(set_menu_title,
-               void(const smart_objects::SmartObject& menu_title));
-  MOCK_METHOD1(set_menu_icon,
-               void(const smart_objects::SmartObject& menu_icon));
-  MOCK_CONST_METHOD0(audio_stream_retry_number, uint32_t());
-  MOCK_METHOD1(set_audio_stream_retry_number,
-               void(const uint32_t& audio_stream_retry_number));
-  MOCK_CONST_METHOD0(video_stream_retry_number, uint32_t());
-  MOCK_METHOD1(set_video_stream_retry_number,
-               void(const uint32_t& video_stream_retry_number));
-  MOCK_METHOD2(AddCommand,
-               void(uint32_t cmd_id,
-                    const smart_objects::SmartObject& command));
-  MOCK_METHOD1(RemoveCommand, void(uint32_t cmd_id));
-  MOCK_METHOD1(FindCommand, smart_objects::SmartObject*(uint32_t cmd_id));
-  MOCK_METHOD2(AddSubMenu,
-               void(uint32_t menu_id, const smart_objects::SmartObject& menu));
-  MOCK_METHOD1(RemoveSubMenu, void(uint32_t menu_id));
-  MOCK_CONST_METHOD1(FindSubMenu,
-                     smart_objects::SmartObject*(uint32_t menu_id));
-  MOCK_METHOD1(IsSubMenuNameAlreadyExist, bool(const std::string& name));
-  MOCK_METHOD2(AddChoiceSet,
-               void(uint32_t choice_set_id,
-                    const smart_objects::SmartObject& choice_set));
-  MOCK_METHOD1(RemoveChoiceSet, void(uint32_t choice_set_id));
-  MOCK_METHOD1(FindChoiceSet,
-               smart_objects::SmartObject*(uint32_t choice_set_id));
-  MOCK_METHOD3(AddPerformInteractionChoiceSet,
-               void(uint32_t correlation_id,
-                    uint32_t choice_set_id,
-                    const smart_objects::SmartObject& choice_set));
-  MOCK_METHOD1(DeletePerformInteractionChoiceSet,
-               void(uint32_t correlation_id));
-  MOCK_CONST_METHOD0(
-      performinteraction_choice_set_map,
-      DataAccessor<::application_manager::PerformChoiceSetMap>());
-  MOCK_CONST_METHOD0(commands_map,
-                     DataAccessor<::application_manager::CommandsMap>());
-  MOCK_CONST_METHOD0(sub_menu_map,
-                     DataAccessor<::application_manager::SubMenuMap>());
-  MOCK_CONST_METHOD0(choice_set_map,
-                     DataAccessor<::application_manager::ChoiceSetMap>());
-  MOCK_METHOD1(set_perform_interaction_active, void(uint32_t active));
-  MOCK_CONST_METHOD0(is_perform_interaction_active, uint32_t());
-  MOCK_METHOD1(set_perform_interaction_mode, void(int32_t mode));
-  MOCK_CONST_METHOD0(perform_interaction_mode, int32_t());
-  MOCK_METHOD1(set_reset_global_properties_active, void(bool active));
-  MOCK_CONST_METHOD0(is_reset_global_properties_active, bool());
-  MOCK_CONST_METHOD0(app_id, uint32_t());
-  MOCK_CONST_METHOD0(is_foreground, bool());
-  MOCK_CONST_METHOD0(mobile_app_id, std::string());
-  MOCK_METHOD1(set_mobile_app_id, void(const std::string&));
-  MOCK_METHOD1(set_foreground, void(bool));
-  MOCK_METHOD1(AddFile, bool(application_manager::AppFile&));
-  MOCK_METHOD1(UpdateFile, bool(application_manager::AppFile&));
-};
-
-}  // namespace resumption_test
-}  // namespace components
-}  // namespace test
-
-#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_RESUMPTION_INCLUDE_APPLICATION_MOCK_H_
diff --git a/src/components/application_manager/test/resumption/include/resumption_data_test.h b/src/components/application_manager/test/resumption/include/resumption_data_test.h
index 55767225b5..290bac41c5 100644
--- a/src/components/application_manager/test/resumption/include/resumption_data_test.h
+++ b/src/components/application_manager/test/resumption/include/resumption_data_test.h
@@ -57,7 +57,7 @@ class ResumptionDataTest : public ::testing::Test {
 
   // Set data for resumption
   virtual void PrepareData();
-  utils::SharedPtr<NiceMock<ApplicationMock>> app_mock;
+  utils::SharedPtr<NiceMock<MockApplication>> app_mock;
 
   HMILevel::eType hmi_level_;
   size_t app_id_;
diff --git a/src/components/application_manager/test/resumption/resumption_data_test.cc b/src/components/application_manager/test/resumption/resumption_data_test.cc
index 7d04659a8b..4b5970daa6 100644
--- a/src/components/application_manager/test/resumption/resumption_data_test.cc
+++ b/src/components/application_manager/test/resumption/resumption_data_test.cc
@@ -45,12 +45,6 @@
 
 #include "include/resumption_data_test.h"
 
-std::string application_manager::MessageHelper::GetDeviceMacAddressForHandle(
-    const uint32_t device_handle) {
-  std::string device_mac_address = "12345";
-  return device_mac_address;
-}
-
 namespace test {
 namespace components {
 namespace resumption_test {
@@ -354,6 +348,7 @@ void ResumptionDataTest::PrepareData() {
   ON_CALL(*app_mock, is_application_data_changed()).WillByDefault(Return(true));
 
   ON_CALL(*app_mock, policy_app_id()).WillByDefault(Return(policy_app_id_));
+  ON_CALL(*app_mock, mac_address()).WillByDefault(ReturnRef(mac_address_));
   ON_CALL(*app_mock, curHash()).WillByDefault(ReturnRef(hash_));
   ON_CALL(*app_mock, get_grammar_id()).WillByDefault(Return(grammar_id_));
   ON_CALL(*app_mock, device()).WillByDefault(Return(device_handle_));
diff --git a/src/components/application_manager/test/resumption/resumption_data_test.h b/src/components/application_manager/test/resumption/resumption_data_test.h
index 55767225b5..7fc49a53d0 100755
--- a/src/components/application_manager/test/resumption/resumption_data_test.h
+++ b/src/components/application_manager/test/resumption/resumption_data_test.h
@@ -57,7 +57,7 @@ class ResumptionDataTest : public ::testing::Test {
 
   // Set data for resumption
   virtual void PrepareData();
-  utils::SharedPtr<NiceMock<ApplicationMock>> app_mock;
+  utils::SharedPtr<NiceMock<MockApplication>> app_mock;
 
   HMILevel::eType hmi_level_;
   size_t app_id_;
@@ -111,7 +111,7 @@ class ResumptionDataTest : public ::testing::Test {
   const size_t count_of_submenues = 3;
   const size_t count_of_files = 8;
   const size_t count_of_vrhelptitle = 2;
-  const std::string device_id_ = "12345";
+  const std::string mac_address = "12345";
 
   am::CommandsMap test_commands_map;
   am::SubMenuMap test_submenu_map;
diff --git a/src/components/application_manager/test/state_controller/CMakeLists.txt b/src/components/application_manager/test/state_controller/CMakeLists.txt
index 305db68b9a..166a8a1d98 100644
--- a/src/components/application_manager/test/state_controller/CMakeLists.txt
+++ b/src/components/application_manager/test/state_controller/CMakeLists.txt
@@ -30,16 +30,16 @@
 
 if(BUILD_TESTS)
 
-set(appMain_DIR ${CMAKE_SOURCE_DIR}/src/appMain)
-
 include_directories(
     ${GMOCK_INCLUDE_DIRECTORY}
-    ${COMPONENTS_DIR}/application_manager/test/state_controller/include
+    include
+    ${COMPONENTS_DIR}/application_manager/test/include
 )
 
 set(LIBRARIES
   gmock
   ApplicationManager
+  ApplicationManagerTest
 )
 
 set(SOURCES
diff --git a/src/components/application_manager/test/state_controller/include/application_manager_mock.h b/src/components/application_manager/test/state_controller/include/application_manager_mock.h
index d473e33647..4adcb99b4d 100644
--- a/src/components/application_manager/test/state_controller/include/application_manager_mock.h
+++ b/src/components/application_manager/test/state_controller/include/application_manager_mock.h
@@ -38,6 +38,8 @@
 #include "application_manager/application_manager.h"
 #include "application_manager/usage_statistics.h"
 
+namespace test {
+namespace components {
 namespace state_controller_test {
 namespace am = application_manager;
 
@@ -81,4 +83,7 @@ class ApplicationManagerMock : public application_manager::ApplicationManager {
   MOCK_METHOD1(OnApplicationRegistered, void(am::ApplicationSharedPtr));
 };
 }  // namespace state_controller_test
+}  // namespace components
+}  // namespace test
+
 #endif  // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_STATE_CONTROLLER_INCLUDE_APPLICATION_MANAGER_MOCK_H_
diff --git a/src/components/application_manager/test/state_controller/include/application_mock.h b/src/components/application_manager/test/state_controller/include/application_mock.h
index 1ab32833c5..15db179588 100644
--- a/src/components/application_manager/test/state_controller/include/application_mock.h
+++ b/src/components/application_manager/test/state_controller/include/application_mock.h
@@ -37,224 +37,344 @@
 
 #include "gmock/gmock.h"
 #include "application_manager/application.h"
+
+namespace test {
+namespace components {
 namespace state_controller_test {
+
 namespace am = application_manager;
 
 namespace custom_str = utils::custom_string;
 
-class ApplicationMock : public am::Application {
+class MockApplication : public application_manager::Application {
  public:
-  MOCK_CONST_METHOD0(active_message, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(curHash, const std::string&());
-  MOCK_METHOD0(UpdateHash, void());
-  MOCK_CONST_METHOD0(flag_sending_hash_change_after_awake, bool());
-  MOCK_METHOD1(set_flag_sending_hash_change_after_awake, void(bool flag));
-  MOCK_CONST_METHOD0(is_application_data_changed, bool());
+  // InitialApplicationData
+  MOCK_CONST_METHOD0(app_types,
+      const smart_objects::SmartObject*());
+  MOCK_CONST_METHOD0(vr_synonyms,
+      const smart_objects::SmartObject*());
+  MOCK_CONST_METHOD0(mac_address,
+      const std::string&());
+  MOCK_CONST_METHOD0(mobile_app_id,
+      std::string());
+  MOCK_CONST_METHOD0(tts_name,
+      const smart_objects::SmartObject*());
+  MOCK_CONST_METHOD0(ngn_media_screen_name,
+      const smart_objects::SmartObject*());
+  MOCK_CONST_METHOD0(language,
+      const mobile_apis::Language::eType&());
+  MOCK_CONST_METHOD0(ui_language,
+      const mobile_apis::Language::eType&());
+  MOCK_METHOD1(set_app_types,
+      void(const smart_objects::SmartObject& app_types));
+  MOCK_METHOD1(set_vr_synonyms,
+      void(const smart_objects::SmartObject& vr_synonyms));
+  MOCK_METHOD1(set_mobile_app_id,
+      void(const std::string& mobile_app_id));
+  MOCK_METHOD1(set_tts_name,
+      void(const smart_objects::SmartObject& tts_name));
+  MOCK_METHOD1(set_ngn_media_screen_name,
+      void(const smart_objects::SmartObject& ngn_name));
+  MOCK_METHOD1(set_language,
+      void(const mobile_apis::Language::eType& language));
+  MOCK_METHOD1(set_ui_language,
+      void(const mobile_apis::Language::eType& ui_language));
+
+  //  DynamicApplicationData
+  MOCK_CONST_METHOD0(help_prompt,
+       const smart_objects::SmartObject*());
+   MOCK_CONST_METHOD0(timeout_prompt,
+       const smart_objects::SmartObject*());
+   MOCK_CONST_METHOD0(vr_help_title,
+       const smart_objects::SmartObject*());
+   MOCK_CONST_METHOD0(vr_help,
+       const smart_objects::SmartObject*());
+   MOCK_CONST_METHOD0(tbt_state,
+       const mobile_apis::TBTState::eType&());
+   MOCK_CONST_METHOD0(show_command,
+       const smart_objects::SmartObject*());
+   MOCK_CONST_METHOD0(tbt_show_command,
+       const smart_objects::SmartObject*());
+   MOCK_CONST_METHOD0(SubscribedButtons,
+       DataAccessor<application_manager::ButtonSubscriptions>());
+   MOCK_CONST_METHOD0(SubscribedIVI,
+       DataAccessor<application_manager::VehicleInfoSubscriptions>());
+   MOCK_CONST_METHOD0(keyboard_props,
+       const smart_objects::SmartObject*());
+   MOCK_CONST_METHOD0(menu_title,
+       const smart_objects::SmartObject*());
+   MOCK_CONST_METHOD0(menu_icon,
+       const smart_objects::SmartObject*());
+   MOCK_METHOD1(load_global_properties,
+       void(const smart_objects::SmartObject& so));
+   MOCK_METHOD1(set_help_prompt,
+       void(const smart_objects::SmartObject& help_prompt));
+   MOCK_METHOD1(set_timeout_prompt,
+       void(const smart_objects::SmartObject& timeout_prompt));
+   MOCK_METHOD1(set_vr_help_title,
+       void(const smart_objects::SmartObject& vr_help_title));
+   MOCK_METHOD0(reset_vr_help_title,
+       void());
+   MOCK_METHOD1(set_vr_help,
+       void(const smart_objects::SmartObject& vr_help));
+   MOCK_METHOD0(reset_vr_help,
+       void());
+   MOCK_METHOD1(set_tbt_state,
+       void(const mobile_apis::TBTState::eType& tbt_state));
+   MOCK_METHOD1(set_show_command,
+       void(const smart_objects::SmartObject& show_command));
+   MOCK_METHOD1(set_tbt_show_command,
+       void(const smart_objects::SmartObject& tbt_show));
+   MOCK_METHOD1(set_keyboard_props,
+       void(const smart_objects::SmartObject& keyboard_props));
+   MOCK_METHOD1(set_menu_title,
+       void(const smart_objects::SmartObject& menu_title));
+   MOCK_METHOD1(set_menu_icon,
+       void(const smart_objects::SmartObject& menu_icon));
+   MOCK_CONST_METHOD0(audio_stream_retry_number,
+       uint32_t());
+   MOCK_METHOD1(set_audio_stream_retry_number,
+       void(const uint32_t& audio_stream_retry_number));
+   MOCK_CONST_METHOD0(video_stream_retry_number,
+       uint32_t());
+   MOCK_METHOD1(set_video_stream_retry_number,
+       void(const uint32_t& video_stream_retry_number));
+   MOCK_METHOD2(AddCommand,
+       void(uint32_t cmd_id, const smart_objects::SmartObject& command));
+   MOCK_METHOD1(RemoveCommand,
+       void(uint32_t cmd_id));
+   MOCK_METHOD1(FindCommand,
+       smart_objects::SmartObject*(uint32_t cmd_id));
+   MOCK_METHOD2(AddSubMenu,
+       void(uint32_t menu_id, const smart_objects::SmartObject& menu));
+   MOCK_METHOD1(RemoveSubMenu,
+       void(uint32_t menu_id));
+   MOCK_CONST_METHOD1(FindSubMenu,
+       smart_objects::SmartObject*(uint32_t menu_id));
+   MOCK_METHOD1(IsSubMenuNameAlreadyExist,
+       bool(const std::string& name));
+   MOCK_METHOD2(AddChoiceSet,
+       void(uint32_t choice_set_id, const smart_objects::SmartObject& choice_set));
+   MOCK_METHOD1(RemoveChoiceSet,
+       void(uint32_t choice_set_id));
+   MOCK_METHOD1(FindChoiceSet,
+       smart_objects::SmartObject*(uint32_t choice_set_id));
+   MOCK_METHOD3(AddPerformInteractionChoiceSet,
+       void(uint32_t correlation_id, uint32_t choice_set_id, const smart_objects::SmartObject& choice_set));
+   MOCK_METHOD1(DeletePerformInteractionChoiceSet,
+       void(uint32_t correlation_id));
+   MOCK_CONST_METHOD0(performinteraction_choice_set_map,
+       DataAccessor<application_manager::PerformChoiceSetMap>());
+   MOCK_CONST_METHOD0(commands_map,
+       DataAccessor<application_manager::CommandsMap>());
+   MOCK_CONST_METHOD0(sub_menu_map,
+       DataAccessor<application_manager::SubMenuMap>());
+   MOCK_CONST_METHOD0(choice_set_map,
+       DataAccessor<application_manager::ChoiceSetMap>());
+   MOCK_METHOD1(set_perform_interaction_active,
+       void(uint32_t active));
+   MOCK_CONST_METHOD0(is_perform_interaction_active,
+       uint32_t());
+   MOCK_METHOD1(set_perform_interaction_layout,
+       void(mobile_apis::LayoutMode::eType layout));
+   MOCK_CONST_METHOD0(perform_interaction_layout,
+       mobile_apis::LayoutMode::eType());
+   MOCK_METHOD1(set_perform_interaction_mode,
+       void(int32_t mode));
+   MOCK_CONST_METHOD0(perform_interaction_mode,
+       int32_t());
+   MOCK_METHOD1(set_reset_global_properties_active,
+       void(bool active));
+   MOCK_CONST_METHOD0(is_reset_global_properties_active,
+       bool());
+// Application
+
+  MOCK_CONST_METHOD0(active_message,
+      const smart_objects::SmartObject*());
+  MOCK_CONST_METHOD0(curHash,
+      const std::string&());
+  MOCK_METHOD0(UpdateHash,
+      void());
+  MOCK_CONST_METHOD0(is_application_data_changed,
+      bool());
   MOCK_METHOD1(set_is_application_data_changed,
-               void(bool state_application_data));
-  MOCK_METHOD0(CloseActiveMessage, void());
-  MOCK_CONST_METHOD0(IsFullscreen, bool());
-  MOCK_METHOD0(ChangeSupportingAppHMIType, void());
-  MOCK_CONST_METHOD0(is_navi, bool());
-  MOCK_METHOD1(set_is_navi, void(bool allow));
-  MOCK_CONST_METHOD0(video_streaming_approved, bool());
-  MOCK_METHOD1(set_video_streaming_approved, void(bool state));
-  MOCK_CONST_METHOD0(audio_streaming_approved, bool());
-  MOCK_METHOD1(set_audio_streaming_approved, void(bool state));
-  MOCK_CONST_METHOD0(video_streaming_allowed, bool());
-  MOCK_METHOD1(set_video_streaming_allowed, void(bool state));
-  MOCK_CONST_METHOD0(audio_streaming_allowed, bool());
-  MOCK_METHOD1(set_audio_streaming_allowed, void(bool state));
+      void(bool state_application_data));
+  MOCK_METHOD0(CloseActiveMessage,
+      void());
+  MOCK_CONST_METHOD0(IsFullscreen,
+      bool());
+  MOCK_METHOD0(ChangeSupportingAppHMIType,
+      void());
+  MOCK_CONST_METHOD0(is_navi,
+      bool());
+  MOCK_METHOD1(set_is_navi,
+      void(bool allow));
+  MOCK_CONST_METHOD0(video_streaming_approved,
+      bool());
+  MOCK_METHOD1(set_video_streaming_approved,
+      void(bool state));
+  MOCK_CONST_METHOD0(audio_streaming_approved,
+      bool());
+  MOCK_METHOD1(set_audio_streaming_approved,
+      void(bool state));
+  MOCK_CONST_METHOD0(video_streaming_allowed,
+      bool());
+  MOCK_METHOD1(set_video_streaming_allowed,
+      void(bool state));
+  MOCK_CONST_METHOD0(audio_streaming_allowed,
+      bool());
+  MOCK_METHOD1(set_audio_streaming_allowed,
+      void(bool state));
   MOCK_METHOD1(StartStreaming,
-               void(protocol_handler::ServiceType service_type));
-  MOCK_METHOD1(StopStreamingForce,
-               void(protocol_handler::ServiceType service_type));
-  MOCK_METHOD1(StopStreaming, void(protocol_handler::ServiceType service_type));
+      void(protocol_handler::ServiceType service_type));
+  MOCK_METHOD1(StopStreaming,
+      void(protocol_handler::ServiceType service_type));
   MOCK_METHOD1(SuspendStreaming,
-               void(protocol_handler::ServiceType service_type));
+      void(protocol_handler::ServiceType service_type));
   MOCK_METHOD1(WakeUpStreaming,
-               void(protocol_handler::ServiceType service_type));
-  MOCK_CONST_METHOD0(is_voice_communication_supported, bool());
+      void(protocol_handler::ServiceType service_type));
+  MOCK_CONST_METHOD0(is_voice_communication_supported,
+      bool());
   MOCK_METHOD1(set_voice_communication_supported,
-               void(bool is_voice_communication_supported));
-  MOCK_CONST_METHOD0(app_allowed, bool());
-  MOCK_CONST_METHOD0(has_been_activated, bool());
-  MOCK_METHOD1(set_activated, bool(bool is_active));
-  MOCK_CONST_METHOD0(version, const am::Version&());
-  MOCK_METHOD1(set_hmi_application_id, void(uint32_t hmi_app_id));
-
-  MOCK_CONST_METHOD0(hmi_app_id, uint32_t());
-  MOCK_CONST_METHOD0(name, const custom_str::CustomString&());
-  MOCK_METHOD1(set_folder_name, void(const std::string& folder_name));
-  MOCK_CONST_METHOD0(folder_name, const std::string());
-  MOCK_CONST_METHOD0(is_media_application, bool());
-  MOCK_CONST_METHOD0(is_foreground, bool());
-  MOCK_METHOD1(set_foreground, void(bool));
-  MOCK_CONST_METHOD0(hmi_level, const mobile_apis::HMILevel::eType());
-  MOCK_CONST_METHOD0(put_file_in_none_count, const uint32_t());
-  MOCK_CONST_METHOD0(delete_file_in_none_count, const uint32_t());
-  MOCK_CONST_METHOD0(list_files_in_none_count, const uint32_t());
-  MOCK_CONST_METHOD0(system_context, const mobile_apis::SystemContext::eType());
+      void(bool is_voice_communication_supported));
+  MOCK_CONST_METHOD0(app_allowed,
+      bool());
+  MOCK_CONST_METHOD0(has_been_activated,
+      bool());
+  MOCK_METHOD1(set_activated,
+      bool(bool is_active));
+  MOCK_CONST_METHOD0(version,
+      const application_manager::Version&());
+  MOCK_METHOD1(set_hmi_application_id,
+      void(uint32_t hmi_app_id));
+  MOCK_CONST_METHOD0(hmi_app_id,
+      uint32_t());
+  MOCK_CONST_METHOD0(app_id,
+      uint32_t());
+  MOCK_CONST_METHOD0(name,
+      const custom_str::CustomString&());
+  MOCK_METHOD1(set_folder_name,
+      void(const std::string& folder_name));
+  MOCK_CONST_METHOD0(folder_name,
+      const std::string());
+  MOCK_CONST_METHOD0(is_media_application,
+      bool());
+  MOCK_CONST_METHOD0(is_foreground,
+      bool());
+  MOCK_METHOD1(set_foreground,
+      void(bool is_foreground));
+  MOCK_CONST_METHOD0(hmi_level,
+      const mobile_apis::HMILevel::eType());
+  MOCK_CONST_METHOD0(put_file_in_none_count,
+      const uint32_t());
+  MOCK_CONST_METHOD0(delete_file_in_none_count,
+      const uint32_t());
+  MOCK_CONST_METHOD0(list_files_in_none_count,
+      const uint32_t());
+  MOCK_CONST_METHOD0(system_context,
+      const mobile_apis::SystemContext::eType());
   MOCK_CONST_METHOD0(audio_streaming_state,
-                     const mobile_apis::AudioStreamingState::eType());
-  MOCK_CONST_METHOD0(app_icon_path, const std::string&());
-  MOCK_CONST_METHOD0(device, connection_handler::DeviceHandle());
-  MOCK_CONST_METHOD0(CurrentHmiState, const am::HmiStatePtr());
-  MOCK_CONST_METHOD0(RegularHmiState, const am::HmiStatePtr());
-  MOCK_CONST_METHOD0(PostponedHmiState, const am::HmiStatePtr());
-  MOCK_METHOD1(set_tts_properties_in_none, void(bool active));
-  MOCK_METHOD0(tts_properties_in_none, bool());
-  MOCK_METHOD1(set_tts_properties_in_full, void(bool active));
-  MOCK_METHOD0(tts_properties_in_full, bool());
-  MOCK_METHOD1(set_version, void(const am::Version& version));
-  MOCK_METHOD1(set_name, void(const custom_str::CustomString& name));
-  MOCK_METHOD1(set_is_media_application, void(bool is_media));
-  MOCK_METHOD0(increment_put_file_in_none_count, void());
-  MOCK_METHOD0(increment_delete_file_in_none_count, void());
-  MOCK_METHOD0(increment_list_files_in_none_count, void());
-  MOCK_METHOD1(set_app_icon_path, bool(const std::string& file_name));
-  MOCK_METHOD1(set_app_allowed, void(const bool& allowed));
-  MOCK_METHOD1(set_device, void(connection_handler::DeviceHandle device));
-  MOCK_CONST_METHOD0(get_grammar_id, uint32_t());
-  MOCK_METHOD1(set_grammar_id, void(uint32_t value));
+      const mobile_apis::AudioStreamingState::eType());
+  MOCK_CONST_METHOD0(app_icon_path,
+      const std::string&());
+  MOCK_CONST_METHOD0(device,
+      connection_handler::DeviceHandle());
+  MOCK_METHOD1(set_tts_properties_in_none,
+      void(bool active));
+  MOCK_METHOD0(tts_properties_in_none,
+      bool());
+  MOCK_METHOD1(set_tts_properties_in_full,
+      void(bool active));
+  MOCK_METHOD0(tts_properties_in_full,
+      bool());
+  MOCK_METHOD1(set_version,
+      void(const application_manager::Version& version));
+  MOCK_METHOD1(set_name,
+      void(const custom_str::CustomString& name));
+  MOCK_METHOD1(set_is_media_application,
+      void(bool is_media));
+  MOCK_METHOD0(increment_put_file_in_none_count,
+      void());
+  MOCK_METHOD0(increment_delete_file_in_none_count,
+      void());
+  MOCK_METHOD0(increment_list_files_in_none_count,
+      void());
+  MOCK_METHOD1(set_app_icon_path,
+      bool(const std::string& file_name));
+  MOCK_METHOD1(set_app_allowed,
+      void(const bool& allowed));
+  MOCK_METHOD1(set_device,
+      void(connection_handler::DeviceHandle device));
+  MOCK_CONST_METHOD0(get_grammar_id,
+      uint32_t());
+  MOCK_METHOD1(set_grammar_id,
+      void(uint32_t value));
   MOCK_METHOD1(set_protocol_version,
-               void(const am::ProtocolVersion& protocol_version));
-  MOCK_CONST_METHOD0(protocol_version, am::ProtocolVersion());
-  MOCK_METHOD1(set_is_resuming, void(bool));
-  MOCK_CONST_METHOD0(is_resuming, bool());
-  MOCK_METHOD1(AddFile, bool(const am::AppFile& file));
-  MOCK_CONST_METHOD0(getAppFiles, const am::AppFilesMap&());
-  MOCK_METHOD1(UpdateFile, bool(const am::AppFile& file));
-  MOCK_METHOD1(DeleteFile, bool(const std::string& file_name));
-  MOCK_METHOD1(GetFile, const am::AppFile*(const std::string& file_name));
+      void(const application_manager::ProtocolVersion& protocol_version));
+  MOCK_CONST_METHOD0(protocol_version,
+      application_manager::ProtocolVersion());
+  MOCK_METHOD1(set_is_resuming,
+      void(bool is_resuming));
+  MOCK_CONST_METHOD0(is_resuming,
+      bool());
+  MOCK_METHOD1(AddFile,
+      bool(const application_manager::AppFile& file));
+  MOCK_CONST_METHOD0(getAppFiles,
+      const application_manager::AppFilesMap&());
+  MOCK_METHOD1(UpdateFile,
+      bool(const application_manager::AppFile& file));
+  MOCK_METHOD1(DeleteFile,
+      bool(const std::string& file_name));
+  MOCK_METHOD1(GetFile,
+      const application_manager::AppFile*(const std::string& file_name));
   MOCK_METHOD1(SubscribeToButton,
-               bool(mobile_apis::ButtonName::eType btn_name));
+      bool(mobile_apis::ButtonName::eType btn_name));
   MOCK_METHOD1(IsSubscribedToButton,
-               bool(mobile_apis::ButtonName::eType btn_name));
+      bool(mobile_apis::ButtonName::eType btn_name));
   MOCK_METHOD1(UnsubscribeFromButton,
-               bool(mobile_apis::ButtonName::eType btn_name));
-  MOCK_METHOD1(SubscribeToIVI, bool(uint32_t vehicle_info_type));
-  MOCK_CONST_METHOD1(IsSubscribedToIVI, bool(uint32_t vehicle_info_type));
-  MOCK_METHOD1(UnsubscribeFromIVI, bool(uint32_t vehicle_info_type));
-  MOCK_METHOD0(ResetDataInNone, void());
+      bool(mobile_apis::ButtonName::eType btn_name));
+  MOCK_METHOD1(SubscribeToIVI,
+      bool(uint32_t vehicle_info_type));
+  MOCK_CONST_METHOD1(IsSubscribedToIVI,
+      bool(uint32_t vehicle_info_type));
+  MOCK_METHOD1(UnsubscribeFromIVI,
+      bool(uint32_t vehicle_info_type));
+  MOCK_METHOD0(ResetDataInNone,
+      void());
   MOCK_METHOD2(IsCommandLimitsExceeded,
-               bool(mobile_apis::FunctionID::eType cmd_id,
-                    am::TLimitSource source));
-  MOCK_METHOD0(usage_report, am::UsageStatistics&());
-  MOCK_METHOD1(SetRegularState, void(am::HmiStatePtr state));
-  MOCK_METHOD1(SetPostponedState, void(am::HmiStatePtr state));
-  MOCK_METHOD0(RemovePostponedState, void());
-  MOCK_METHOD1(AddHMIState, void(am::HmiStatePtr state));
-  MOCK_METHOD1(RemoveHMIState, void(am::HmiState::StateID state_id));
+      bool(mobile_apis::FunctionID::eType cmd_id, application_manager::TLimitSource source));
+  MOCK_METHOD0(usage_report,
+      application_manager::UsageStatistics&());
+  MOCK_METHOD1(SetRegularState,
+      void(application_manager::HmiStatePtr state));
+  MOCK_METHOD1(SetPostponedState,
+      void(application_manager::HmiStatePtr state));
+  MOCK_METHOD0(RemovePostponedState,
+      void());
+  MOCK_METHOD1(AddHMIState,
+      void(application_manager::HmiStatePtr state));
+  MOCK_METHOD1(RemoveHMIState,
+      void(application_manager::HmiState::StateID state_id));
+  MOCK_CONST_METHOD0(CurrentHmiState,
+      const application_manager::HmiStatePtr());
+  MOCK_CONST_METHOD0(RegularHmiState,
+      const application_manager::HmiStatePtr());
+  MOCK_CONST_METHOD0(PostponedHmiState,
+      const application_manager::HmiStatePtr());
   MOCK_METHOD2(SubscribeToSoftButtons,
-               void(int32_t cmd_id, const am::SoftButtonID& softbuttons_id));
-  MOCK_METHOD1(IsSubscribedToSoftButton, bool(const uint32_t softbutton_id));
-  MOCK_METHOD1(UnsubscribeFromSoftButtons, void(int32_t cmd_id));
-  MOCK_CONST_METHOD0(IsAudioApplication, bool());
-  MOCK_METHOD0(LoadPersistentFiles, void());
-
-  // InitialApplicationData methods
-  MOCK_CONST_METHOD0(app_types, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(vr_synonyms, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(mobile_app_id, std::string());
-  MOCK_CONST_METHOD0(tts_name, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(ngn_media_screen_name,
-                     const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(language, const mobile_apis::Language::eType&());
-  MOCK_CONST_METHOD0(ui_language, const mobile_apis::Language::eType&());
-  MOCK_METHOD1(set_app_types,
-               void(const smart_objects::SmartObject& app_types));
-  MOCK_METHOD1(set_vr_synonyms,
-               void(const smart_objects::SmartObject& vr_synonyms));
-  MOCK_METHOD1(set_mobile_app_id, void(const std::string& policy_app_id));
-  MOCK_METHOD1(set_tts_name, void(const smart_objects::SmartObject& tts_name));
-  MOCK_METHOD1(set_ngn_media_screen_name,
-               void(const smart_objects::SmartObject& ngn_name));
-  MOCK_METHOD1(set_language,
-               void(const mobile_apis::Language::eType& language));
-  MOCK_METHOD1(set_ui_language,
-               void(const mobile_apis::Language::eType& ui_language));
-
-  // DynamicApplicationData methods
-  MOCK_CONST_METHOD0(help_prompt, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(timeout_prompt, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(vr_help_title, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(vr_help, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(tbt_state, const mobile_apis::TBTState::eType&());
-  MOCK_CONST_METHOD0(show_command, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(tbt_show_command, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(SubscribedButtons,
-                     DataAccessor<am::ButtonSubscriptions>());
-  MOCK_CONST_METHOD0(SubscribedIVI,
-                     DataAccessor<am::VehicleInfoSubscriptions>());
-  MOCK_CONST_METHOD0(keyboard_props, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(menu_title, const smart_objects::SmartObject*());
-  MOCK_CONST_METHOD0(menu_icon, const smart_objects::SmartObject*());
-  MOCK_METHOD1(load_global_properties,
-               void(const smart_objects::SmartObject& so));
-  MOCK_METHOD1(set_help_prompt,
-               void(const smart_objects::SmartObject& help_prompt));
-  MOCK_METHOD1(set_timeout_prompt,
-               void(const smart_objects::SmartObject& timeout_prompt));
-  MOCK_METHOD1(set_vr_help_title,
-               void(const smart_objects::SmartObject& vr_help_title));
-  MOCK_METHOD0(reset_vr_help_title, void());
-  MOCK_METHOD1(set_vr_help, void(const smart_objects::SmartObject& vr_help));
-  MOCK_METHOD0(reset_vr_help, void());
-  MOCK_METHOD1(set_tbt_state,
-               void(const mobile_apis::TBTState::eType& tbt_state));
-  MOCK_METHOD1(set_show_command,
-               void(const smart_objects::SmartObject& show_command));
-  MOCK_METHOD1(set_tbt_show_command,
-               void(const smart_objects::SmartObject& tbt_show));
-  MOCK_METHOD1(set_keyboard_props,
-               void(const smart_objects::SmartObject& keyboard_props));
-  MOCK_METHOD1(set_menu_title,
-               void(const smart_objects::SmartObject& menu_title));
-  MOCK_METHOD1(set_menu_icon,
-               void(const smart_objects::SmartObject& menu_icon));
-  MOCK_CONST_METHOD0(audio_stream_retry_number, uint32_t());
-  MOCK_METHOD1(set_audio_stream_retry_number,
-               void(const uint32_t& audio_stream_retry_number));
-  MOCK_CONST_METHOD0(video_stream_retry_number, uint32_t());
-  MOCK_METHOD1(set_video_stream_retry_number,
-               void(const uint32_t& video_stream_retry_number));
-  MOCK_METHOD2(AddCommand,
-               void(uint32_t cmd_id,
-                    const smart_objects::SmartObject& command));
-  MOCK_METHOD1(RemoveCommand, void(uint32_t cmd_id));
-  MOCK_METHOD1(FindCommand, smart_objects::SmartObject*(uint32_t cmd_id));
-  MOCK_METHOD2(AddSubMenu,
-               void(uint32_t menu_id, const smart_objects::SmartObject& menu));
-  MOCK_METHOD1(RemoveSubMenu, void(uint32_t menu_id));
-  MOCK_CONST_METHOD1(FindSubMenu,
-                     smart_objects::SmartObject*(uint32_t menu_id));
-  MOCK_METHOD1(IsSubMenuNameAlreadyExist, bool(const std::string& name));
-  MOCK_METHOD2(AddChoiceSet,
-               void(uint32_t choice_set_id,
-                    const smart_objects::SmartObject& choice_set));
-  MOCK_METHOD1(RemoveChoiceSet, void(uint32_t choice_set_id));
-  MOCK_METHOD1(FindChoiceSet,
-               smart_objects::SmartObject*(uint32_t choice_set_id));
-  MOCK_METHOD3(AddPerformInteractionChoiceSet,
-               void(uint32_t correlation_id,
-                    uint32_t choice_set_id,
-                    const smart_objects::SmartObject& choice_set));
-  MOCK_METHOD1(DeletePerformInteractionChoiceSet,
-               void(uint32_t correlation_id));
-  MOCK_CONST_METHOD0(performinteraction_choice_set_map,
-                     DataAccessor<am::PerformChoiceSetMap>());
-  MOCK_CONST_METHOD0(commands_map, DataAccessor<am::CommandsMap>());
-  MOCK_CONST_METHOD0(sub_menu_map, DataAccessor<am::SubMenuMap>());
-  MOCK_CONST_METHOD0(choice_set_map, DataAccessor<am::ChoiceSetMap>());
-  MOCK_METHOD1(set_perform_interaction_active, void(uint32_t active));
-  MOCK_CONST_METHOD0(is_perform_interaction_active, uint32_t());
-  MOCK_METHOD1(set_perform_interaction_mode, void(int32_t mode));
-  MOCK_CONST_METHOD0(perform_interaction_mode, int32_t());
-  MOCK_METHOD1(set_reset_global_properties_active, void(bool active));
-  MOCK_CONST_METHOD0(is_reset_global_properties_active, bool());
-  MOCK_CONST_METHOD0(app_id, uint32_t());
+      void(int32_t cmd_id, const application_manager::SoftButtonID& softbuttons_id));
+  MOCK_METHOD1(IsSubscribedToSoftButton,
+      bool(const uint32_t softbutton_id));
+  MOCK_METHOD1(UnsubscribeFromSoftButtons,
+      void(int32_t cmd_id));
+  MOCK_CONST_METHOD0(IsAudioApplication,
+      bool());
+  MOCK_METHOD0(LoadPersistentFiles,
+      void());
 };
 
 }  // namespace state_controller_test
+}  // namespace components
+}  // namespace test
+
 #endif  // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_STATE_CONTROLLER_INCLUDE_APPLICATION_MOCK_H_
diff --git a/src/components/application_manager/test/state_controller/include/statistics_manager_mock.h b/src/components/application_manager/test/state_controller/include/statistics_manager_mock.h
index 4e2dae78d1..aabe583fa9 100644
--- a/src/components/application_manager/test/state_controller/include/statistics_manager_mock.h
+++ b/src/components/application_manager/test/state_controller/include/statistics_manager_mock.h
@@ -37,7 +37,10 @@
 #include "gmock/gmock.h"
 #include "usage_statistics/statistics_manager.h"
 
+namespace test {
+namespace components {
 namespace state_controller_test {
+
 namespace us = usage_statistics;
 
 class StatisticsManagerMock : public us::StatisticsManager {
@@ -49,4 +52,7 @@ class StatisticsManagerMock : public us::StatisticsManager {
 };
 
 }  // namespace state_controller_test
+}
+}
+
 #endif  // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_STATE_CONTROLLER_INCLUDE_STATISTICS_MANAGER_MOCK_H_
diff --git a/src/components/application_manager/test/state_controller/state_controller_test.cc b/src/components/application_manager/test/state_controller/state_controller_test.cc
index d9979e6fb6..053d1e4346 100644
--- a/src/components/application_manager/test/state_controller/state_controller_test.cc
+++ b/src/components/application_manager/test/state_controller/state_controller_test.cc
@@ -30,18 +30,21 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <gtest/gtest.h>
+#include "gtest/gtest.h"
 #include "application_manager/hmi_state.h"
 #include "application_manager/state_controller.h"
 #include "application_manager/usage_statistics.h"
-#include "application_manager_mock.h"
+#include "application_manager/application_manager_impl.h"
 #include "application_mock.h"
+#include "application_manager/test/mock_message_helper.h"
+#include "connection_handler/mock_connection_handler_settings.h"
+#include "connection_handler/connection_handler_impl.h"
+#include "transport_manager/transport_manager_mock.h"
 #include "statistics_manager_mock.h"
 #include "utils/lock.h"
 #include "utils/data_accessor.h"
 #include "utils/make_shared.h"
 #include "application_manager/message_helper.h"
-#include "application_manager/test/mock_message_helper.h"
 #include "application_manager/event_engine/event.h"
 #include "application_manager/smart_object_keys.h"
 
@@ -61,6 +64,8 @@ using ::testing::AtLeast;
 
 static application_manager::MockMessageHelper* message_helper_mock_;
 
+namespace test {
+namespace components {
 namespace state_controller_test {
 
 struct HmiStatesComparator {
@@ -76,12 +81,12 @@ struct HmiStatesComparator {
       , audio_streaming_state_(audio_streaming_state)
       , system_context_(system_context) {}
 
-  HmiStatesComparator(HmiStatePtr state_ptr)
+  HmiStatesComparator(am::HmiStatePtr state_ptr)
       : hmi_level_(state_ptr->hmi_level())
       , audio_streaming_state_(state_ptr->audio_streaming_state())
       , system_context_(state_ptr->system_context()) {}
 
-  bool operator()(HmiStatePtr state_ptr) const {
+  bool operator()(am::HmiStatePtr state_ptr) const {
     return state_ptr->hmi_level() == hmi_level_ &&
            state_ptr->audio_streaming_state() == audio_streaming_state_ &&
            state_ptr->system_context() == system_context_;
@@ -89,11 +94,11 @@ struct HmiStatesComparator {
 };
 
 struct HmiStatesIDComparator {
-  HmiState::StateID state_id_;
+  am::HmiState::StateID state_id_;
 
-  HmiStatesIDComparator(HmiState::StateID state_id) : state_id_(state_id) {}
+  HmiStatesIDComparator(am::HmiState::StateID state_id) : state_id_(state_id) {}
 
-  bool operator()(HmiStatePtr state_ptr) const {
+  bool operator()(am::HmiStatePtr state_ptr) const {
     return state_ptr->state_id() == state_id_;
   }
 };
@@ -109,21 +114,21 @@ enum ApplicationType {
   APP_TYPE_NON_MEDIA,
   APP_TYPE_NAVI,
   APP_TYPE_MEDIA,
-  APPTYPE_ATTENUATED
+  APP_TYPE_ATTENUATED
 };
 
 class StateControllerTest : public ::testing::Test {
  public:
   StateControllerTest()
       : ::testing::Test()
-      , usage_stat(
-            "0",
-            utils::SharedPtr<us::StatisticsManager>(new StatisticsManagerMock))
+      , usage_stat("0",
+                   utils::SharedPtr<usage_statistics::StatisticsManager>(
+                       new state_controller_test::StatisticsManagerMock))
       , applications_(application_set_, applications_lock_)
       , state_ctrl_(&app_manager_mock_) {}
-  NiceMock<ApplicationManagerMock> app_manager_mock_;
+  NiceMock<application_manager::ApplicationManagerImpl> app_manager_mock_;
 
-  UsageStatistics usage_stat;
+  am::UsageStatistics usage_stat;
 
   am::ApplicationSet application_set_;
   mutable sync_primitives::Lock applications_lock_;
@@ -131,53 +136,60 @@ class StateControllerTest : public ::testing::Test {
   am::StateController state_ctrl_;
 
   am::ApplicationSharedPtr simple_app_;
-  NiceMock<ApplicationMock>* simple_app_ptr_;
+  NiceMock<MockApplication>* simple_app_ptr_;
   uint32_t simple_app_id_ = 1721;
 
   am::ApplicationSharedPtr navi_app_;
-  NiceMock<ApplicationMock>* navi_app_ptr_;
+  NiceMock<MockApplication>* navi_app_ptr_;
   uint32_t navi_app_id_ = 1762;
 
   am::ApplicationSharedPtr media_app_;
-  NiceMock<ApplicationMock>* media_app_ptr_;
+  NiceMock<MockApplication>* media_app_ptr_;
   uint32_t media_app_id_ = 1801;
 
   am::ApplicationSharedPtr vc_app_;
-  NiceMock<ApplicationMock>* vc_app_ptr_;
+  NiceMock<MockApplication>* vc_app_ptr_;
   uint32_t vc_app_id_ = 1825;
 
   am::ApplicationSharedPtr media_navi_app_;
-  NiceMock<ApplicationMock>* media_navi_app_ptr_;
+  NiceMock<MockApplication>* media_navi_app_ptr_;
   uint32_t media_navi_app_id_ = 1855;
 
   am::ApplicationSharedPtr media_vc_app_;
-  NiceMock<ApplicationMock>* media_vc_app_ptr_;
+  NiceMock<MockApplication>* media_vc_app_ptr_;
   uint32_t media_vc_app_id_ = 1881;
 
   am::ApplicationSharedPtr navi_vc_app_;
-  NiceMock<ApplicationMock>* navi_vc_app_ptr_;
+  NiceMock<MockApplication>* navi_vc_app_ptr_;
   uint32_t navi_vc_app_id_ = 1894;
 
   am::ApplicationSharedPtr media_navi_vc_app_;
-  NiceMock<ApplicationMock>* media_navi_vc_app_ptr_;
+  NiceMock<MockApplication>* media_navi_vc_app_ptr_;
   uint32_t media_navi_vc_app_id_ = 1922;
 
-  std::vector<HmiStatePtr> valid_states_for_audio_app_;
-  std::vector<HmiStatePtr> valid_states_for_not_audio_app_;
-  std::vector<HmiStatePtr> common_invalid_states_;
-  std::vector<HmiStatePtr> invalid_states_for_not_audio_app;
-  std::vector<HmiStatePtr> invalid_states_for_audio_app;
-  std::vector<HmiState::StateID> valid_state_ids_;
+  std::vector<am::HmiStatePtr> valid_states_for_audio_app_;
+  std::vector<am::HmiStatePtr> valid_states_for_not_audio_app_;
+  std::vector<am::HmiStatePtr> common_invalid_states_;
+  std::vector<am::HmiStatePtr> invalid_states_for_not_audio_app;
+  std::vector<am::HmiStatePtr> invalid_states_for_audio_app;
+  std::vector<am::HmiState::StateID> valid_state_ids_;
   std::vector<am::ApplicationSharedPtr> applications_list_;
-  HmiStatePtr createHmiState(mobile_apis::HMILevel::eType hmi_level,
-                             mobile_apis::AudioStreamingState::eType aidio_ss,
-                             mobile_apis::SystemContext::eType system_context) {
+
+  connection_handler_test::MockConnectionHandlerSettings
+      mock_connection_handler_settings;
+  transport_manager_test::TransportManagerMock mock_transport_manager;
+  connection_handler::ConnectionHandlerImpl* conn_handler;
+
+  am::HmiStatePtr createHmiState(
+      mobile_apis::HMILevel::eType hmi_level,
+      mobile_apis::AudioStreamingState::eType aidio_ss,
+      mobile_apis::SystemContext::eType system_context) {
     namespace HMILevel = mobile_apis::HMILevel;
     namespace AudioStreamingState = mobile_apis::AudioStreamingState;
     namespace SystemContext = mobile_apis::SystemContext;
 
-    HmiStatePtr state =
-        utils::MakeShared<HmiState>(simple_app_id_, &app_manager_mock_);
+    am::HmiStatePtr state =
+        utils::MakeShared<am::HmiState>(simple_app_id_, &app_manager_mock_);
     state->set_hmi_level(hmi_level);
     state->set_audio_streaming_state(aidio_ss);
     state->set_system_context(system_context);
@@ -188,7 +200,8 @@ class StateControllerTest : public ::testing::Test {
    * @brief Prepare list of resultant HMI states for testing HMIState
    * @param result_hmi state will contain resultant HMI states.
    */
-  void PrepareCommonStateResults(std::vector<HmiStatePtr>& result_hmi_state) {
+  void PrepareCommonStateResults(
+      std::vector<am::HmiStatePtr>& result_hmi_state) {
     namespace HMILevel = mobile_apis::HMILevel;
     namespace AudioStreamingState = mobile_apis::AudioStreamingState;
     namespace SystemContext = mobile_apis::SystemContext;
@@ -220,7 +233,7 @@ class StateControllerTest : public ::testing::Test {
    * @param result_hmi state will contain resultant HMI states.
    */
   void PrepareStateResultsForAttenuated(
-      std::vector<HmiStatePtr>& result_hmi_state) {
+      std::vector<am::HmiStatePtr>& result_hmi_state) {
     namespace HMILevel = mobile_apis::HMILevel;
     namespace AudioStreamingState = mobile_apis::AudioStreamingState;
     namespace SystemContext = mobile_apis::SystemContext;
@@ -245,7 +258,7 @@ class StateControllerTest : public ::testing::Test {
    * @param result_hmi state will contain resultant HMI states.
    */
   void PreparePhoneCallHMIStateResults(
-      std::vector<HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
+      std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
     namespace HMILevel = mobile_apis::HMILevel;
     namespace AudioStreamingState = mobile_apis::AudioStreamingState;
     namespace SystemContext = mobile_apis::SystemContext;
@@ -307,8 +320,8 @@ class StateControllerTest : public ::testing::Test {
    * case if VR or TTS mode is active
    * @param result_hmi state will contain resultant HMI states.
    */
-  void PrepareVRTTSHMIStateResults(std::vector<HmiStatePtr>& result_hmi_state,
-                                   ApplicationType app_t) {
+  void PrepareVRTTSHMIStateResults(
+      std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
     namespace HMILevel = mobile_apis::HMILevel;
     namespace AudioStreamingState = mobile_apis::AudioStreamingState;
     namespace SystemContext = mobile_apis::SystemContext;
@@ -342,7 +355,7 @@ class StateControllerTest : public ::testing::Test {
                            SystemContext::SYSCTXT_MAIN));
         break;
       }
-      case APPTYPE_ATTENUATED: {
+      case APP_TYPE_ATTENUATED: {
         PrepareStateResultsForAttenuated(result_hmi_state);
         break;
       }
@@ -356,7 +369,7 @@ class StateControllerTest : public ::testing::Test {
    * @param result_hmi state will contain resultant HMI states.
    */
   void PrepareNaviStreamingHMIStateResults(
-      std::vector<HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
+      std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
     namespace HMILevel = mobile_apis::HMILevel;
     namespace AudioStreamingState = mobile_apis::AudioStreamingState;
     namespace SystemContext = mobile_apis::SystemContext;
@@ -404,7 +417,7 @@ class StateControllerTest : public ::testing::Test {
    * @param result_hmi state will contain resultant HMI states.
    */
   void PrepareNaviStreamTTSStateResult(
-      std::vector<HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
+      std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
     namespace HMILevel = mobile_apis::HMILevel;
     namespace AudioStreamingState = mobile_apis::AudioStreamingState;
     namespace SystemContext = mobile_apis::SystemContext;
@@ -451,15 +464,15 @@ class StateControllerTest : public ::testing::Test {
   }
 
   void TestSetState(am::ApplicationSharedPtr app,
-                    HmiStatePtr hmi_state,
+                    am::HmiStatePtr hmi_state,
                     ApplicationType app_t,
                     void (StateControllerTest::*call_back)(
-                        std::vector<HmiStatePtr>&, ApplicationType)) {
+                        std::vector<am::HmiStatePtr>&, ApplicationType)) {
     InsertApplication(app);
-    std::vector<HmiStatePtr> result_hmi_state;
+    std::vector<am::HmiStatePtr> result_hmi_state;
     (this->*call_back)(result_hmi_state, app_t);
-    std::vector<HmiStatePtr>::iterator it_begin;
-    std::vector<HmiStatePtr>::iterator it_end;
+    std::vector<am::HmiStatePtr>::iterator it_begin;
+    std::vector<am::HmiStatePtr>::iterator it_end;
     if (APP_TYPE_NON_MEDIA == app_t) {
       it_begin = valid_states_for_not_audio_app_.begin();
       it_end = valid_states_for_not_audio_app_.end();
@@ -471,7 +484,7 @@ class StateControllerTest : public ::testing::Test {
       ASSERT_TRUE(result_hmi_state.size() ==
                   valid_states_for_audio_app_.size());
     }
-    std::vector<HmiStatePtr>::iterator it_result_begin =
+    std::vector<am::HmiStatePtr>::iterator it_result_begin =
         result_hmi_state.begin();
     for (; it_begin != it_end; ++it_begin, ++it_result_begin) {
       hmi_state->set_parent(*it_begin);
@@ -480,17 +493,18 @@ class StateControllerTest : public ::testing::Test {
     }
   }
 
-  void TestSetSeveralState(am::ApplicationSharedPtr app,
-                           HmiStatePtr first_hmi_state,
-                           HmiStatePtr second_hmi_state,
-                           ApplicationType app_t,
-                           void (StateControllerTest::*call_back)(
-                               std::vector<HmiStatePtr>&, ApplicationType)) {
+  void TestSetSeveralState(
+      am::ApplicationSharedPtr app,
+      am::HmiStatePtr first_hmi_state,
+      am::HmiStatePtr second_hmi_state,
+      ApplicationType app_t,
+      void (StateControllerTest::*call_back)(std::vector<am::HmiStatePtr>&,
+                                             ApplicationType)) {
     InsertApplication(app);
-    std::vector<HmiStatePtr> result_hmi_state;
+    std::vector<am::HmiStatePtr> result_hmi_state;
     (this->*call_back)(result_hmi_state, app_t);
-    std::vector<HmiStatePtr>::iterator it_begin;
-    std::vector<HmiStatePtr>::iterator it_end;
+    std::vector<am::HmiStatePtr>::iterator it_begin;
+    std::vector<am::HmiStatePtr>::iterator it_end;
     if (APP_TYPE_NON_MEDIA == app_t) {
       it_begin = valid_states_for_not_audio_app_.begin();
       it_end = valid_states_for_not_audio_app_.end();
@@ -502,19 +516,24 @@ class StateControllerTest : public ::testing::Test {
       ASSERT_TRUE(result_hmi_state.size() ==
                   valid_states_for_audio_app_.size());
     }
-    std::vector<HmiStatePtr>::iterator it_result_begin =
+    std::vector<am::HmiStatePtr>::iterator it_result_begin =
         result_hmi_state.begin();
     for (; it_begin != it_end; ++it_begin, ++it_result_begin) {
       first_hmi_state->set_parent(*it_begin);
       second_hmi_state->set_parent(first_hmi_state);
       HmiStatesComparator st_comp(second_hmi_state);
-      ASSERT_TRUE(st_comp(*it_result_begin));
+      ASSERT_TRUE(st_comp(*it_result_begin)) << second_hmi_state->audio_streaming_state()  << "."
+                                             << second_hmi_state->hmi_level() << "."
+                                             << second_hmi_state->system_context() << "_"
+                                             << (*it_result_begin)->audio_streaming_state()  << "."
+                                             << (*it_result_begin)->hmi_level() << "."
+                                             << (*it_result_begin)->system_context() << "_";
     }
   }
 
   template <typename T, typename Q>
   void TestMixState(void (StateControllerTest::*call_back_result)(
-      std::vector<HmiStatePtr>&, ApplicationType)) {
+      std::vector<am::HmiStatePtr>&, ApplicationType)) {
     std::vector<am::ApplicationSharedPtr>::iterator it_begin =
         applications_list_.begin();
     std::vector<am::ApplicationSharedPtr>::iterator it_end =
@@ -526,9 +545,9 @@ class StateControllerTest : public ::testing::Test {
       app_id = (*it_begin)->app_id();
       app_type = AppType(app_id);
       app = (*it_begin);
-      HmiStatePtr state_first =
+      am::HmiStatePtr state_first =
           utils::MakeShared<T>(app_id, &app_manager_mock_);
-      HmiStatePtr state_second =
+      am::HmiStatePtr state_second =
           utils::MakeShared<Q>(app_id, &app_manager_mock_);
       TestSetSeveralState(
           app, state_first, state_second, app_type, call_back_result);
@@ -538,12 +557,12 @@ class StateControllerTest : public ::testing::Test {
   }
 
  protected:
-  am::ApplicationSharedPtr ConfigureApp(NiceMock<ApplicationMock>** app_mock,
+  am::ApplicationSharedPtr ConfigureApp(NiceMock<MockApplication>** app_mock,
                                         uint32_t app_id,
                                         bool media,
                                         bool navi,
                                         bool vc) {
-    *app_mock = new NiceMock<ApplicationMock>;
+    *app_mock = new NiceMock<MockApplication>;
 
     Mock::AllowLeak(*app_mock);  // WorkAround for gogletest bug
     am::ApplicationSharedPtr app(*app_mock);
@@ -568,7 +587,7 @@ class StateControllerTest : public ::testing::Test {
     namespace SystemContext = mobile_apis::SystemContext;
     // Valid states for not audio app
     message_helper_mock_ =
-            application_manager::MockMessageHelper::message_helper_mock();
+        application_manager::MockMessageHelper::message_helper_mock();
     valid_states_for_not_audio_app_.push_back(
         createHmiState(HMILevel::HMI_NONE,
                        AudioStreamingState::NOT_AUDIBLE,
@@ -665,10 +684,7 @@ class StateControllerTest : public ::testing::Test {
         createHmiState(HMILevel::INVALID_ENUM,
                        AudioStreamingState::INVALID_ENUM,
                        SystemContext::INVALID_ENUM));
-    common_invalid_states_.push_back(
-        createHmiState(HMILevel::INVALID_ENUM,
-                       AudioStreamingState::INVALID_ENUM,
-                       SystemContext::INVALID_ENUM));
+
     // Invalid States for audio apps
     invalid_states_for_audio_app.push_back(
         createHmiState(HMILevel::HMI_LIMITED,
@@ -713,11 +729,11 @@ class StateControllerTest : public ::testing::Test {
                        SystemContext::SYSCTXT_MAIN));
 
     // Valid state ids
-    valid_state_ids_.push_back(HmiState::StateID::STATE_ID_VR_SESSION);
-    valid_state_ids_.push_back(HmiState::StateID::STATE_ID_TTS_SESSION);
-    valid_state_ids_.push_back(HmiState::StateID::STATE_ID_PHONE_CALL);
-    valid_state_ids_.push_back(HmiState::StateID::STATE_ID_SAFETY_MODE);
-    valid_state_ids_.push_back(HmiState::StateID::STATE_ID_NAVI_STREAMING);
+    valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_VR_SESSION);
+    valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_TTS_SESSION);
+    valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_PHONE_CALL);
+    valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_SAFETY_MODE);
+    valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_NAVI_STREAMING);
   }
 
   void ConfigureApps() {
@@ -801,18 +817,43 @@ class StateControllerTest : public ::testing::Test {
     ASSERT_TRUE(media_navi_vc_app_->is_voice_communication_supported());
   }
 
-  void SetUp() {
+  virtual void SetUp() OVERRIDE {
     ON_CALL(app_manager_mock_, applications())
         .WillByDefault(Return(applications_));
     ConfigureApps();
     CheckAppConfiguration();
     FillStatesLists();
+    SetConnection();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    delete conn_handler;
+  }
+
+  void SetConnection() {
+    conn_handler = new connection_handler::ConnectionHandlerImpl(
+        mock_connection_handler_settings, mock_transport_manager);
+    ON_CALL(app_manager_mock_, connection_handler())
+        .WillByDefault(Return(conn_handler));
+  }
+
+  void SetBCActivateAppRequestToHMI(mobile_apis::HMILevel::eType set_lvl,
+                                    uint32_t corr_id) {
+    smart_objects::SmartObjectSPtr bc_activate_app_request =
+        new smart_objects::SmartObject();
+    const hmi_apis::Common_HMILevel::eType hmi_lvl =
+        static_cast<hmi_apis::Common_HMILevel::eType>(set_lvl);
+    (*bc_activate_app_request)[am::strings::params]
+                              [am::strings::correlation_id] = corr_id;
+    EXPECT_CALL(*message_helper_mock_,
+                GetBCActivateAppRequestToHMI(_, hmi_lvl, _))
+        .WillOnce(Return(bc_activate_app_request));
   }
 
   void ExpectSuccesfullSetHmiState(am::ApplicationSharedPtr app,
-                                   NiceMock<ApplicationMock>* app_mock,
-                                   HmiStatePtr old_state,
-                                   HmiStatePtr new_state) {
+                                   NiceMock<MockApplication>* app_mock,
+                                   am::HmiStatePtr old_state,
+                                   am::HmiStatePtr new_state) {
     EXPECT_CALL(*app_mock, CurrentHmiState())
         .WillOnce(Return(old_state))
         .WillOnce(Return(new_state));
@@ -829,9 +870,9 @@ class StateControllerTest : public ::testing::Test {
 
   void ExpectAppChangeHmiStateDueToConflictResolving(
       am::ApplicationSharedPtr app,
-      NiceMock<ApplicationMock>* app_mock,
-      HmiStatePtr old_state,
-      HmiStatePtr new_state) {
+      NiceMock<MockApplication>* app_mock,
+      am::HmiStatePtr old_state,
+      am::HmiStatePtr new_state) {
     EXPECT_CALL(*app_mock, RegularHmiState())
         .WillOnce(Return(old_state))
         .WillOnce(Return(old_state));
@@ -840,8 +881,8 @@ class StateControllerTest : public ::testing::Test {
 
   void ExpectAppWontChangeHmiStateDueToConflictResolving(
       am::ApplicationSharedPtr app,
-      NiceMock<ApplicationMock>* app_mock,
-      HmiStatePtr state) {
+      NiceMock<MockApplication>* app_mock,
+      am::HmiStatePtr state) {
     EXPECT_CALL(*app_mock, RegularHmiState()).WillOnce(Return(state));
     EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(app)).Times(0);
     EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(app->app_id(), _, _))
@@ -854,58 +895,58 @@ class StateControllerTest : public ::testing::Test {
         .WillByDefault(Return(app));
   }
 
-  HmiStatePtr NoneNotAudibleState() {
+  am::HmiStatePtr NoneNotAudibleState() {
     return createHmiState(mobile_apis::HMILevel::HMI_NONE,
                           mobile_apis::AudioStreamingState::NOT_AUDIBLE,
                           mobile_apis::SystemContext::SYSCTXT_MAIN);
   }
 
-  HmiStatePtr FullAudibleState() {
+  am::HmiStatePtr FullAudibleState() {
     return createHmiState(mobile_apis::HMILevel::HMI_FULL,
                           mobile_apis::AudioStreamingState::AUDIBLE,
                           mobile_apis::SystemContext::SYSCTXT_MAIN);
   }
 
-  HmiStatePtr FullNotAudibleState() {
+  am::HmiStatePtr FullNotAudibleState() {
     return createHmiState(mobile_apis::HMILevel::HMI_FULL,
                           mobile_apis::AudioStreamingState::NOT_AUDIBLE,
                           mobile_apis::SystemContext::SYSCTXT_MAIN);
   }
 
-  HmiStatePtr LimitedState() {
+  am::HmiStatePtr LimitedState() {
     return createHmiState(mobile_apis::HMILevel::HMI_LIMITED,
                           mobile_apis::AudioStreamingState::AUDIBLE,
                           mobile_apis::SystemContext::SYSCTXT_MAIN);
   }
 
-  HmiStatePtr BackgroundState() {
+  am::HmiStatePtr BackgroundState() {
     return createHmiState(mobile_apis::HMILevel::HMI_BACKGROUND,
                           mobile_apis::AudioStreamingState::NOT_AUDIBLE,
                           mobile_apis::SystemContext::SYSCTXT_MAIN);
   }
 
   void CheckStateApplyingForApplication(
-      NiceMock<ApplicationMock>& application,
-      std::vector<HmiState::StateID>& state_ids) {
+      NiceMock<MockApplication>& application,
+      std::vector<am::HmiState::StateID>& state_ids) {
     using smart_objects::SmartObject;
     using am::event_engine::Event;
     namespace FunctionID = hmi_apis::FunctionID;
+
     EXPECT_CALL(application, CurrentHmiState())
         .WillRepeatedly(Return(NoneNotAudibleState()));
 
     for (uint32_t i = 0; i < state_ids.size(); ++i) {
-      HmiState::StateID state_id = state_ids[i];
+      am::HmiState::StateID state_id = state_ids[i];
       EXPECT_CALL(application,
-                  AddHMIState(Truly(HmiStatesIDComparator(state_id))))
-          .Times(1);
+                  AddHMIState(Truly(HmiStatesIDComparator(state_id)))).Times(1);
 
       switch (state_id) {
-        case HmiState::StateID::STATE_ID_VR_SESSION: {
+        case am::HmiState::StateID::STATE_ID_VR_SESSION: {
           Event vr_start_event(FunctionID::VR_Started);
           state_ctrl_.on_event(vr_start_event);
           break;
         }
-        case HmiState::StateID::STATE_ID_TTS_SESSION: {
+        case am::HmiState::StateID::STATE_ID_TTS_SESSION: {
           Event tts_start_event(FunctionID::TTS_Started);
           state_ctrl_.on_event(tts_start_event);
           break;
@@ -921,9 +962,8 @@ class StateControllerTest : public ::testing::Test {
           state_ctrl_.on_event(phone_call_event);
           break;
         }
-        case HmiState::StateID::STATE_ID_SAFETY_MODE: {
-          Event emergency_event(
-              FunctionID::BasicCommunication_OnEventChanged);
+        case am::HmiState::StateID::STATE_ID_SAFETY_MODE: {
+          Event emergency_event(FunctionID::BasicCommunication_OnEventChanged);
           SmartObject message;
           message[am::strings::msg_params][am::hmi_notification::is_active] =
               true;
@@ -933,7 +973,7 @@ class StateControllerTest : public ::testing::Test {
           state_ctrl_.on_event(emergency_event);
           break;
         }
-        case HmiState::StateID::STATE_ID_NAVI_STREAMING: {
+        case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: {
           state_ctrl_.OnNaviStreamingStarted();
           break;
         }
@@ -945,7 +985,7 @@ class StateControllerTest : public ::testing::Test {
     }
 
     for (uint32_t i = 0; i < state_ids.size(); ++i) {
-      HmiState::StateID state_id = state_ids[i];
+      am::HmiState::StateID state_id = state_ids[i];
       EXPECT_CALL(application, RemoveHMIState(state_id)).Times(1);
 
       EXPECT_CALL(application, PostponedHmiState())
@@ -953,40 +993,39 @@ class StateControllerTest : public ::testing::Test {
       EXPECT_CALL(application, RemovePostponedState());
 
       switch (state_id) {
-        case HmiState::StateID::STATE_ID_VR_SESSION: {
+        case am::HmiState::StateID::STATE_ID_VR_SESSION: {
           Event vr_stop_event(FunctionID::VR_Stopped);
           state_ctrl_.on_event(vr_stop_event);
           break;
         }
-        case HmiState::StateID::STATE_ID_TTS_SESSION: {
+        case am::HmiState::StateID::STATE_ID_TTS_SESSION: {
           Event tts_stop_event(FunctionID::TTS_Stopped);
           state_ctrl_.on_event(tts_stop_event);
           break;
         }
         case am::HmiState::StateID::STATE_ID_PHONE_CALL: {
-        Event phone_call_event(FunctionID::BasicCommunication_OnEventChanged);
-        SmartObject message;
-        message[am::strings::msg_params][am::hmi_notification::is_active] =
-            false;
-        message[am::strings::msg_params][am::hmi_notification::event_name] =
-            hmi_apis::Common_EventTypes::PHONE_CALL;
+          Event phone_call_event(FunctionID::BasicCommunication_OnEventChanged);
+          SmartObject message;
+          message[am::strings::msg_params][am::hmi_notification::is_active] =
+              false;
+          message[am::strings::msg_params][am::hmi_notification::event_name] =
+              hmi_apis::Common_EventTypes::PHONE_CALL;
           phone_call_event.set_smart_object(message);
           state_ctrl_.on_event(phone_call_event);
           break;
         }
         case am::HmiState::StateID::STATE_ID_SAFETY_MODE: {
-        Event emergency_event(
-            FunctionID::BasicCommunication_OnEventChanged);
-        SmartObject message;
-        message[am::strings::msg_params][am::hmi_notification::is_active] =
-            false;
-        message[am::strings::msg_params][am::hmi_notification::event_name] =
-            hmi_apis::Common_EventTypes::EMERGENCY_EVENT;
+          Event emergency_event(FunctionID::BasicCommunication_OnEventChanged);
+          SmartObject message;
+          message[am::strings::msg_params][am::hmi_notification::is_active] =
+              false;
+          message[am::strings::msg_params][am::hmi_notification::event_name] =
+              hmi_apis::Common_EventTypes::EMERGENCY_EVENT;
           emergency_event.set_smart_object(message);
           state_ctrl_.on_event(emergency_event);
           break;
         }
-        case HmiState::StateID::STATE_ID_NAVI_STREAMING: {
+        case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: {
           state_ctrl_.OnNaviStreamingStopped();
           break;
         }
@@ -1087,13 +1126,13 @@ TEST_F(StateControllerTest, MoveSimpleAppToValidStates) {
   }
 }
 
-TEST_F(StateControllerTest, MoveAudioAppAppToValidStates) {
+TEST_F(StateControllerTest, MoveAudioNotResumeAppToValidStates) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
   am::ApplicationSharedPtr audio_app = media_navi_vc_app_;
-  NiceMock<ApplicationMock>* audio_app_mock = media_navi_vc_app_ptr_;
+  NiceMock<MockApplication>* audio_app_mock = media_navi_vc_app_ptr_;
 
   HmiStatePtr initial_state = createHmiState(HMILevel::INVALID_ENUM,
                                              AudioStreamingState::INVALID_ENUM,
@@ -1126,26 +1165,26 @@ TEST_F(StateControllerTest, MoveAudioResumeAppToValidStates) {
   namespace SystemContext = mobile_apis::SystemContext;
 
   am::ApplicationSharedPtr audio_app = media_navi_vc_app_;
-  NiceMock<ApplicationMock>* audio_app_mock = media_navi_vc_app_ptr_;
+  NiceMock<MockApplication>* audio_app_mock = media_navi_vc_app_ptr_;
 
-  HmiStatePtr initial_state =
-      createHmiState(HMILevel::INVALID_ENUM, AudioStreamingState::INVALID_ENUM,
-                     SystemContext::INVALID_ENUM);
+  HmiStatePtr initial_state = createHmiState(HMILevel::INVALID_ENUM,
+                                             AudioStreamingState::INVALID_ENUM,
+                                             SystemContext::INVALID_ENUM);
 
   // Set all valid states for audio app
   for (std::vector<HmiStatePtr>::iterator it =
            valid_states_for_audio_app_.begin();
-       it != valid_states_for_audio_app_.end(); ++it) {
+       it != valid_states_for_audio_app_.end();
+       ++it) {
     HmiStatePtr state_to_setup = *it;
     HmiStatePtr state_to_check = state_to_setup;
-    //First time current state is initial, then it changes to setup state
+    // First time current state is initial, then it changes to setup state
     EXPECT_CALL(*audio_app_mock, CurrentHmiState())
         .WillOnce(Return(initial_state))
         .WillOnce(Return(state_to_setup));
     // Audio resume app when HMI level is LIMITED or FULL gets audible state
     if (state_to_setup->hmi_level() == HMILevel::HMI_LIMITED) {
-      EXPECT_CALL(*audio_app_mock, is_resuming())
-          .WillRepeatedly(Return(true));
+      EXPECT_CALL(*audio_app_mock, is_resuming()).WillRepeatedly(Return(true));
       EXPECT_CALL(*message_helper_mock_,
                   SendOnResumeAudioSourceToHMI(media_navi_vc_app_id_));
       state_to_check->set_audio_streaming_state(AudioStreamingState::AUDIBLE);
@@ -1154,17 +1193,17 @@ TEST_F(StateControllerTest, MoveAudioResumeAppToValidStates) {
       if (state_to_setup->hmi_level() == HMILevel::HMI_FULL) {
         state_to_check->set_audio_streaming_state(AudioStreamingState::AUDIBLE);
       }
-      EXPECT_CALL(*audio_app_mock, is_resuming())
-          .WillRepeatedly(Return(true));
+      EXPECT_CALL(*audio_app_mock, is_resuming()).WillRepeatedly(Return(true));
     }
     EXPECT_CALL(app_manager_mock_, active_application())
         .WillRepeatedly(Return(am::ApplicationSharedPtr()));
     EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(audio_app))
         .Times(AtLeast(0));
-    EXPECT_CALL(
-        app_manager_mock_,
-        OnHMILevelChanged(audio_app->app_id(), initial_state->hmi_level(),
-                          state_to_setup->hmi_level())).Times(AtLeast(0));
+    EXPECT_CALL(app_manager_mock_,
+                OnHMILevelChanged(audio_app->app_id(),
+                                  initial_state->hmi_level(),
+                                  state_to_setup->hmi_level()))
+        .Times(AtLeast(0));
 
     // Check that we set correct state
     EXPECT_CALL(*audio_app_mock,
@@ -1175,6 +1214,8 @@ TEST_F(StateControllerTest, MoveAudioResumeAppToValidStates) {
 }
 
 TEST_F(StateControllerTest, MoveAppFromValidStateToInvalid) {
+  using am::HmiState;
+  using am::HmiStatePtr;
   for (std::vector<HmiStatePtr>::iterator invalid_state_it =
            common_invalid_states_.begin();
        invalid_state_it != common_invalid_states_.end();
@@ -1205,10 +1246,10 @@ TEST_F(StateControllerTest, SetFullToSimpleAppWhileAnotherSimpleAppIsInFull) {
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
   am::ApplicationSharedPtr app_in_full;
-  NiceMock<ApplicationMock>* app_in_full_mock;
+  NiceMock<MockApplication>* app_in_full_mock;
 
   am::ApplicationSharedPtr app_moved_to_full;
-  NiceMock<ApplicationMock>* app_moved_to_full_mock;
+  NiceMock<MockApplication>* app_moved_to_full_mock;
 
   app_in_full =
       ConfigureApp(&app_in_full_mock, 1761, NOT_MEDIA, NOT_NAVI, NOT_VC);
@@ -1234,10 +1275,10 @@ TEST_F(StateControllerTest, SetFullToSimpleAppWhileAudioAppAppIsInFull) {
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
   am::ApplicationSharedPtr app_in_full = media_navi_vc_app_;
-  NiceMock<ApplicationMock>* app_in_full_mock = media_navi_vc_app_ptr_;
+  NiceMock<MockApplication>* app_in_full_mock = media_navi_vc_app_ptr_;
 
   am::ApplicationSharedPtr app_moved_to_full = simple_app_;
-  NiceMock<ApplicationMock>* app_moved_to_full_mock = simple_app_ptr_;
+  NiceMock<MockApplication>* app_moved_to_full_mock = simple_app_ptr_;
 
   InsertApplication(app_in_full);
   InsertApplication(app_moved_to_full);
@@ -1259,10 +1300,10 @@ TEST_F(StateControllerTest,
   namespace SystemContext = mobile_apis::SystemContext;
 
   am::ApplicationSharedPtr app_in_full = media_app_;
-  NiceMock<ApplicationMock>* app_in_full_mock = media_app_ptr_;
+  NiceMock<MockApplication>* app_in_full_mock = media_app_ptr_;
 
   am::ApplicationSharedPtr app_moved_to_full = navi_app_;
-  NiceMock<ApplicationMock>* app_moved_to_full_mock = navi_app_ptr_;
+  NiceMock<MockApplication>* app_moved_to_full_mock = navi_app_ptr_;
 
   InsertApplication(app_in_full);
   InsertApplication(app_moved_to_full);
@@ -1282,11 +1323,11 @@ TEST_F(StateControllerTest,
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
-  NiceMock<ApplicationMock>* app_in_full_mock;
+  NiceMock<MockApplication>* app_in_full_mock;
   am::ApplicationSharedPtr app_in_full =
       ConfigureApp(&app_in_full_mock, 1761, MEDIA, NOT_NAVI, NOT_VC);
 
-  NiceMock<ApplicationMock>* app_moved_to_full_mock;
+  NiceMock<MockApplication>* app_moved_to_full_mock;
   am::ApplicationSharedPtr app_moved_to_full =
       ConfigureApp(&app_moved_to_full_mock, 1796, MEDIA, NOT_NAVI, NOT_VC);
 
@@ -1309,11 +1350,11 @@ TEST_F(StateControllerTest,
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
-  NiceMock<ApplicationMock>* app_in_limited_mock;
+  NiceMock<MockApplication>* app_in_limited_mock;
   am::ApplicationSharedPtr app_in_limited =
       ConfigureApp(&app_in_limited_mock, 1761, NOT_MEDIA, NAVI, NOT_VC);
 
-  NiceMock<ApplicationMock>* app_moved_to_full_mock;
+  NiceMock<MockApplication>* app_moved_to_full_mock;
   am::ApplicationSharedPtr app_moved_to_full =
       ConfigureApp(&app_moved_to_full_mock, 1796, NOT_MEDIA, NAVI, VC);
 
@@ -1335,11 +1376,11 @@ TEST_F(StateControllerTest,
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
-  NiceMock<ApplicationMock>* app_in_limited_mock;
+  NiceMock<MockApplication>* app_in_limited_mock;
   am::ApplicationSharedPtr app_in_limited =
       ConfigureApp(&app_in_limited_mock, 1761, NOT_MEDIA, NOT_NAVI, VC);
 
-  NiceMock<ApplicationMock>* app_moved_to_limited_mock;
+  NiceMock<MockApplication>* app_moved_to_limited_mock;
   am::ApplicationSharedPtr app_moved_to_limited =
       ConfigureApp(&app_moved_to_limited_mock, 1796, NOT_MEDIA, NOT_NAVI, VC);
 
@@ -1364,10 +1405,10 @@ TEST_F(StateControllerTest,
   namespace SystemContext = mobile_apis::SystemContext;
 
   am::ApplicationSharedPtr app_in_limited = navi_app_;
-  NiceMock<ApplicationMock>* app_in_limited_mock = navi_app_ptr_;
+  NiceMock<MockApplication>* app_in_limited_mock = navi_app_ptr_;
 
   am::ApplicationSharedPtr app_moved_to_limited = vc_app_;
-  NiceMock<ApplicationMock>* app_moved_to_limited_mock = vc_app_ptr_;
+  NiceMock<MockApplication>* app_moved_to_limited_mock = vc_app_ptr_;
 
   InsertApplication(app_in_limited);
   InsertApplication(app_moved_to_limited);
@@ -1386,10 +1427,10 @@ TEST_F(StateControllerTest,
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
   am::ApplicationSharedPtr app_in_full = navi_app_;
-  NiceMock<ApplicationMock>* app_in_full_mock = navi_app_ptr_;
+  NiceMock<MockApplication>* app_in_full_mock = navi_app_ptr_;
 
   am::ApplicationSharedPtr app_moved_to_limited = vc_app_;
-  NiceMock<ApplicationMock>* app_moved_to_limited_mock = vc_app_ptr_;
+  NiceMock<MockApplication>* app_moved_to_limited_mock = vc_app_ptr_;
 
   InsertApplication(app_in_full);
   InsertApplication(app_moved_to_limited);
@@ -1410,13 +1451,13 @@ TEST_F(StateControllerTest, SetFullToSimpleAppWhile2AudioAppsInLimited) {
   namespace SystemContext = mobile_apis::SystemContext;
 
   am::ApplicationSharedPtr app_moved_to_full = simple_app_;
-  NiceMock<ApplicationMock>* app_moved_to_full_mock = simple_app_ptr_;
+  NiceMock<MockApplication>* app_moved_to_full_mock = simple_app_ptr_;
 
   am::ApplicationSharedPtr limited_app1 = media_app_;
-  NiceMock<ApplicationMock>* limited_app1_mock = media_app_ptr_;
+  NiceMock<MockApplication>* limited_app1_mock = media_app_ptr_;
 
   am::ApplicationSharedPtr limited_app2 = navi_vc_app_;
-  NiceMock<ApplicationMock>* limited_app2_mock = navi_vc_app_ptr_;
+  NiceMock<MockApplication>* limited_app2_mock = navi_vc_app_ptr_;
 
   InsertApplication(app_moved_to_full);
   InsertApplication(limited_app1);
@@ -1442,13 +1483,13 @@ TEST_F(StateControllerTest,
   namespace SystemContext = mobile_apis::SystemContext;
 
   am::ApplicationSharedPtr app_moved_to_full = simple_app_;
-  NiceMock<ApplicationMock>* app_moved_to_full_mock = simple_app_ptr_;
+  NiceMock<MockApplication>* app_moved_to_full_mock = simple_app_ptr_;
 
   am::ApplicationSharedPtr limited_app = media_app_;
-  NiceMock<ApplicationMock>* limited_app_mock = media_app_ptr_;
+  NiceMock<MockApplication>* limited_app_mock = media_app_ptr_;
 
   am::ApplicationSharedPtr full_app = navi_vc_app_;
-  NiceMock<ApplicationMock>* full_app_mock = navi_vc_app_ptr_;
+  NiceMock<MockApplication>* full_app_mock = navi_vc_app_ptr_;
 
   InsertApplication(app_moved_to_full);
   InsertApplication(limited_app);
@@ -1474,14 +1515,14 @@ TEST_F(StateControllerTest,
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
-  NiceMock<ApplicationMock>* app_moved_to_full_mock;
+  NiceMock<MockApplication>* app_moved_to_full_mock;
   am::ApplicationSharedPtr app_moved_to_full =
       ConfigureApp(&app_moved_to_full_mock, 1761, NOT_MEDIA, NOT_NAVI, NOT_VC);
 
   am::ApplicationSharedPtr limited_app = media_app_;
-  NiceMock<ApplicationMock>* limited_app_mock = media_app_ptr_;
+  NiceMock<MockApplication>* limited_app_mock = media_app_ptr_;
 
-  NiceMock<ApplicationMock>* full_app_mock;
+  NiceMock<MockApplication>* full_app_mock;
   am::ApplicationSharedPtr full_app =
       ConfigureApp(&full_app_mock, 1796, NOT_MEDIA, NOT_NAVI, NOT_VC);
 
@@ -1510,15 +1551,15 @@ TEST_F(
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
-  NiceMock<ApplicationMock>* app_moved_to_full_mock;
+  NiceMock<MockApplication>* app_moved_to_full_mock;
   am::ApplicationSharedPtr app_moved_to_full =
       ConfigureApp(&app_moved_to_full_mock, 1761, MEDIA, NOT_NAVI, NOT_VC);
 
-  NiceMock<ApplicationMock>* limited_app_mock;
+  NiceMock<MockApplication>* limited_app_mock;
   am::ApplicationSharedPtr limited_app =
       ConfigureApp(&limited_app_mock, 1762, MEDIA, NOT_NAVI, NOT_VC);
 
-  NiceMock<ApplicationMock>* full_app_mock;
+  NiceMock<MockApplication>* full_app_mock;
   am::ApplicationSharedPtr full_app =
       ConfigureApp(&full_app_mock, 1796, NOT_MEDIA, NOT_NAVI, NOT_VC);
 
@@ -1547,15 +1588,15 @@ TEST_F(
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
-  NiceMock<ApplicationMock>* app_moved_to_full_mock;
+  NiceMock<MockApplication>* app_moved_to_full_mock;
   am::ApplicationSharedPtr app_moved_to_full =
       ConfigureApp(&app_moved_to_full_mock, 1761, MEDIA, NOT_NAVI, NOT_VC);
 
-  NiceMock<ApplicationMock>* limited_app_mock;
+  NiceMock<MockApplication>* limited_app_mock;
   am::ApplicationSharedPtr limited_app =
       ConfigureApp(&limited_app_mock, 1762, MEDIA, NOT_NAVI, NOT_VC);
 
-  NiceMock<ApplicationMock>* full_app_mock;
+  NiceMock<MockApplication>* full_app_mock;
   am::ApplicationSharedPtr full_app =
       ConfigureApp(&full_app_mock, 1796, NOT_MEDIA, NAVI, NOT_VC);
 
@@ -1629,7 +1670,7 @@ TEST_F(StateControllerTest, ActivateAppSuccessReceivedFromHMI) {
 
   const uint32_t corr_id = 314;
   const uint32_t hmi_app_id = 2718;
-  typedef std::pair<HmiStatePtr, Common_HMILevel::eType> StateLevelPair;
+  typedef std::pair<am::HmiStatePtr, Common_HMILevel::eType> StateLevelPair;
   std::vector<StateLevelPair> hmi_states;
   hmi_states.push_back(
       StateLevelPair(FullAudibleState(), Common_HMILevel::FULL));
@@ -1647,15 +1688,21 @@ TEST_F(StateControllerTest, ActivateAppSuccessReceivedFromHMI) {
   std::vector<StateLevelPair> initial_hmi_states = hmi_states;
   std::vector<StateLevelPair>::iterator it = hmi_states.begin();
   std::vector<StateLevelPair>::iterator it2 = initial_hmi_states.begin();
+  smart_objects::SmartObjectSPtr bc_activate_app_request =
+      new smart_objects::SmartObject();
+  (*bc_activate_app_request)[am::strings::params][am::strings::correlation_id] =
+      corr_id;
+
   for (; it != hmi_states.end(); ++it) {
     for (; it2 != initial_hmi_states.end(); ++it2) {
-      HmiStatePtr hmi_state = it->first;
-      HmiStatePtr initial_hmi_state = it->first;
+      am::HmiStatePtr hmi_state = it->first;
+      am::HmiStatePtr initial_hmi_state = it->first;
       Common_HMILevel::eType hmi_level = it->second;
 
       EXPECT_CALL(*message_helper_mock_,
-                  SendActivateAppToHMI(media_app_->app_id(), hmi_level, _))
-          .WillOnce(Return(corr_id));
+                  GetBCActivateAppRequestToHMI(_, hmi_level, _))
+          .WillOnce(Return(bc_activate_app_request));
+
       EXPECT_CALL(app_manager_mock_, application_id(corr_id))
           .WillOnce(Return(hmi_app_id));
       EXPECT_CALL(app_manager_mock_, application_by_hmi_app(hmi_app_id))
@@ -1675,14 +1722,73 @@ TEST_F(StateControllerTest, ActivateAppSuccessReceivedFromHMI) {
   }
 }
 
+std::vector<hmi_apis::Common_Result::eType> hmi_result() {
+  using namespace hmi_apis;
+  std::vector<Common_Result::eType> hmi_results;
+  hmi_results.push_back(Common_Result::ABORTED);
+  hmi_results.push_back(Common_Result::APPLICATION_NOT_REGISTERED);
+  hmi_results.push_back(Common_Result::CHAR_LIMIT_EXCEEDED);
+  hmi_results.push_back(Common_Result::DATA_NOT_AVAILABLE);
+  hmi_results.push_back(Common_Result::DISALLOWED);
+  hmi_results.push_back(Common_Result::DUPLICATE_NAME);
+  hmi_results.push_back(Common_Result::GENERIC_ERROR);
+  hmi_results.push_back(Common_Result::IGNORED);
+  hmi_results.push_back(Common_Result::INVALID_DATA);
+  hmi_results.push_back(Common_Result::INVALID_ENUM);
+  hmi_results.push_back(Common_Result::INVALID_ID);
+  hmi_results.push_back(Common_Result::IN_USE);
+  hmi_results.push_back(Common_Result::NO_APPS_REGISTERED);
+  hmi_results.push_back(Common_Result::NO_DEVICES_CONNECTED);
+  hmi_results.push_back(Common_Result::OUT_OF_MEMORY);
+  hmi_results.push_back(Common_Result::REJECTED);
+  hmi_results.push_back(Common_Result::RETRY);
+  hmi_results.push_back(Common_Result::TIMED_OUT);
+  hmi_results.push_back(Common_Result::TOO_MANY_PENDING_REQUESTS);
+  hmi_results.push_back(Common_Result::TRUNCATED_DATA);
+  hmi_results.push_back(Common_Result::UNSUPPORTED_REQUEST);
+  hmi_results.push_back(Common_Result::UNSUPPORTED_RESOURCE);
+  hmi_results.push_back(Common_Result::USER_DISALLOWED);
+  hmi_results.push_back(Common_Result::WARNINGS);
+  hmi_results.push_back(Common_Result::WRONG_LANGUAGE);
+  return hmi_results;
+}
+
+TEST_F(StateControllerTest, SendEventBCActivateApp_HMIReceivesError) {
+  using namespace hmi_apis;
+  const uint32_t corr_id = 314;
+  const uint32_t hmi_app_id = 2718;
+  std::vector<Common_Result::eType> hmi_results = hmi_result();
+
+  std::vector<Common_Result::eType>::iterator it = hmi_results.begin();
+  for (; it != hmi_results.end(); ++it) {
+    EXPECT_CALL(app_manager_mock_, application_id(corr_id))
+        .WillOnce(Return(hmi_app_id));
+    EXPECT_CALL(app_manager_mock_, application_by_hmi_app(hmi_app_id))
+        .WillOnce(Return(simple_app_));
+
+    EXPECT_CALL(*simple_app_ptr_, RegularHmiState()).Times(0);
+    EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()).Times(0);
+    EXPECT_CALL(*simple_app_ptr_, SetRegularState(_)).Times(0);
+
+    EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(simple_app_))
+        .Times(0);
+    EXPECT_CALL(app_manager_mock_,
+                OnHMILevelChanged(simple_app_->app_id(), _, _)).Times(0);
+
+    smart_objects::SmartObject message;
+    message[am::strings::params][am::hmi_response::code] = *it;
+    message[am::strings::params][am::strings::correlation_id] = corr_id;
+    am::event_engine::Event event(FunctionID::BasicCommunication_ActivateApp);
+    event.set_smart_object(message);
+    state_ctrl_.on_event(event);
+  }
+}
+
 TEST_F(StateControllerTest, ActivateAppInvalidCorrelationId) {
   using namespace hmi_apis;
   const uint32_t corr_id = 314;
   const uint32_t hmi_app_id = 2718;
-  EXPECT_CALL(
-      *message_helper_mock_,
-      SendActivateAppToHMI(simple_app_->app_id(), Common_HMILevel::FULL, _))
-      .WillOnce(Return(hmi_app_id));
+
   EXPECT_CALL(app_manager_mock_, application_id(corr_id))
       .WillOnce(Return(hmi_app_id));
   EXPECT_CALL(app_manager_mock_, application_by_hmi_app(hmi_app_id))
@@ -1692,6 +1798,7 @@ TEST_F(StateControllerTest, ActivateAppInvalidCorrelationId) {
       .Times(0);
   EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(simple_app_->app_id(), _, _))
       .Times(0);
+  SetBCActivateAppRequestToHMI(mobile_apis::HMILevel::HMI_FULL, corr_id);
   state_ctrl_.SetRegularState<true>(simple_app_, FullNotAudibleState());
   smart_objects::SmartObject message;
   message[am::strings::params][am::hmi_response::code] = Common_Result::SUCCESS;
@@ -1742,7 +1849,7 @@ TEST_F(StateControllerTest, ApplyTempStatesForMediaNaviVCApp) {
 }
 
 TEST_F(StateControllerTest, SetStatePhoneCallForNonMediaApplication) {
-  HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
+  am::HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
       simple_app_id_, &app_manager_mock_);
   TestSetState(simple_app_,
                state_phone_call,
@@ -1751,7 +1858,7 @@ TEST_F(StateControllerTest, SetStatePhoneCallForNonMediaApplication) {
 }
 
 TEST_F(StateControllerTest, SetStatePhoneCallForMediaApplication) {
-  HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
+  am::HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
       media_app_id_, &app_manager_mock_);
   TestSetState(media_app_,
                state_phone_call,
@@ -1760,7 +1867,7 @@ TEST_F(StateControllerTest, SetStatePhoneCallForMediaApplication) {
 }
 
 TEST_F(StateControllerTest, SetStatePhoneCallForMediaNaviApplication) {
-  HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
+  am::HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
       media_navi_app_id_, &app_manager_mock_);
   TestSetState(media_navi_app_,
                state_phone_call,
@@ -1769,7 +1876,7 @@ TEST_F(StateControllerTest, SetStatePhoneCallForMediaNaviApplication) {
 }
 
 TEST_F(StateControllerTest, SetVRStateForNonMediaApplication) {
-  HmiStatePtr state_vr =
+  am::HmiStatePtr state_vr =
       utils::MakeShared<am::VRHmiState>(simple_app_id_, &app_manager_mock_);
   TestSetState(simple_app_,
                state_vr,
@@ -1778,7 +1885,7 @@ TEST_F(StateControllerTest, SetVRStateForNonMediaApplication) {
 }
 
 TEST_F(StateControllerTest, SetVRStateForMediaApplication) {
-  HmiStatePtr state_vr =
+  am::HmiStatePtr state_vr =
       utils::MakeShared<am::VRHmiState>(media_app_id_, &app_manager_mock_);
   TestSetState(media_app_,
                state_vr,
@@ -1787,7 +1894,7 @@ TEST_F(StateControllerTest, SetVRStateForMediaApplication) {
 }
 
 TEST_F(StateControllerTest, SetVRStateForMediaNaviVoiceApplication) {
-  HmiStatePtr state_vr = utils::MakeShared<am::VRHmiState>(
+  am::HmiStatePtr state_vr = utils::MakeShared<am::VRHmiState>(
       media_navi_vc_app_id_, &app_manager_mock_);
   TestSetState(media_navi_vc_app_,
                state_vr,
@@ -1797,7 +1904,7 @@ TEST_F(StateControllerTest, SetVRStateForMediaNaviVoiceApplication) {
 
 TEST_F(StateControllerTest,
        SetTTSStateForNonMediaApplicationAttenuatedNotSupported) {
-  HmiStatePtr state_tts =
+  am::HmiStatePtr state_tts =
       utils::MakeShared<am::TTSHmiState>(simple_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
@@ -1809,7 +1916,7 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetTTSStateForNonMediaApplicationAttenuatedSupported) {
-  HmiStatePtr state_tts =
+  am::HmiStatePtr state_tts =
       utils::MakeShared<am::TTSHmiState>(simple_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
@@ -1821,7 +1928,7 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetTTSStateForMediaApplicationAttenuatedNotSupported) {
-  HmiStatePtr state_tts =
+  am::HmiStatePtr state_tts =
       utils::MakeShared<am::TTSHmiState>(media_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
@@ -1832,19 +1939,19 @@ TEST_F(StateControllerTest,
 }
 
 TEST_F(StateControllerTest, SetTTSStateForMediaApplicationAttenuatedSupported) {
-  HmiStatePtr state_tts =
+  am::HmiStatePtr state_tts =
       utils::MakeShared<am::TTSHmiState>(media_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
   TestSetState(media_app_,
                state_tts,
-               APPTYPE_ATTENUATED,
+               APP_TYPE_ATTENUATED,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
 TEST_F(StateControllerTest,
        SetTTSStateForMediaNaviVCApplicationAttenuatedNotSupported) {
-  HmiStatePtr state_tts = utils::MakeShared<am::TTSHmiState>(
+  am::HmiStatePtr state_tts = utils::MakeShared<am::TTSHmiState>(
       media_navi_vc_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
@@ -1856,18 +1963,18 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetTTSStateForMediaNaviVCApplicationAttenuatedSupported) {
-  HmiStatePtr state_tts = utils::MakeShared<am::TTSHmiState>(
+  am::HmiStatePtr state_tts = utils::MakeShared<am::TTSHmiState>(
       media_navi_vc_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
   TestSetState(media_navi_vc_app_,
                state_tts,
-               APPTYPE_ATTENUATED,
+               APP_TYPE_ATTENUATED,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
 TEST_F(StateControllerTest, SetNaviStreamingStateForNonMediaApplication) {
-  HmiStatePtr state_navi_streming =
+  am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(simple_app_id_,
                                                    &app_manager_mock_);
   TestSetState(simple_app_,
@@ -1878,7 +1985,7 @@ TEST_F(StateControllerTest, SetNaviStreamingStateForNonMediaApplication) {
 
 TEST_F(StateControllerTest,
        SetNaviStreamingStateMediaApplicationAttenuatedNotSupported) {
-  HmiStatePtr state_navi_streming =
+  am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(media_app_id_,
                                                    &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
@@ -1891,20 +1998,20 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetNaviStreamingStateMediaApplicationAttenuatedSupported) {
-  HmiStatePtr state_navi_streming =
+  am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(media_app_id_,
                                                    &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
   TestSetState(media_app_,
                state_navi_streming,
-               APPTYPE_ATTENUATED,
+               APP_TYPE_ATTENUATED,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
 TEST_F(StateControllerTest,
        SetNaviStreamingStateVCApplicationAttenuatedNotSupported) {
-  HmiStatePtr state_navi_streming =
+  am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(vc_app_id_,
                                                    &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
@@ -1917,19 +2024,19 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetNaviStreamingStateVCApplicationAttenuatedSupported) {
-  HmiStatePtr state_navi_streming =
+  am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(vc_app_id_,
                                                    &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
   TestSetState(vc_app_,
                state_navi_streming,
-               APPTYPE_ATTENUATED,
+               APP_TYPE_ATTENUATED,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
 TEST_F(StateControllerTest, SetNaviStreamingStateNaviApplication) {
-  HmiStatePtr state_navi_streming =
+  am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(navi_app_id_,
                                                    &app_manager_mock_);
   TestSetState(navi_app_,
@@ -1939,7 +2046,7 @@ TEST_F(StateControllerTest, SetNaviStreamingStateNaviApplication) {
 }
 
 TEST_F(StateControllerTest, SetNaviStreamingStateMediaNaviApplication) {
-  HmiStatePtr state_navi_streming =
+  am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(media_navi_app_id_,
                                                    &app_manager_mock_);
   TestSetState(media_navi_app_,
@@ -1949,7 +2056,7 @@ TEST_F(StateControllerTest, SetNaviStreamingStateMediaNaviApplication) {
 }
 
 TEST_F(StateControllerTest, SetSafetyModeStateForNonMediaApplication) {
-  HmiStatePtr state_safety_mode = utils::MakeShared<am::SafetyModeHmiState>(
+  am::HmiStatePtr state_safety_mode = utils::MakeShared<am::SafetyModeHmiState>(
       simple_app_id_, &app_manager_mock_);
   TestSetState(simple_app_,
                state_safety_mode,
@@ -1958,7 +2065,7 @@ TEST_F(StateControllerTest, SetSafetyModeStateForNonMediaApplication) {
 }
 
 TEST_F(StateControllerTest, SetSafetyModeStateForMediaApplication) {
-  HmiStatePtr state_safety_mode =
+  am::HmiStatePtr state_safety_mode =
       utils::MakeShared<am::VRHmiState>(media_app_id_, &app_manager_mock_);
   TestSetState(media_app_,
                state_safety_mode,
@@ -1967,7 +2074,7 @@ TEST_F(StateControllerTest, SetSafetyModeStateForMediaApplication) {
 }
 
 TEST_F(StateControllerTest, SetSafetyModeStateForMediaNaviVoiceApplication) {
-  HmiStatePtr state_safety_mode = utils::MakeShared<am::VRHmiState>(
+  am::HmiStatePtr state_safety_mode = utils::MakeShared<am::VRHmiState>(
       media_navi_vc_app_id_, &app_manager_mock_);
   TestSetState(media_navi_vc_app_,
                state_safety_mode,
@@ -2130,13 +2237,9 @@ TEST_F(StateControllerTest, SetRegularStateWithNewHmiLvl) {
   set_lvl = HMILevel::HMI_FULL;
   EXPECT_CALL(*simple_app_ptr_, RegularHmiState())
       .WillOnce(Return(BackgroundState()));
+
   const uint32_t corr_id = 314;
-  EXPECT_CALL(*message_helper_mock_,
-              SendActivateAppToHMI(
-                  simple_app_->app_id(),
-                  static_cast<hmi_apis::Common_HMILevel::eType>(set_lvl),
-                  _))
-      .WillOnce(Return(corr_id));
+  SetBCActivateAppRequestToHMI(set_lvl, corr_id);
 
   state_ctrl_.SetRegularState(simple_app_, set_lvl);
 
@@ -2180,8 +2283,7 @@ TEST_F(StateControllerTest,
   HmiStatePtr check_state = FullNotAudibleState();
 
   // Non-media app can't have LIMITED-AUDIO state
-  EXPECT_CALL(*simple_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
   EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()).Times(0);
   EXPECT_CALL(*simple_app_ptr_, SetRegularState(_)).Times(0);
   EXPECT_CALL(app_manager_mock_, GetDefaultHmiLevel(_))
@@ -2193,8 +2295,7 @@ TEST_F(StateControllerTest,
   state_ctrl_.SetRegularState<false>(simple_app_, check_state);
 
   check_state = LimitedState();
-  EXPECT_CALL(*media_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
   EXPECT_CALL(*media_app_ptr_, CurrentHmiState()).Times(0);
   EXPECT_CALL(*media_app_ptr_, SetRegularState(_)).Times(0);
   EXPECT_CALL(*media_app_ptr_,
@@ -2220,8 +2321,7 @@ TEST_F(StateControllerTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) {
       .WillOnce(Return(check_state))
       .WillOnce(Return(check_state));
 
-  EXPECT_CALL(*simple_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(false));
+  EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(false));
 
   EXPECT_CALL(*message_helper_mock_,
               SendOnResumeAudioSourceToHMI(simple_app_id_)).Times(0);
@@ -2239,8 +2339,7 @@ TEST_F(StateControllerTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) {
       .WillOnce(Return(check_state))
       .WillOnce(Return(check_state));
 
-  EXPECT_CALL(*media_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
 
   EXPECT_CALL(*message_helper_mock_,
               SendOnResumeAudioSourceToHMI(media_app_id_));
@@ -2270,8 +2369,7 @@ TEST_F(StateControllerTest,
 
   // Non-media app can't have LIMITED-AUDIO state
   HmiStatePtr check_state = FullNotAudibleState();
-  EXPECT_CALL(*simple_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
 
   EXPECT_CALL(*simple_app_ptr_, RegularHmiState()).Times(0);
   EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()).Times(0);
@@ -2286,8 +2384,7 @@ TEST_F(StateControllerTest,
 
   // Set media app
   check_state = LimitedState();
-  EXPECT_CALL(*media_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
 
   EXPECT_CALL(*media_app_ptr_, RegularHmiState()).Times(0);
   EXPECT_CALL(*media_app_ptr_, CurrentHmiState()).Times(0);
@@ -2314,22 +2411,24 @@ TEST_F(StateControllerTest,
   event.set_smart_object(message);
   state_ctrl_.on_event(event);
 
-  HmiStatePtr check_state = FullAudibleState();
+  am::HmiStatePtr check_state = FullAudibleState();
 
-  EXPECT_CALL(*media_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
 
   EXPECT_CALL(*media_app_ptr_, is_media_application())
       .WillRepeatedly(Return(true));
 
   EXPECT_CALL(app_manager_mock_, IsAppTypeExistsInFullOrLimited(_))
-              .WillRepeatedly(Return(false));
+      .WillRepeatedly(Return(false));
 
   EXPECT_CALL(app_manager_mock_, active_application())
-              .WillRepeatedly(Return(am::ApplicationSharedPtr()));
+      .WillRepeatedly(Return(am::ApplicationSharedPtr()));
 
   EXPECT_CALL(*media_app_ptr_,
               SetPostponedState(Truly(HmiStatesComparator(check_state))));
   state_ctrl_.SetRegularState<false>(media_app_, check_state);
 }
+
 }  // namespace state_controller_test
+}  // namespace components
+}  // namespace test
author	Kozoriz <kozorizandriy@gmail.com>	2016-02-29 10:31:36 +0200
committer	Kozoriz <kozorizandriy@gmail.com>	2016-03-04 10:11:53 +0200
commit	0699659c50ffdbb4f8f7308032ece33f3675abbe (patch)
tree	2d783d6384eb2887d0f6cb3abbd71b1012db2618 /src/components/application_manager/test
parent	6b1559b8659ec8d20777c29a714797fa3b649804 (diff)
download	sdl_core-0699659c50ffdbb4f8f7308032ece33f3675abbe.tar.gz