ApplicationManager tests correctives after removing all singletons

32 files changed, 4288 insertions, 885 deletions

diff --git a/src/components/application_manager/test/CMakeLists.txt b/src/components/application_manager/test/CMakeLists.txt
index 62a35477f5..ca5fcb8e6f 100644
--- a/src/components/application_manager/test/CMakeLists.txt
+++ b/src/components/application_manager/test/CMakeLists.txt
@@ -32,68 +32,37 @@
 # application manager(AM) singleton while refactoring of AM is finished.
 
 if (BUILD_TESTS)
+ 
+  include_directories(
+    include
+    ${CMAKE_BINARY_DIR}/src/components/
+    ${COMPONENTS_DIR}/resumption/include
+    ${GMOCK_INCLUDE_DIRECTORY}
+    ${COMPONENTS_DIR}/application_manager/include/
+    ${COMPONENTS_DIR}/application_manager/include/application_manager/commands/
+    ${COMPONENTS_DIR}/utils/include/utils
+    ${COMPONENTS_DIR}/include/utils
+    ${COMPONENTS_DIR}/include/
+    ${COMPONENTS_DIR}/policy/include/policy
+    ${COMPONENTS_DIR}/policy/test/include
+    ${COMPONENTS_DIR}/media_manager/include/
+    ${SecurityManagerIncludeDir}
+    ${COMPONENTS_DIR}/security_manager/include
+    ${AM_TEST_DIR}/resumption/include/
+    )
 
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mock)
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mock/include)
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mock/include/application_manager)
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mock/include/application_manager/commands)
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mock/include/application_manager/commands/mobile)
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mock/include/application_manager/commands/hmi)
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mock/include/application_manager/event_engine)
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mock/include/application_manager/policies)
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mock/include/application_manager/policies/delegates)
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mock/include/application_manager/resumption)
-
-  file (GLOB_RECURSE AMINCLUDE_TO_BE_MOCKED
-    ${AM_SOURCE_DIR}/include/application_manager/*
-  )
-  list(REMOVE_ITEM AMINCLUDE_TO_BE_MOCKED "${AM_SOURCE_DIR}/include/application_manager/application_manager_impl.h")
-  file(COPY "${AM_SOURCE_DIR}/test/mock/include/application_manager/application_manager_impl.h"
-       DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/mock/include/application_manager/)
-
-  FOREACH(infileName ${AMINCLUDE_TO_BE_MOCKED})
-  file(RELATIVE_PATH rel "${AM_SOURCE_DIR}/" ${infileName})
-  execute_process(
-    COMMAND "${CMAKE_COMMAND}" "-E" "create_symlink" "${infileName}" "${CMAKE_CURRENT_BINARY_DIR}/mock/${rel}"
-  )
-  ENDFOREACH(infileName)
-
-# Replace include for mocking singltone
-get_property(the_include_dirs DIRECTORY "" PROPERTY INCLUDE_DIRECTORIES)
-set(class_to_mock ${CMAKE_SOURCE_DIR}/src/components/application_manager/include)
-list(FIND the_include_dirs ${class_to_mock} find_idx)
-if(find_idx GREATER -1)
-  LIST_REPLACE(the_include_dirs ${find_idx} ${AM_MOCK_DIR}/include)
-endif()
-set_property(DIRECTORY "" PROPERTY INCLUDE_DIRECTORIES ${the_include_dirs})
-
-include_directories(
-  include
-  ${CMAKE_SOURCE_DIR}/src/3rd_party-static/gmock-1.7.0/include
-  ${CMAKE_SOURCE_DIR}/src/3rd_party-static/gmock-1.7.0/gtest/include
-  ${COMPONENTS_DIR}/application_manager/include/application_manager/
-  ${COMPONENTS_DIR}/application_manager/include/application_manager/policies
-  ${COMPONENTS_DIR}/application_manager/include/application_manager/resumption
-  ${COMPONENTS_DIR}/application_manager/include/
-  ${COMPONENTS_DIR}/utils/include/utils/
-  ${COMPONENTS_DIR}/policy/test/include/
-  ${COMPONENTS_DIR}/security_manager/test/include/
-  ${COMPONENTS_DIR}/security_manager/include/
-  ${COMPONENTS_DIR}/include/utils/
-  ${COMPONENTS_DIR}/application_manager/test/resumption/include/
-  ${COMPONENTS_DIR}/application_manager/test/state_controller/include/
-  ${COMPONENTS_DIR}
-)
-
-set(testSources
+  set(testSources
     ${AM_TEST_DIR}/mobile_message_handler_test.cc
     ${AM_TEST_DIR}/mobile_message_handler_v1_test.cc
     ${AM_TEST_DIR}/request_info_test.cc
     ${AM_TEST_DIR}/resumption_sql_queries_test.cc
     ${AM_TEST_DIR}/event_engine_test.cc
+    ${AM_TEST_DIR}/policy_event_observer_test.cc
+    ${AM_TEST_DIR}/application_impl_test.cc
+    ${AM_TEST_DIR}/hmi_capabilities_test.cc
+    ${AM_TEST_DIR}/application_state_test.cc
     ${AM_TEST_DIR}/usage_statistics_test.cc
-    # TODO(VVeremjova) APPLINK-12835
-    #${AM_TEST_DIR}/zero_request_amount_test.cc
+    ${AM_TEST_DIR}/mock_message_helper.cc
   )
   set (request_controller_SOURCES
     ${AM_TEST_DIR}/request_controller/request_controller_test.cc
@@ -132,7 +101,7 @@ set(testSources
     ${AM_SOURCE_DIR}/src/application_state.cc
     ${AM_SOURCE_DIR}/src/state_controller.cc
     ${AM_SOURCE_DIR}/src/mobile_command_factory.cc
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/application_manager/mock_message_helper.cc
+    ${AM_TEST_DIR}/mock_message_helper.cc
 
     ${AM_SOURCE_DIR}/src/hmi_command_factory.cc
     ${AM_SOURCE_DIR}/src/hmi_state.cc
@@ -196,37 +165,57 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "QNX")
   list(REMOVE_ITEM test_exec_libraries dl)
 endif()
 
-if(ENABLE_LOG)
-  list(APPEND LIBRARIES log4cxx -L${LOG4CXX_LIBS_DIRECTORY})
-  list(APPEND LIBRARIES apr-1 -L${APR_LIBS_DIRECTORY})
-  list(APPEND LIBRARIES aprutil-1 -L${APR_UTIL_LIBS_DIRECTORY})
-  list(APPEND LIBRARIES expat -L${EXPAT_LIBS_DIRECTORY})
-endif()
-
-add_library("ApplicationManagerTest" ${mockedSources} ${testSources})
-
-target_link_libraries("ApplicationManagerTest" ${testLibraries} AMHMICommandsLibrary
-                                                                AMMobileCommandsLibrary
-                                                                AMEventEngine
-                                                                AMPolicyLibrary)
-
-create_test("application_manager_test" "${testSources}" "${ApplicationManagerTest}")
-target_link_libraries("application_manager_test"
-  ApplicationManagerTest ${test_exec_libraries}
-  ApplicationManager
-  ProtocolLibrary
-  connectionHandler
-  ConfigProfile
-  jsoncpp
-  MediaManager
-  ProtocolHandler
-  Resumption
-)
+  set(testLibraries
+    Utils
+    ApplicationManager
+    jsoncpp
+    Policy
+    connectionHandler
+    HMI_API
+    MOBILE_API
+    v4_protocol_v1_2_no_extra
+    SmartObjects
+    formatters
+    gmock_main
+    UsageStatistics
+    dl
+    ProtocolLibrary
+    ConfigProfile
+    MediaManager
+    Resumption
+    ProtocolHandler
+    SecurityManager
+  )
 
-# TODO [AKozoriz] : Fix not buildable tests
-  set(ResumptionData_SOURCES
+  if (${CMAKE_SYSTEM_NAME} MATCHES "QNX")
+    list(REMOVE_ITEM test_exec_libraries dl)
+  endif()
+
+  if (ENABLE_LOG)
+    list(APPEND LIBRARIES log4cxx -L${LOG4CXX_LIBS_DIRECTORY})
+    list(APPEND LIBRARIES apr-1 -L${APR_LIBS_DIRECTORY})
+    list(APPEND LIBRARIES aprutil-1 -L${APR_UTIL_LIBS_DIRECTORY})
+    list(APPEND LIBRARIES expat -L${EXPAT_LIBS_DIRECTORY})
+  endif()
+
+  file(COPY smartDeviceLink_test2.ini DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+  file(COPY sdl_preloaded_pt.json DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+  file(COPY sdl_pt_update.json DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
+add_custom_command(
+OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/libPolicy.so
+                     COMMAND ${CMAKE_COMMAND} -E
+                     copy  ${COMPONENTS_DIR}/policy/libPolicy.so ${CMAKE_CURRENT_BINARY_DIR})
+  set(CMAKE_EXE_LINKER_FLAGS
+    "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath=${CMAKE_CURRENT_BINARY_DIR}")
+  create_test("application_manager_test" "${testSources}" "${testLibraries}" )
+# TODO [AKozoriz] : Fix not buildable tests 
+ set(ResumptionData_SOURCES
     ${AM_TEST_DIR}/resumption/resumption_data_test.cc
 #    ${AM_TEST_DIR}/resumption/resumption_data_db_test.cc
+#    ${AM_TEST_DIR}/resumption/resumption_data_json_test.cc
+#    ${AM_TEST_DIR}/resumption/resume_ctrl_test.cc
+    ${AM_TEST_DIR}/mock_message_helper.cc
   )
 
   file(COPY hmi_capabilities.json DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/src/components/application_manager/test/application_impl_test.cc b/src/components/application_manager/test/application_impl_test.cc
new file mode 100644
index 0000000000..62d7b70a3f
--- /dev/null
+++ b/src/components/application_manager/test/application_impl_test.cc
@@ -0,0 +1,725 @@
+/*
+ * Copyright (c) 2016, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "application_manager/application_impl.h"
+#include <iostream>
+#include "gtest/gtest.h"
+#include "application_manager/hmi_state.h"
+#include "utils/file_system.h"
+
+#include "utils/make_shared.h"
+#include "application_manager/mock_message_helper.h"
+#include "utils/custom_string.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_application_manager_settings.h"
+#include "application_manager/mock_request_controller_settings.h"
+#include "application_manager/event_engine/event_dispatcher.h"
+#include "application_manager/state_controller.h"
+#include "resumption/last_state.h"
+#include "application_manager/resumption/resume_ctrl.h"
+#include "application_manager/policies/mock_policy_handler_interface.h"
+#include "policy/mock_statistics_manager.h"
+
+namespace test {
+namespace components {
+namespace application_manager_test {
+
+using namespace application_manager;
+
+using namespace mobile_apis;
+namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
+namespace custom_str = utils::custom_string;
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::AtLeast;
+using usage_statistics_test::MockStatisticsManager;
+
+typedef void (ApplicationImpl::*AddSet)(HmiStatePtr args);
+
+class ApplicationImplTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() OVERRIDE {
+    app_id = 10;
+    policy_app_id = "policy_app_id";
+    app_name = "app_name";
+    mac_address = "mac_address";
+    test_lvl = HMILevel::INVALID_ENUM;
+    state_id = HmiState::STATE_ID_REGULAR;
+    audiostate = AudioStreamingState::NOT_AUDIBLE;
+    syst_context = SystemContext::SYSCTXT_MAIN;
+
+    testHmiState = CreateTestHmiState();
+    EXPECT_CALL(mock_application_manager_, CreateRegularState(app_id, _, _, _))
+        .WillOnce(Return(testHmiState));
+    EXPECT_CALL(mock_application_manager_, get_settings()).WillRepeatedly(ReturnRef(mock_application_manager_settings_));
+    EXPECT_CALL(mock_application_manager_settings_, app_icons_folder()).WillRepeatedly(ReturnRef(directory_name));
+    EXPECT_CALL(mock_application_manager_settings_, app_storage_folder()).WillRepeatedly(ReturnRef(directory_name));
+    EXPECT_CALL(mock_application_manager_settings_, audio_data_stopped_timeout()).WillOnce(Return(0));
+    EXPECT_CALL(mock_application_manager_settings_, video_data_stopped_timeout()).WillOnce(Return(0));
+    app_impl = new ApplicationImpl(app_id,
+                                   policy_app_id,
+                                   mac_address,
+                                   app_name,
+                                   utils::MakeShared<MockStatisticsManager>(),
+                                   mock_application_manager_);
+
+
+  }
+  virtual void TearDown() OVERRIDE {
+    delete app_impl;
+  }
+  HmiStatePtr CreateTestHmiState();
+
+  HmiStatePtr TestAddHmiState(HMILevel::eType hmi_lvl,
+                              HmiState::StateID id_state,
+                              AddSet hmi_action);
+
+  void CheckCurrentHMIState();
+  MockApplicationManagerSettings mock_application_manager_settings_;
+  MockApplicationManager mock_application_manager_;
+  ApplicationImpl* app_impl;
+  uint32_t app_id;
+  std::string policy_app_id;
+  std::string mac_address;
+  custom_str::CustomString app_name;
+  const std::string directory_name = "./test_storage";
+  HmiState::StateID state_id;
+  HmiStatePtr testHmiState;
+  HMILevel::eType test_lvl;
+  AudioStreamingState::eType audiostate;
+  SystemContext::eType syst_context;
+};
+
+
+HmiStatePtr ApplicationImplTest::CreateTestHmiState() {
+  HmiStatePtr testState =
+      utils::MakeShared<HmiState>(app_id, mock_application_manager_, state_id);
+  testState->set_hmi_level(test_lvl);
+  testState->set_audio_streaming_state(audiostate);
+  testState->set_system_context(syst_context);
+  return testState;
+}
+
+HmiStatePtr ApplicationImplTest::TestAddHmiState(HMILevel::eType hmi_lvl,
+                                                 HmiState::StateID id_state,
+                                                 AddSet hmi_action) {
+  test_lvl = hmi_lvl;
+  state_id = id_state;
+  HmiStatePtr state = CreateTestHmiState();
+  (app_impl->*hmi_action)(state);
+  return state;
+}
+
+void ApplicationImplTest::CheckCurrentHMIState() {
+  HmiStatePtr current_state = app_impl->CurrentHmiState();
+  EXPECT_EQ(test_lvl, current_state->hmi_level());
+  EXPECT_EQ(state_id, current_state->state_id());
+}
+
+TEST_F(ApplicationImplTest, AddHmiState_GetCurrentState) {
+  TestAddHmiState(HMILevel::HMI_FULL,
+                  HmiState::STATE_ID_PHONE_CALL,
+                  &ApplicationImpl::AddHMIState);
+
+  CheckCurrentHMIState();
+  EXPECT_EQ(app_id, app_impl->app_id());
+}
+
+TEST_F(ApplicationImplTest, AddRegularHmiState_GetCurrentState) {
+  TestAddHmiState(HMILevel::HMI_LIMITED,
+                  HmiState::STATE_ID_REGULAR,
+                  &ApplicationImpl::SetRegularState);
+
+  CheckCurrentHMIState();
+  EXPECT_EQ(app_id, app_impl->app_id());
+}
+
+TEST_F(ApplicationImplTest, AddStateAddRegularState_GetCurrentState) {
+  TestAddHmiState(HMILevel::HMI_FULL,
+                  HmiState::STATE_ID_REGULAR,
+                  &ApplicationImpl::SetRegularState);
+  TestAddHmiState(HMILevel::HMI_LIMITED,
+                  HmiState::STATE_ID_NAVI_STREAMING,
+                  &ApplicationImpl::AddHMIState);
+
+  CheckCurrentHMIState();
+  EXPECT_EQ(app_id, app_impl->app_id());
+}
+
+TEST_F(ApplicationImplTest, AddStateAddRegularState_GetRegularState) {
+  TestAddHmiState(HMILevel::HMI_FULL,
+                  HmiState::STATE_ID_REGULAR,
+                  &ApplicationImpl::SetRegularState);
+  TestAddHmiState(HMILevel::HMI_LIMITED,
+                  HmiState::STATE_ID_NAVI_STREAMING,
+                  &ApplicationImpl::AddHMIState);
+
+  HmiStatePtr current_state = app_impl->RegularHmiState();
+  EXPECT_EQ(HMILevel::HMI_FULL, current_state->hmi_level());
+  EXPECT_EQ(HmiState::STATE_ID_REGULAR, current_state->state_id());
+  EXPECT_EQ(app_id, app_impl->app_id());
+}
+
+TEST_F(ApplicationImplTest, AddStates_RemoveLastState) {
+  // First state
+  TestAddHmiState(HMILevel::HMI_FULL,
+                  HmiState::STATE_ID_PHONE_CALL,
+                  &ApplicationImpl::AddHMIState);
+  HmiStatePtr state2 = TestAddHmiState(HMILevel::HMI_NONE,
+                                       HmiState::STATE_ID_NAVI_STREAMING,
+                                       &ApplicationImpl::AddHMIState);
+  HmiStatePtr state3 = TestAddHmiState(HMILevel::HMI_LIMITED,
+                                       HmiState::STATE_ID_TTS_SESSION,
+                                       &ApplicationImpl::AddHMIState);
+
+  CheckCurrentHMIState();
+
+  // Remove last state
+  app_impl->RemoveHMIState(state3->state_id());
+  HmiStatePtr current_state = app_impl->CurrentHmiState();
+  EXPECT_EQ(state2, current_state);
+  EXPECT_EQ(HMILevel::HMI_NONE, current_state->hmi_level());
+  EXPECT_EQ(HmiState::STATE_ID_NAVI_STREAMING, current_state->state_id());
+}
+
+TEST_F(ApplicationImplTest, AddStates_RemoveNotLastNotFirstState) {
+  HmiStatePtr state1 = TestAddHmiState(HMILevel::HMI_FULL,
+                                       HmiState::STATE_ID_PHONE_CALL,
+                                       &ApplicationImpl::AddHMIState);
+  HmiStatePtr state2 = TestAddHmiState(HMILevel::HMI_NONE,
+                                       HmiState::STATE_ID_NAVI_STREAMING,
+                                       &ApplicationImpl::AddHMIState);
+  HmiStatePtr state3 = TestAddHmiState(HMILevel::HMI_LIMITED,
+                                       HmiState::STATE_ID_TTS_SESSION,
+                                       &ApplicationImpl::AddHMIState);
+
+  CheckCurrentHMIState();
+
+  // Remove not last state
+  app_impl->RemoveHMIState(state2->state_id());
+  HmiStatePtr current_state = app_impl->CurrentHmiState();
+  EXPECT_EQ(state3, current_state);
+  // HMI level is equal to parent hmi_level
+  EXPECT_EQ(HMILevel::HMI_FULL, current_state->hmi_level());
+  EXPECT_EQ(HmiState::STATE_ID_TTS_SESSION, current_state->state_id());
+  EXPECT_EQ(state1, current_state->parent());
+}
+
+TEST_F(ApplicationImplTest, AddStates_RemoveFirstState) {
+  HmiStatePtr state1 = TestAddHmiState(HMILevel::HMI_FULL,
+                                       HmiState::STATE_ID_PHONE_CALL,
+                                       &ApplicationImpl::AddHMIState);
+  // Second state
+  TestAddHmiState(HMILevel::HMI_NONE,
+                  HmiState::STATE_ID_NAVI_STREAMING,
+                  &ApplicationImpl::AddHMIState);
+  HmiStatePtr state3 = TestAddHmiState(HMILevel::HMI_LIMITED,
+                                       HmiState::STATE_ID_TTS_SESSION,
+                                       &ApplicationImpl::AddHMIState);
+  CheckCurrentHMIState();
+
+  // Remove first added state
+  app_impl->RemoveHMIState(state1->state_id());
+  HmiStatePtr current_state = app_impl->CurrentHmiState();
+  EXPECT_EQ(state3, current_state);
+  // Last state does not have a parent
+  EXPECT_EQ(HMILevel::HMI_LIMITED, current_state->hmi_level());
+  EXPECT_EQ(HmiState::STATE_ID_TTS_SESSION, current_state->state_id());
+  EXPECT_EQ(NULL, current_state->parent());
+}
+
+TEST_F(ApplicationImplTest, SetRegularState_RemoveFirstState) {
+  HmiStatePtr state1 = TestAddHmiState(HMILevel::HMI_NONE,
+                                       HmiState::STATE_ID_NAVI_STREAMING,
+                                       &ApplicationImpl::AddHMIState);
+  // Set regular state
+  HmiStatePtr state2 = TestAddHmiState(HMILevel::HMI_FULL,
+                                       HmiState::STATE_ID_REGULAR,
+                                       &ApplicationImpl::SetRegularState);
+  HmiStatePtr state3 = TestAddHmiState(HMILevel::HMI_LIMITED,
+                                       HmiState::STATE_ID_TTS_SESSION,
+                                       &ApplicationImpl::AddHMIState);
+  CheckCurrentHMIState();
+
+  // Remove first state
+  app_impl->RemoveHMIState(state1->state_id());
+  HmiStatePtr current_state = app_impl->CurrentHmiState();
+  EXPECT_EQ(state3, current_state);
+  // Last state has a parent
+  EXPECT_EQ(HMILevel::HMI_FULL, current_state->hmi_level());
+  EXPECT_EQ(HmiState::STATE_ID_TTS_SESSION, current_state->state_id());
+  EXPECT_EQ(state2, current_state->parent());
+}
+
+TEST_F(ApplicationImplTest, SetPostponedState_RemovePostponedState) {
+  // Set postponed hmi state
+  HmiStatePtr state1 = TestAddHmiState(HMILevel::HMI_NONE,
+                                       HmiState::STATE_ID_POSTPONED,
+                                       &ApplicationImpl::SetPostponedState);
+
+  // Check that state was setted correctly
+  HmiStatePtr state2 = app_impl->PostponedHmiState();
+  EXPECT_EQ(state1, state2);
+
+  // Check that state was correctly removed
+  app_impl->RemovePostponedState();
+  state2 = app_impl->PostponedHmiState();
+  EXPECT_EQ(NULL, state2);
+}
+
+TEST_F(ApplicationImplTest, AddStateAddRegularState_GetHmiLvlAudioSystemState) {
+  audiostate = AudioStreamingState::ATTENUATED;
+  syst_context = SystemContext::SYSCTXT_ALERT;
+  TestAddHmiState(HMILevel::HMI_FULL,
+                  HmiState::STATE_ID_REGULAR,
+                  &ApplicationImpl::SetRegularState);
+
+  EXPECT_EQ(test_lvl, app_impl->hmi_level());
+  EXPECT_EQ(audiostate, app_impl->audio_streaming_state());
+  EXPECT_EQ(syst_context, app_impl->system_context());
+
+  audiostate = AudioStreamingState::AUDIBLE;
+  syst_context = SystemContext::SYSCTXT_MENU;
+  TestAddHmiState(HMILevel::HMI_LIMITED,
+                  HmiState::STATE_ID_NAVI_STREAMING,
+                  &ApplicationImpl::AddHMIState);
+
+  EXPECT_EQ(test_lvl, app_impl->hmi_level());
+  EXPECT_EQ(audiostate, app_impl->audio_streaming_state());
+  EXPECT_EQ(syst_context, app_impl->system_context());
+}
+
+TEST_F(ApplicationImplTest, IsAudioApplication) {
+  EXPECT_FALSE(app_impl->IsAudioApplication());
+  app_impl->set_is_navi(true);
+  app_impl->set_is_media_application(false);
+  app_impl->set_voice_communication_supported(false);
+  EXPECT_TRUE(app_impl->IsAudioApplication());
+  app_impl->set_is_navi(false);
+  app_impl->set_is_media_application(true);
+  app_impl->set_voice_communication_supported(false);
+  EXPECT_TRUE(app_impl->IsAudioApplication());
+  app_impl->set_is_navi(false);
+  app_impl->set_is_media_application(false);
+  app_impl->set_voice_communication_supported(true);
+  EXPECT_TRUE(app_impl->IsAudioApplication());
+  app_impl->set_is_media_application(false);
+  app_impl->set_voice_communication_supported(false);
+  app_impl->set_is_navi(false);
+  EXPECT_FALSE(app_impl->IsAudioApplication());
+}
+
+TEST_F(ApplicationImplTest, AddFile) {
+  AppFile test_file;
+
+  test_file.is_persistent = true;
+  test_file.is_download_complete = false;
+  test_file.file_type = FileType::AUDIO_AAC;
+  test_file.file_name = "test_file 1";
+
+  EXPECT_TRUE(app_impl->AddFile(test_file));
+  test_file.is_download_complete = true;
+  EXPECT_FALSE(app_impl->AddFile(test_file));
+  test_file.file_name = "test_file 2";
+  EXPECT_TRUE(app_impl->AddFile(test_file));
+}
+
+TEST_F(ApplicationImplTest, UpdateFile) {
+  AppFile test_file;
+
+  test_file.is_persistent = true;
+  test_file.is_download_complete = false;
+  test_file.file_type = FileType::AUDIO_AAC;
+  test_file.file_name = "test_file 1";
+
+  EXPECT_FALSE(app_impl->UpdateFile(test_file));
+  EXPECT_TRUE(app_impl->AddFile(test_file));
+  test_file.is_download_complete = true;
+  EXPECT_FALSE(app_impl->AddFile(test_file));
+  EXPECT_TRUE(app_impl->UpdateFile(test_file));
+}
+
+TEST_F(ApplicationImplTest, DeleteFile) {
+  AppFile test_file;
+  test_file.is_persistent = true;
+  test_file.is_download_complete = false;
+  test_file.file_type = FileType::AUDIO_AAC;
+  test_file.file_name = "test_file 1";
+
+  EXPECT_FALSE(app_impl->DeleteFile(test_file.file_name));
+  EXPECT_TRUE(app_impl->AddFile(test_file));
+  EXPECT_TRUE(app_impl->DeleteFile(test_file.file_name));
+  EXPECT_FALSE(app_impl->DeleteFile(test_file.file_name));
+  EXPECT_TRUE(app_impl->AddFile(test_file));
+}
+
+TEST_F(ApplicationImplTest, GetFile) {
+  AppFile test_file;
+  test_file.is_persistent = true;
+  test_file.is_download_complete = true;
+  test_file.file_type = FileType::GRAPHIC_JPEG;
+  test_file.file_name = "test_file 1";
+
+  EXPECT_EQ(NULL, app_impl->GetFile(test_file.file_name));
+  EXPECT_TRUE(app_impl->AddFile(test_file));
+  const AppFile* app_file = app_impl->GetFile(test_file.file_name);
+  EXPECT_EQ(test_file.is_persistent, app_file->is_persistent);
+  EXPECT_EQ(test_file.is_download_complete, app_file->is_download_complete);
+  EXPECT_EQ(test_file.file_type, app_file->file_type);
+}
+
+TEST_F(ApplicationImplTest, SetIconPath) {
+  AppFile test_file;
+  test_file.is_persistent = true;
+  test_file.is_download_complete = false;
+  test_file.file_type = FileType::GRAPHIC_BMP;
+  test_file.file_name = "test_file 1";
+
+  EXPECT_TRUE(app_impl->AddFile(test_file));
+  test_file.file_name = "test_file 2";
+  test_file.file_type = FileType::GRAPHIC_PNG;
+  EXPECT_TRUE(app_impl->AddFile(test_file));
+
+  EXPECT_TRUE(app_impl->set_app_icon_path(test_file.file_name));
+  EXPECT_EQ(test_file.file_name, app_impl->app_icon_path());
+}
+
+TEST_F(ApplicationImplTest, LoadPersistentFiles) {
+  // Precondition
+  // Create test folder with diff files
+
+  app_impl->MarkRegistered();
+  std::string folder_name = "";
+  app_impl->set_folder_name(folder_name);
+
+  file_system::CreateDirectory(directory_name);
+
+  EXPECT_TRUE(file_system::CreateFile(directory_name + "/test_file1.json"));
+  EXPECT_TRUE(file_system::CreateFile(directory_name + "/test_file2.bmp"));
+  EXPECT_TRUE(file_system::CreateFile(directory_name + "/test_file3.jpeg"));
+  EXPECT_TRUE(file_system::CreateFile(directory_name + "/test_file4.png"));
+  EXPECT_TRUE(file_system::CreateFile(directory_name + "/test_file5"));
+  EXPECT_TRUE(file_system::CreateFile(directory_name + "/test_file6.wave"));
+  EXPECT_TRUE(file_system::CreateFile(directory_name + "/test_file7.mp4"));
+  EXPECT_TRUE(file_system::CreateFile(directory_name + "/test_file8.mp3"));
+
+  app_impl->LoadPersistentFiles();
+
+  AppFilesMap files_map = app_impl->getAppFiles();
+
+  EXPECT_EQ(8u, files_map.size());
+  const AppFile* test_file1 =
+      app_impl->GetFile(directory_name + "//test_file1.json");
+  ASSERT_TRUE(test_file1);
+  EXPECT_EQ(FileType::JSON, test_file1->file_type);
+  const AppFile* test_file2 =
+      app_impl->GetFile(directory_name + "//test_file2.bmp");
+  ASSERT_TRUE(test_file2);
+  EXPECT_EQ(FileType::GRAPHIC_BMP, test_file2->file_type);
+  const AppFile* test_file3 =
+      app_impl->GetFile(directory_name + "//test_file3.jpeg");
+  ASSERT_TRUE(test_file3);
+  EXPECT_EQ(FileType::GRAPHIC_JPEG, test_file3->file_type);
+  const AppFile* test_file4 =
+      app_impl->GetFile(directory_name + "//test_file4.png");
+  ASSERT_TRUE(test_file4);
+  EXPECT_EQ(FileType::GRAPHIC_PNG, test_file4->file_type);
+  const AppFile* test_file5 =
+      app_impl->GetFile(directory_name + "//test_file5");
+  ASSERT_TRUE(test_file5);
+  EXPECT_EQ(FileType::BINARY, test_file5->file_type);
+  const AppFile* test_file6 =
+      app_impl->GetFile(directory_name + "//test_file6.wave");
+  ASSERT_TRUE(test_file6);
+  EXPECT_EQ(FileType::AUDIO_WAVE, test_file6->file_type);
+  const AppFile* test_file7 =
+      app_impl->GetFile(directory_name + "//test_file7.mp4");
+  ASSERT_TRUE(test_file7);
+  EXPECT_EQ(FileType::AUDIO_AAC, test_file7->file_type);
+  const AppFile* test_file8 =
+      app_impl->GetFile(directory_name + "//test_file8.mp3");
+  ASSERT_TRUE(test_file8);
+  EXPECT_EQ(FileType::AUDIO_MP3, test_file8->file_type);
+}
+
+TEST_F(ApplicationImplTest, IsCommandLimitsExceeded_SetLimitFromConfig) {
+  std::pair<uint32_t, int32_t> get_frequency;
+  get_frequency.first = 5;
+  get_frequency.second = 1;
+  EXPECT_CALL(mock_application_manager_settings_, read_did_frequency())
+      .WillRepeatedly(ReturnRef(get_frequency));
+  EXPECT_CALL(mock_application_manager_settings_, get_vehicle_data_frequency())
+      .WillRepeatedly(ReturnRef(get_frequency));
+  for (uint32_t i = 0; i < get_frequency.first; i++) {
+    EXPECT_FALSE(app_impl->IsCommandLimitsExceeded(FunctionID::ReadDIDID,
+                                                   TLimitSource::CONFIG_FILE));
+  }
+  EXPECT_TRUE(app_impl->IsCommandLimitsExceeded(FunctionID::ReadDIDID,
+                                                TLimitSource::CONFIG_FILE));
+
+  for (uint32_t i = 0; i < get_frequency.first; i++) {
+    EXPECT_FALSE(app_impl->IsCommandLimitsExceeded(FunctionID::GetVehicleDataID,
+                                                   TLimitSource::CONFIG_FILE));
+  }
+  EXPECT_TRUE(app_impl->IsCommandLimitsExceeded(FunctionID::GetVehicleDataID,
+                                                TLimitSource::CONFIG_FILE));
+}
+
+TEST_F(ApplicationImplTest, IsCommandLimitsExceeded_LimitFromPT) {
+  policy_test::MockPolicyHandlerInterface policy_interface;
+  EXPECT_CALL(mock_application_manager_, GetPolicyHandler()).WillRepeatedly(ReturnRef(policy_interface));
+  EXPECT_CALL(policy_interface, GetPriority(policy_app_id, _)).WillRepeatedly(Return(false));
+
+  EXPECT_CALL(policy_interface, GetNotificationsNumber(_)).WillOnce(Return(100u));
+  EXPECT_FALSE(app_impl->IsCommandLimitsExceeded(FunctionID::ReadDIDID,
+                                                 TLimitSource::POLICY_TABLE));
+
+  EXPECT_CALL(policy_interface, GetNotificationsNumber(_)).WillOnce(Return(100u));
+  EXPECT_FALSE(app_impl->IsCommandLimitsExceeded(FunctionID::GetVehicleDataID,
+                                                 TLimitSource::POLICY_TABLE));
+  EXPECT_CALL(policy_interface, GetNotificationsNumber(_)).WillRepeatedly(Return(0));
+  EXPECT_TRUE(app_impl->IsCommandLimitsExceeded(FunctionID::ReadDIDID,
+                                                TLimitSource::POLICY_TABLE));
+  EXPECT_TRUE(app_impl->IsCommandLimitsExceeded(FunctionID::GetVehicleDataID,
+                                                TLimitSource::POLICY_TABLE));
+}
+
+TEST_F(ApplicationImplTest, SubscribeToButton_UnsubscribeFromButton) {
+  EXPECT_TRUE(app_impl->SubscribeToButton(ButtonName::PRESET_0));
+  // It is impossible to subsribe to the same button twice
+  EXPECT_FALSE(app_impl->SubscribeToButton(ButtonName::PRESET_0));
+  EXPECT_TRUE(app_impl->IsSubscribedToButton(ButtonName::PRESET_0));
+  EXPECT_TRUE(app_impl->UnsubscribeFromButton(ButtonName::PRESET_0));
+  EXPECT_FALSE(app_impl->IsSubscribedToButton(ButtonName::PRESET_0));
+}
+
+TEST_F(ApplicationImplTest, SubscribeToDefaultButton_UnsubscribeFromButton) {
+  EXPECT_TRUE(app_impl->IsSubscribedToButton(ButtonName::CUSTOM_BUTTON));
+  EXPECT_FALSE(app_impl->SubscribeToButton(ButtonName::CUSTOM_BUTTON));
+}
+
+TEST_F(ApplicationImplTest, SubscribeToSoftButton_UnsubscribeFromSoftButton) {
+  const uint btn_count = 10;
+  for (uint i = 0; i < btn_count; i++) {
+    EXPECT_FALSE(app_impl->IsSubscribedToSoftButton(i));
+  }
+
+  SoftButtonID test_button;
+  for (uint i = 0; i < btn_count; i++) {
+    test_button.insert(i);
+  }
+  app_impl->SubscribeToSoftButtons(FunctionID::ScrollableMessageID,
+                                   test_button);
+
+  for (uint i = 0; i < btn_count; i++) {
+    EXPECT_TRUE(app_impl->IsSubscribedToSoftButton(i));
+  }
+  app_impl->UnsubscribeFromSoftButtons(FunctionID::ScrollableMessageID);
+
+  for (uint i = 0; i < btn_count; i++) {
+    EXPECT_FALSE(app_impl->IsSubscribedToSoftButton(i));
+  }
+}
+
+TEST_F(ApplicationImplTest, ChangeSupportingAppHMIType_TypeNotNaviNotVoice) {
+  smart_objects::SmartObject type_media;
+  type_media[0] = AppHMIType::MEDIA;
+
+  EXPECT_FALSE(app_impl->is_navi());
+  EXPECT_FALSE(app_impl->is_voice_communication_supported());
+
+  app_impl->set_app_types(type_media);
+  app_impl->ChangeSupportingAppHMIType();
+
+  EXPECT_FALSE(app_impl->is_navi());
+  EXPECT_FALSE(app_impl->is_voice_communication_supported());
+}
+
+TEST_F(ApplicationImplTest, ChangeSupportingAppHMIType_TypeIsVoice) {
+  smart_objects::SmartObject type_comm;
+  type_comm[0] = AppHMIType::COMMUNICATION;
+
+  EXPECT_FALSE(app_impl->is_navi());
+  EXPECT_FALSE(app_impl->is_voice_communication_supported());
+
+  app_impl->set_app_types(type_comm);
+  app_impl->ChangeSupportingAppHMIType();
+
+  EXPECT_FALSE(app_impl->is_navi());
+  EXPECT_TRUE(app_impl->is_voice_communication_supported());
+}
+
+TEST_F(ApplicationImplTest, ChangeSupportingAppHMIType_TypeIsNavi) {
+  smart_objects::SmartObject type_navi;
+  type_navi[0] = AppHMIType::NAVIGATION;
+
+  EXPECT_FALSE(app_impl->is_navi());
+  EXPECT_FALSE(app_impl->is_voice_communication_supported());
+
+  app_impl->set_app_types(type_navi);
+  app_impl->ChangeSupportingAppHMIType();
+
+  EXPECT_TRUE(app_impl->is_navi());
+  EXPECT_FALSE(app_impl->is_voice_communication_supported());
+}
+
+TEST_F(ApplicationImplTest, ChangeSupportingAppHMIType_TypeIsNaviAndVoice) {
+  smart_objects::SmartObject app_types;
+  app_types[0] = AppHMIType::NAVIGATION;
+  app_types[1] = AppHMIType::COMMUNICATION;
+  app_types[2] = AppHMIType::MEDIA;
+
+  EXPECT_FALSE(app_impl->is_navi());
+  EXPECT_FALSE(app_impl->is_voice_communication_supported());
+
+  app_impl->set_app_types(app_types);
+  app_impl->ChangeSupportingAppHMIType();
+
+  EXPECT_TRUE(app_impl->is_navi());
+  EXPECT_TRUE(app_impl->is_voice_communication_supported());
+}
+
+TEST_F(ApplicationImplTest, UpdateHash_AppMngrNotSuspended) {
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendHashUpdateNotification(app_id, _)).Times(1);
+  app_impl->UpdateHash();
+
+  EXPECT_TRUE(app_impl->is_application_data_changed());
+}
+
+TEST_F(ApplicationImplTest, StartStreaming_MobileNavi_StreamingNotApproved) {
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendNaviStartStream(app_id, _));
+  app_impl->StartStreaming(protocol_handler::ServiceType::kMobileNav);
+
+  EXPECT_EQ(0u, app_impl->video_stream_retry_number());
+}
+
+TEST_F(ApplicationImplTest, StartStreaming_Audio_StreamingNotApproved) {
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendAudioStartStream(app_id, _));
+  app_impl->StartStreaming(protocol_handler::ServiceType::kAudio);
+
+  EXPECT_EQ(0u, app_impl->video_stream_retry_number());
+}
+
+TEST_F(ApplicationImplTest, StartStreaming_StreamingApproved) {
+  app_impl->set_video_streaming_approved(true);
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendNaviStartStream(app_id, _)).Times(0);
+  app_impl->StartStreaming(protocol_handler::ServiceType::kMobileNav);
+
+  app_impl->set_audio_streaming_approved(true);
+
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendAudioStartStream(app_id, _)).Times(0);
+  app_impl->StartStreaming(protocol_handler::ServiceType::kAudio);
+}
+
+TEST_F(ApplicationImplTest, SuspendNaviStreaming) {
+  protocol_handler::ServiceType type =
+      protocol_handler::ServiceType::kMobileNav;
+  EXPECT_CALL(mock_application_manager_, OnAppStreaming(app_id, type, false));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendOnDataStreaming(type, false, _));
+  app_impl->SuspendStreaming(type);
+}
+
+TEST_F(ApplicationImplTest, SuspendAudioStreaming) {
+  protocol_handler::ServiceType type = protocol_handler::ServiceType::kAudio;
+  EXPECT_CALL(mock_application_manager_, OnAppStreaming(app_id, type, false));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendOnDataStreaming(type, false, _));
+  app_impl->SuspendStreaming(type);
+}
+
+// TODO {AKozoriz} : Fix tests with streaming (APPLINK-19289)
+TEST_F(ApplicationImplTest, DISABLED_Suspend_WakeUpAudioStreaming) {
+  protocol_handler::ServiceType type = protocol_handler::ServiceType::kAudio;
+  EXPECT_CALL(mock_application_manager_, OnAppStreaming(app_id, type, false));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendOnDataStreaming(type, false, _));
+  app_impl->SuspendStreaming(type);
+
+  EXPECT_CALL(mock_application_manager_, OnAppStreaming(app_id, type, true));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendOnDataStreaming(type, true, _));
+  app_impl->WakeUpStreaming(type);
+}
+
+TEST_F(ApplicationImplTest, DISABLED_Suspend_WakeUpNaviStreaming) {
+  protocol_handler::ServiceType type =
+      protocol_handler::ServiceType::kMobileNav;
+  EXPECT_CALL(mock_application_manager_, OnAppStreaming(app_id, type, false));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendOnDataStreaming(type, false, _));
+  app_impl->SuspendStreaming(type);
+
+  EXPECT_CALL(mock_application_manager_, OnAppStreaming(app_id, type, true));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendOnDataStreaming(type, true, _));
+  app_impl->WakeUpStreaming(type);
+}
+
+TEST_F(ApplicationImplTest, StopStreaming_StreamingApproved) {
+  // Stop navigation streaming
+  protocol_handler::ServiceType type =
+      protocol_handler::ServiceType::kMobileNav;
+  app_impl->set_video_streaming_approved(true);
+
+  EXPECT_CALL(mock_application_manager_, OnAppStreaming(app_id, type, false));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendOnDataStreaming(type, false, _));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendNaviStopStream(app_id, _));
+
+  app_impl->StopStreaming(type);
+  EXPECT_FALSE(app_impl->video_streaming_approved());
+
+  // Stop audio streaming
+  app_impl->set_audio_streaming_approved(true);
+  type = protocol_handler::ServiceType::kAudio;
+  EXPECT_CALL(mock_application_manager_, OnAppStreaming(app_id, type, false));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendOnDataStreaming(type, false, _));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendAudioStopStream(app_id, _));
+
+  app_impl->StopStreaming(type);
+  EXPECT_FALSE(app_impl->audio_streaming_approved());
+}
+
+}  // namespace application_manager_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/application_manager/test/application_state_test.cc b/src/components/application_manager/test/application_state_test.cc
new file mode 100644
index 0000000000..fa22024351
--- /dev/null
+++ b/src/components/application_manager/test/application_state_test.cc
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2016, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "application_manager/application_state.h"
+#include "gtest/gtest.h"
+#include "application_manager/hmi_state.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/event_engine/event_dispatcher.h"
+#include "resumption/last_state.h"
+#include "application_manager/policies/policy_handler.h"
+#include "application_manager/state_controller.h"
+#include "application_manager/resumption/resume_ctrl.h"
+
+#include "utils/make_shared.h"
+
+namespace test {
+namespace components {
+namespace application_manager_test {
+
+using namespace application_manager;
+using namespace mobile_apis;
+typedef HmiState::StateID StateID;
+
+namespace {
+std::vector<StateID> GenerateCurrentStates() {
+  std::vector<StateID> states;
+  states.push_back(StateID::STATE_ID_PHONE_CALL);
+  states.push_back(StateID::STATE_ID_SAFETY_MODE);
+  states.push_back(StateID::STATE_ID_VR_SESSION);
+  states.push_back(StateID::STATE_ID_TTS_SESSION);
+  states.push_back(StateID::STATE_ID_NAVI_STREAMING);
+  states.push_back(StateID::STATE_ID_DEACTIVATE_HMI);
+  return states;
+}
+}
+
+class ApplicationStateTest : public ::testing::Test {
+ protected:
+
+  static std::vector<StateID> added_states_;
+  ApplicationState app_state;
+  const StateID current_id = StateID::STATE_ID_CURRENT;
+  const StateID postponed_id = StateID::STATE_ID_POSTPONED;
+  const uint32_t app_id = 10;
+  MockApplicationManager app_mngr_;
+};
+
+std::vector<StateID> ApplicationStateTest::added_states_ =
+    GenerateCurrentStates();
+
+TEST_F(ApplicationStateTest, AddStates_GetCurrentStates) {
+  std::vector<StateID>::iterator new_state = added_states_.begin();
+  for (; new_state != added_states_.end(); ++new_state) {
+    HmiStatePtr state =
+        utils::MakeShared<HmiState>(app_id, app_mngr_, *new_state);
+    app_state.AddState(state);
+    EXPECT_EQ(state, app_state.GetState(current_id));
+  }
+}
+
+TEST_F(ApplicationStateTest, AddStates_RemoveStates_GetCurrentState) {
+  std::vector<StateID>::iterator new_state = added_states_.begin();
+  for (; new_state != added_states_.end(); ++new_state) {
+    HmiStatePtr state =
+        utils::MakeShared<HmiState>(app_id, app_mngr_, *new_state);
+    app_state.AddState(state);
+
+    HmiStatePtr curr_state = app_state.GetState(current_id);
+    ASSERT_EQ(*new_state, curr_state->state_id());
+  }
+
+  new_state = added_states_.end() - 1;
+  while (new_state != added_states_.begin()) {
+    app_state.RemoveState(*new_state);
+    HmiStatePtr curr_state = app_state.GetState(current_id);
+    --new_state;
+    EXPECT_EQ(*new_state, curr_state->state_id());
+  }
+}
+
+TEST_F(ApplicationStateTest, AddStatesAddPostponedState_GetPostponedState) {
+  // Added some states
+  std::vector<StateID>::iterator new_state = added_states_.begin();
+  for (; new_state != added_states_.end(); ++new_state) {
+    HmiStatePtr state =
+        utils::MakeShared<HmiState>(app_id, app_mngr_, *new_state);
+    app_state.AddState(state);
+  }
+  // Postponed state wasn't added
+  HmiStatePtr get_postponed_id = app_state.GetState(postponed_id);
+  EXPECT_EQ(NULL, get_postponed_id);
+  // Add posponed state
+  HmiStatePtr state =
+      utils::MakeShared<HmiState>(app_id, app_mngr_, postponed_id);
+  app_state.AddState(state);
+  // Postponed state exists
+  get_postponed_id = app_state.GetState(postponed_id);
+  EXPECT_EQ(state, get_postponed_id);
+}
+
+TEST_F(ApplicationStateTest, AddStates_GetRegularState) {
+  // Add state
+  std::vector<StateID>::iterator new_state = added_states_.begin();
+  HmiStatePtr state =
+      utils::MakeShared<HmiState>(app_id, app_mngr_, *new_state);
+  state->set_hmi_level(HMILevel::HMI_FULL);
+  app_state.AddState(state);
+  ++new_state;
+  // Add some other
+  for (; new_state != added_states_.end(); ++new_state) {
+    state = utils::MakeShared<HmiState>(app_id, app_mngr_, *new_state);
+    app_state.AddState(state);
+    state->set_hmi_level(HMILevel::HMI_LIMITED);
+  }
+
+  // Regular state will be the first added state
+  new_state = added_states_.begin();
+  HmiStatePtr reg_state = app_state.GetState(StateID::STATE_ID_REGULAR);
+  EXPECT_EQ(*new_state, reg_state->state_id());
+  EXPECT_EQ(HMILevel::HMI_FULL, reg_state->hmi_level());
+}
+
+TEST_F(ApplicationStateTest, AddRegularState_RemoveFirstState_GetRegularState) {
+  std::vector<StateID>::iterator new_state = added_states_.begin();
+  HmiStatePtr state =
+      utils::MakeShared<HmiState>(app_id, app_mngr_, *new_state);
+  app_state.AddState(state);
+  ++new_state;
+
+  // Add postponed state
+  state = utils::MakeShared<HmiState>(app_id, app_mngr_, postponed_id);
+  app_state.AddState(state);
+
+  // Make sure that the state was added
+  HmiStatePtr post_state = app_state.GetState(postponed_id);
+  ASSERT_EQ(state, post_state);
+
+  for (; new_state != added_states_.end(); ++new_state) {
+    state = utils::MakeShared<HmiState>(app_id, app_mngr_, *new_state);
+    app_state.AddState(state);
+  }
+
+  // Regular state will be the first added state
+  new_state = added_states_.begin();
+  HmiStatePtr reg_state = app_state.GetState(StateID::STATE_ID_REGULAR);
+  ASSERT_EQ(*new_state, reg_state->state_id());
+
+  app_state.RemoveState(*new_state);
+
+  ++new_state;
+  // Now regular state is the next state except postponed
+  reg_state = app_state.GetState(StateID::STATE_ID_REGULAR);
+  EXPECT_EQ(*new_state, reg_state->state_id());
+}
+
+TEST_F(ApplicationStateTest, InitState_GetRegularState) {
+  StateID init_state = StateID::STATE_ID_REGULAR;
+  HmiStatePtr state =
+      utils::MakeShared<HmiState>(app_id, app_mngr_, init_state);
+
+  app_state.InitState(state);
+
+  HmiStatePtr reg_state = app_state.GetState(StateID::STATE_ID_REGULAR);
+  EXPECT_EQ(state, reg_state);
+
+  HmiStatePtr curr_state = app_state.GetState(StateID::STATE_ID_CURRENT);
+  EXPECT_EQ(state, curr_state);
+}
+
+TEST_F(ApplicationStateTest, AddPosponedState_DeletePosponedState) {
+  // Precondition
+  StateID init_state = StateID::STATE_ID_REGULAR;
+  HmiStatePtr state =
+      utils::MakeShared<HmiState>(app_id, app_mngr_, init_state);
+  state->set_hmi_level(mobile_apis::HMILevel::HMI_FULL);
+
+  app_state.InitState(state);
+
+  // Add postponed state
+  state = utils::MakeShared<HmiState>(app_id, app_mngr_, postponed_id);
+  app_state.AddState(state);
+
+  // Make sure that state was added
+  HmiStatePtr get_postponed_state = app_state.GetState(postponed_id);
+  ASSERT_EQ(state, get_postponed_state);
+
+  // Remove postponed state
+  app_state.RemoveState(postponed_id);
+
+  get_postponed_state = app_state.GetState(postponed_id);
+  EXPECT_EQ(NULL, get_postponed_state);
+}
+
+TEST_F(ApplicationStateTest,
+       AddRegularState_RemoveRegularState_RegularStateNotDeleted) {
+  StateID reg_state = StateID::STATE_ID_REGULAR;
+  HmiStatePtr state = utils::MakeShared<HmiState>(app_id, app_mngr_, reg_state);
+  app_state.InitState(state);
+
+  // Try deleting regular state
+  app_state.RemoveState(reg_state);
+
+  // Get regular state
+  HmiStatePtr get_reg_state = app_state.GetState(reg_state);
+  EXPECT_EQ(state, get_reg_state);
+}
+
+}  // namespace application_manager_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/application_manager/test/event_engine_test.cc b/src/components/application_manager/test/event_engine_test.cc
index 1d110430cf..b203374e46 100644
--- a/src/components/application_manager/test/event_engine_test.cc
+++ b/src/components/application_manager/test/event_engine_test.cc
@@ -30,32 +30,33 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "event_engine/event_observer.h"
-#include "event_engine/event.h"
-#include "event_engine/event_dispatcher_impl.h"
-#include <interfaces/HMI_API.h>
+#include "application_manager/event_engine/event_observer.h"
+#include "application_manager/event_engine/event.h"
+#include "application_manager/event_engine/event_dispatcher_impl.h"
+#include "interfaces/HMI_API.h"
 #include "mock/event_observer_mock.h"
+#include "application_manager/mock_event_dispatcher.h"
 #include "smart_objects/smart_object.h"
 #include "gmock/gmock.h"
 #include "utils/make_shared.h"
 
 namespace test {
 namespace components {
-namespace event_engine {
+namespace event_engine_test {
 
 namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
 using application_manager::event_engine::EventDispatcherImpl;
 using application_manager::event_engine::Event;
 using application_manager::event_engine::EventObserver;
-using application_manager::event_engine::MockEventObserver;
 using testing::_;
 
 class EventEngineTest : public testing::Test {
  public:
   EventEngineTest()
-      : event_id(Event::EventID::BasicCommunication_ActivateApp),
-        event_id2(Event::EventID::BasicCommunication_OnAppActivated),
-        event_id3(Event::EventID::VR_IsReady) {}
+      : event_id(Event::EventID::BasicCommunication_ActivateApp)
+      , event_id2(Event::EventID::BasicCommunication_OnAppActivated)
+      , event_id3(Event::EventID::VR_IsReady)
+      , event_observer_mock_(mock_event_dispatcher_)  {}
 
  protected:
   EventDispatcherImpl* event_dispatcher_instance_;
@@ -63,6 +64,7 @@ class EventEngineTest : public testing::Test {
   const application_manager::event_engine::Event::EventID event_id;
   const application_manager::event_engine::Event::EventID event_id2;
   const application_manager::event_engine::Event::EventID event_id3;
+  MockEventDispatcher mock_event_dispatcher_;
   MockEventObserver event_observer_mock_;
   const int32_t correlation_id = 1121;
   smart_objects::SmartObject smart_object_with_type_notification;
@@ -72,8 +74,7 @@ class EventEngineTest : public testing::Test {
   smart_objects::SmartObject smart_object_with_invalid_type;
 
   virtual void SetUp() OVERRIDE {
-    EventDispatcherImpl::destroy();
-    event_dispatcher_instance_ = EventDispatcherImpl::instance();
+    event_dispatcher_instance_ =  new EventDispatcherImpl();
     event_ = new Event(hmi_apis::FunctionID::eType::VR_IsReady);
     smart_object_with_type_notification["params"]["message_type"] =
         hmi_apis::messageType::notification;
@@ -110,7 +111,7 @@ class EventEngineTest : public testing::Test {
   }
 
   virtual void TearDown() OVERRIDE {
-    EventDispatcherImpl::destroy();
+    delete event_dispatcher_instance_;
     delete event_;
   }
 
diff --git a/src/components/application_manager/test/hmi_capabilities_test.cc b/src/components/application_manager/test/hmi_capabilities_test.cc
index 19dc0c8caf..5321ac62f1 100644
--- a/src/components/application_manager/test/hmi_capabilities_test.cc
+++ b/src/components/application_manager/test/hmi_capabilities_test.cc
@@ -32,7 +32,6 @@
 
 #include "application_manager/hmi_capabilities.h"
 #include "gtest/gtest.h"
-#include "application_manager/application_manager_impl.h"
 #include "smart_objects/smart_object.h"
 #include "application_manager/mock_message_helper.h"
 #include "smart_objects/enum_schema_item.h"
@@ -40,6 +39,12 @@
 #include "utils/make_shared.h"
 #include "application_manager/hmi_capabilities_for_testing.h"
 #include "utils/file_system.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_application_manager_settings.h"
+#include "application_manager/mock_event_dispatcher.h"
+#include "application_manager/state_controller.h"
+#include "resumption/last_state.h"
+#include "application_manager/resumption/resume_ctrl.h"
 
 namespace test {
 namespace components {
@@ -47,6 +52,7 @@ namespace application_manager_test {
 
 using ::testing::_;
 using ::testing::Return;
+using ::testing::ReturnRef;
 using ::testing::AtLeast;
 using ::testing::Invoke;
 using ::testing::InSequence;
@@ -59,13 +65,14 @@ class HMICapabilitiesTest : public ::testing::Test {
   HMICapabilitiesTest():
      last_state_("app_storage_folder", "app_info_data")  {}
   virtual void SetUp() OVERRIDE {
-    app_mngr_ = ApplicationManagerImpl::instance();
+	ON_CALL(app_mngr_,event_dispatcher()).WillByDefault(ReturnRef(mock_event_dispatcher));
+    ON_CALL(app_mngr_, get_settings()).WillByDefault(ReturnRef(mock_application_manager_settings_));
+    ON_CALL(mock_application_manager_settings_, hmi_capabilities_file_name()).WillByDefault(ReturnRef(kFileName));
     hmi_capabilities_test = utils::MakeShared<HMICapabilitiesForTesting>(app_mngr_);
     hmi_capabilities_test->Init(&last_state_);
   }
 
   virtual void TearDown() OVERRIDE {
-    app_mngr_->destroy();
     hmi_capabilities_test.reset();
   }
   static void TearDownTestCase() {
@@ -75,9 +82,12 @@ class HMICapabilitiesTest : public ::testing::Test {
   }
 
   void SetCooperating();
-  ApplicationManagerImpl* app_mngr_;
-  utils::SharedPtr<HMICapabilitiesForTesting> hmi_capabilities_test;
+  MockApplicationManager app_mngr_;
+  event_engine_test::MockEventDispatcher mock_event_dispatcher;
   resumption::LastState last_state_;
+  MockApplicationManagerSettings mock_application_manager_settings_;
+  utils::SharedPtr<HMICapabilitiesForTesting> hmi_capabilities_test;
+   const std::string kFileName = "hmi_capabilities.json";
 
 };
 
@@ -373,7 +383,7 @@ TEST_F(HMICapabilitiesTest, HmiCapabilitiesInitialized) {
       new smart_objects::SmartObject(smart_objects::SmartType_Map));
 
   EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
-              CreateModuleInfoSO(_)).WillRepeatedly(Return(language));
+              CreateModuleInfoSO(_, _)).WillRepeatedly(Return(language));
 
   hmi_capabilities_test->set_is_vr_cooperating(true);
   smart_objects::SmartObject supported_languages;
@@ -415,8 +425,8 @@ TEST_F(HMICapabilitiesTest, VerifyImageType) {
 void HMICapabilitiesTest::SetCooperating() {
   smart_objects::SmartObjectSPtr test_so;
   EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
-              CreateModuleInfoSO(_)).WillRepeatedly(Return(test_so));
-  EXPECT_CALL(*app_mngr_, ManageHMICommand(_)).WillRepeatedly(Return(true));
+              CreateModuleInfoSO(_,_)).WillRepeatedly(Return(test_so));
+  EXPECT_CALL(app_mngr_, ManageHMICommand(_)).WillRepeatedly(Return(true));
 }
 
 TEST_F(HMICapabilitiesTest, SetVRCooperating) {
@@ -425,22 +435,22 @@ TEST_F(HMICapabilitiesTest, SetVRCooperating) {
   smart_objects::SmartObjectSPtr language(
       new smart_objects::SmartObject(smart_objects::SmartType_Map));
   EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
-              CreateModuleInfoSO(hmi_apis::FunctionID::VR_GetLanguage))
+              CreateModuleInfoSO(hmi_apis::FunctionID::VR_GetLanguage,_))
       .WillOnce(Return(language));
-  EXPECT_CALL(*app_mngr_, ManageHMICommand(language));
+  EXPECT_CALL(app_mngr_, ManageHMICommand(language));
 
   smart_objects::SmartObjectSPtr support_language;
   EXPECT_CALL(
       *(MockMessageHelper::message_helper_mock()),
-      CreateModuleInfoSO(hmi_apis::FunctionID::VR_GetSupportedLanguages))
+      CreateModuleInfoSO(hmi_apis::FunctionID::VR_GetSupportedLanguages, _))
       .WillOnce(Return(support_language));
-  EXPECT_CALL(*app_mngr_, ManageHMICommand(support_language));
+  EXPECT_CALL(app_mngr_, ManageHMICommand(support_language));
 
   smart_objects::SmartObjectSPtr capabilities;
   EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
-              CreateModuleInfoSO(hmi_apis::FunctionID::VR_GetCapabilities))
+              CreateModuleInfoSO(hmi_apis::FunctionID::VR_GetCapabilities, _))
       .WillOnce(Return(capabilities));
-  EXPECT_CALL(*app_mngr_, ManageHMICommand(capabilities));
+  EXPECT_CALL(app_mngr_, ManageHMICommand(capabilities));
 
   hmi_capabilities_test->set_is_vr_cooperating(true);
 }
@@ -450,22 +460,22 @@ TEST_F(HMICapabilitiesTest, SetTTSCooperating) {
       new smart_objects::SmartObject(smart_objects::SmartType_Map));
   InSequence dummy;
   EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
-              CreateModuleInfoSO(hmi_apis::FunctionID::TTS_GetLanguage))
+              CreateModuleInfoSO(hmi_apis::FunctionID::TTS_GetLanguage, _))
       .WillOnce(Return(language));
-  EXPECT_CALL(*app_mngr_, ManageHMICommand(language));
+  EXPECT_CALL(app_mngr_, ManageHMICommand(language));
 
   smart_objects::SmartObjectSPtr support_language;
   EXPECT_CALL(
       *(MockMessageHelper::message_helper_mock()),
-      CreateModuleInfoSO(hmi_apis::FunctionID::TTS_GetSupportedLanguages))
+      CreateModuleInfoSO(hmi_apis::FunctionID::TTS_GetSupportedLanguages, _))
       .WillOnce(Return(support_language));
-  EXPECT_CALL(*app_mngr_, ManageHMICommand(support_language));
+  EXPECT_CALL(app_mngr_, ManageHMICommand(support_language));
 
   smart_objects::SmartObjectSPtr capabilities;
   EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
-              CreateModuleInfoSO(hmi_apis::FunctionID::TTS_GetCapabilities))
+              CreateModuleInfoSO(hmi_apis::FunctionID::TTS_GetCapabilities, _))
       .WillOnce(Return(capabilities));
-  EXPECT_CALL(*app_mngr_, ManageHMICommand(capabilities));
+  EXPECT_CALL(app_mngr_, ManageHMICommand(capabilities));
 
   hmi_capabilities_test->set_is_tts_cooperating(true);
 }
@@ -475,22 +485,22 @@ TEST_F(HMICapabilitiesTest, SetUICooperating) {
   smart_objects::SmartObjectSPtr language(
       new smart_objects::SmartObject(smart_objects::SmartType_Map));
   EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
-              CreateModuleInfoSO(hmi_apis::FunctionID::UI_GetLanguage))
+              CreateModuleInfoSO(hmi_apis::FunctionID::UI_GetLanguage, _))
       .WillOnce(Return(language));
-  EXPECT_CALL(*app_mngr_, ManageHMICommand(language));
+  EXPECT_CALL(app_mngr_, ManageHMICommand(language));
 
   smart_objects::SmartObjectSPtr support_language;
   EXPECT_CALL(
       *(MockMessageHelper::message_helper_mock()),
-      CreateModuleInfoSO(hmi_apis::FunctionID::UI_GetSupportedLanguages))
+      CreateModuleInfoSO(hmi_apis::FunctionID::UI_GetSupportedLanguages, _))
       .WillOnce(Return(support_language));
-  EXPECT_CALL(*app_mngr_, ManageHMICommand(support_language));
+  EXPECT_CALL(app_mngr_, ManageHMICommand(support_language));
 
   smart_objects::SmartObjectSPtr capabilities;
   EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
-              CreateModuleInfoSO(hmi_apis::FunctionID::UI_GetCapabilities))
+              CreateModuleInfoSO(hmi_apis::FunctionID::UI_GetCapabilities, _))
       .WillOnce(Return(capabilities));
-  EXPECT_CALL(*app_mngr_, ManageHMICommand(capabilities));
+  EXPECT_CALL(app_mngr_, ManageHMICommand(capabilities));
 
   hmi_capabilities_test->set_is_ui_cooperating(true);
 }
@@ -499,9 +509,9 @@ TEST_F(HMICapabilitiesTest, SetIviCooperating) {
   smart_objects::SmartObjectSPtr ivi_type;
   EXPECT_CALL(
       *(MockMessageHelper::message_helper_mock()),
-      CreateModuleInfoSO(hmi_apis::FunctionID::VehicleInfo_GetVehicleType))
+      CreateModuleInfoSO(hmi_apis::FunctionID::VehicleInfo_GetVehicleType, _))
       .WillOnce(Return(ivi_type));
-  EXPECT_CALL(*app_mngr_, ManageHMICommand(ivi_type));
+  EXPECT_CALL(app_mngr_, ManageHMICommand(ivi_type));
 
   hmi_capabilities_test->set_is_ivi_cooperating(true);
 }
diff --git a/src/components/application_manager/test/state_controller/include/state_controller_mock.h b/src/components/application_manager/test/include/application_manager/hmi_capabilities_for_testing.h
index d3e2c8b4ce..d16fd01f41 100644
--- a/src/components/application_manager/test/state_controller/include/state_controller_mock.h
+++ b/src/components/application_manager/test/include/application_manager/hmi_capabilities_for_testing.h
@@ -30,33 +30,34 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_TEST_STATE_CONTROLLER_INCLUDE_STATE_CONTROLLER_MOCK
-#define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_STATE_CONTROLLER_INCLUDE_STATE_CONTROLLER_MOCK
+#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_HMI_CAPABILITIES_FOR_TESTING_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_HMI_CAPABILITIES_FOR_TESTING_H_
 
-#include "gmock/gmock.h"
-#include "application_manager/application.h"
-#include "application_manager/hmi_state.h"
-#include "application_manager/state_controller.h"
-#include "application_manager/application_manager.h"
-#include "interfaces/MOBILE_API.h"
+#include "application_manager/hmi_capabilities.h"
 
-namespace state_controller_test {
-namespace am = application_manager;
+namespace test {
+namespace components {
+namespace application_manager_test {
 
-class StateControllerMock : public am::StateController {
+class HMICapabilitiesForTesting
+    : public ::application_manager::HMICapabilities {
  public:
-  MOCK_METHOD2(SetRegularState,
-               void(am::ApplicationSharedPtr,
-                    const mobile_apis::AudioStreamingState::eType));
-  MOCK_METHOD2(SetRegularState,
-               void(am::ApplicationSharedPtr,
-                    const mobile_apis::SystemContext::eType));
-  MOCK_METHOD3(OnStateChanged,
-               void(am::ApplicationSharedPtr,
-                    am::HmiStatePtr,
-                    am::HmiStatePtr));
-  MOCK_METHOD0(OnNaviStreamingStarted, void());
-  MOCK_METHOD0(OnNaviStreamingStopped, void());
+  HMICapabilitiesForTesting(
+      ::application_manager::ApplicationManager& app_mngr)
+      : HMICapabilities(app_mngr) {}
+  bool LoadCapabilitiesFromFile() {
+    return load_capabilities_from_file();
+  }
+
+  void ConvertJsonLanguagesToObj(
+      Json::Value& json_languages,
+      ::NsSmartDeviceLink::NsSmartObjects::SmartObject& languages) {
+    convert_json_languages_to_obj(json_languages, languages);
+  }
 };
-}
-#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_STATE_CONTROLLER_INCLUDE_STATE_CONTROLLER_MOCK
+
+}  // namespace application_manager_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_HMI_CAPABILITIES_FOR_TESTING_H_
diff --git a/src/components/application_manager/test/include/application_manager/mock_application.h b/src/components/application_manager/test/include/application_manager/mock_application.h
new file mode 100644
index 0000000000..7f24c07793
--- /dev/null
+++ b/src/components/application_manager/test/include/application_manager/mock_application.h
@@ -0,0 +1,280 @@
+/*
+* Copyright (c) 2016, 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_INCLUDE_APPLICATION_MANAGER_MOCK_APPLICATION_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_APPLICATION_H_
+#include <string>
+#include "gmock/gmock.h"
+#include "application_manager/application.h"
+#include "smart_objects/smart_object.h"
+#include "utils/custom_string.h"
+
+namespace test {
+namespace components {
+namespace application_manager_test {
+
+namespace custom_str = utils::custom_string;
+namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
+class MockApplication : public ::application_manager::Application {
+ public:
+  MockApplication(){}
+  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(StopStreamingForce, 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, const application_manager::HmiStatePtr());
+  MOCK_CONST_METHOD0(RegularHmiState, const application_manager::HmiStatePtr());
+  MOCK_CONST_METHOD0(PostponedHmiState, const 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_METHOD0(RemovePostponedState, void());
+  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_perform_interaction_layout, void(mobile_apis::LayoutMode::eType mode));
+  MOCK_CONST_METHOD0(perform_interaction_layout, mobile_apis::LayoutMode::eType());
+  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(mac_address, const std::string&());
+  MOCK_METHOD0(GetAvailableDiskSpace, uint32_t());
+  MOCK_METHOD1(set_mobile_app_id, void(const std::string& policy_app_id));
+  MOCK_CONST_METHOD0(is_foreground, bool());
+  MOCK_METHOD1(set_foreground, void(bool is_foreground));
+};
+
+}  // namespace application_manager_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_APPLICATION_H_
diff --git a/src/components/application_manager/test/include/application_manager/mock_application_manager.h b/src/components/application_manager/test/include/application_manager/mock_application_manager.h
index 0f2d02eed1..04289ebbe9 100644
--- a/src/components/application_manager/test/include/application_manager/mock_application_manager.h
+++ b/src/components/application_manager/test/include/application_manager/mock_application_manager.h
@@ -35,82 +35,194 @@
 
 #include <string>
 #include <vector>
+
 #include "gmock/gmock.h"
+
 #include "application_manager/application_manager.h"
-#include "application_manager/usage_statistics.h"
+#include "application_manager/application_manager_impl.h"
+#include "application_manager/application_manager_settings.h"
 #include "application_manager/commands/command.h"
-#include "media_manager/media_manager.h"
-#include "resumption/last_state.h"
-#include "application_manager/policies/policy_handler_interface.h"
-#include "connection_handler/connection_handler.h"
+#include "application_manager/hmi_capabilities.h"
+#include "application_manager/vehicle_info_data.h"
+#include "application_manager/state_controller.h"
+
+#include "interfaces/MOBILE_API.h"
+
 namespace test {
 namespace components {
 namespace application_manager_test {
-namespace am = application_manager;
 namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
 
 class MockApplicationManager : public application_manager::ApplicationManager {
  public:
-  MOCK_METHOD2(Init, bool(resumption::LastState& last_state,
-                          media_manager::MediaManager* media_manager));
-  MOCK_METHOD0(Stop, bool());
-
-  MOCK_METHOD1(set_hmi_message_handler,
-               void(hmi_message_handler::HMIMessageHandler*));
-  MOCK_METHOD1(set_protocol_handler, void(protocol_handler::ProtocolHandler*));
-  MOCK_METHOD1(set_connection_handler,
-               void(connection_handler::ConnectionHandler*));
-  MOCK_CONST_METHOD0(applications, DataAccessor<am::ApplicationSet>());
-  MOCK_CONST_METHOD1(application_by_hmi_app,
-                     am::ApplicationSharedPtr(uint32_t));
-  MOCK_CONST_METHOD1(application, am::ApplicationSharedPtr(uint32_t));
+    MOCK_METHOD2(Init,
+          bool(resumption::LastState& last_state, media_manager::MediaManager* media_manager));
+      MOCK_METHOD0(Stop,
+          bool());
+      MOCK_METHOD1(set_hmi_message_handler,
+          void(hmi_message_handler::HMIMessageHandler* handler));
+      MOCK_METHOD1(set_protocol_handler,
+          void(protocol_handler::ProtocolHandler* handler));
+      MOCK_METHOD1(set_connection_handler,
+          void(connection_handler::ConnectionHandler* handler));
+      MOCK_CONST_METHOD0(applications,
+          DataAccessor<application_manager::ApplicationSet>());
+      MOCK_CONST_METHOD1(application,
+          application_manager::ApplicationSharedPtr(uint32_t app_id));
+      MOCK_CONST_METHOD0(active_application,
+          application_manager::ApplicationSharedPtr());
+      MOCK_CONST_METHOD1(application_by_hmi_app,
+          application_manager::ApplicationSharedPtr(uint32_t hmi_app_id));
+      MOCK_CONST_METHOD1(application_by_policy_id,
+          application_manager::ApplicationSharedPtr(const std::string& policy_app_id));
+      MOCK_METHOD1(applications_by_button,
+          std::vector<application_manager::ApplicationSharedPtr>(uint32_t button));
+      MOCK_METHOD0(applications_with_navi,
+          std::vector<application_manager::ApplicationSharedPtr>());
+      MOCK_CONST_METHOD0(get_limited_media_application,
+          application_manager::ApplicationSharedPtr());
+      MOCK_CONST_METHOD0(get_limited_navi_application,
+          application_manager::ApplicationSharedPtr());
+      MOCK_CONST_METHOD0(get_limited_voice_application,
+          application_manager::ApplicationSharedPtr());
+      MOCK_METHOD1(application_id,
+          uint32_t(const int32_t correlation_id));
+      MOCK_METHOD2(set_application_id,
+          void(const int32_t correlation_id, const uint32_t app_id));
+      MOCK_METHOD3(OnHMILevelChanged,
+          void(uint32_t app_id, mobile_apis::HMILevel::eType from, mobile_apis::HMILevel::eType to));
+      MOCK_METHOD1(SendHMIStatusNotification,
+          void(const utils::SharedPtr<application_manager::Application> app));
+      MOCK_METHOD2(SendMessageToMobile,
+          void(application_manager::commands::MessageSharedPtr, bool));
+      MOCK_METHOD1(SendMessageToHMI,
+          void(const application_manager::commands::MessageSharedPtr message));
+      MOCK_METHOD1(ManageHMICommand,
+          bool(const application_manager::commands::MessageSharedPtr message));
+      MOCK_METHOD2(ManageMobileCommand,
+          bool(const application_manager::commands::MessageSharedPtr message, application_manager::commands::Command::CommandOrigin origin));
+      MOCK_CONST_METHOD1(GetDefaultHmiLevel,
+          mobile_apis::HMILevel::eType(application_manager::ApplicationConstSharedPtr application));
+      MOCK_METHOD0(hmi_capabilities,
+          application_manager::HMICapabilities&());
+      MOCK_CONST_METHOD0(hmi_capabilities,
+          const application_manager::HMICapabilities&());
+      MOCK_METHOD2(ProcessQueryApp,
+          void(const smart_objects::SmartObject& sm_object, const uint32_t connection_key));
+      MOCK_CONST_METHOD0(is_attenuated_supported,
+          bool());
+      MOCK_CONST_METHOD1(IsAppTypeExistsInFullOrLimited,
+          bool(application_manager::ApplicationConstSharedPtr app));
+      MOCK_METHOD1(OnApplicationRegistered,
+          void(application_manager::ApplicationSharedPtr app));
+      MOCK_CONST_METHOD0(connection_handler,
+          connection_handler::ConnectionHandler&());
+      MOCK_CONST_METHOD0(protocol_handler,
+          protocol_handler::ProtocolHandler&());
+      MOCK_METHOD0(GetPolicyHandler,
+          policy::PolicyHandlerInterface&());
+      MOCK_METHOD0(GetNextHMICorrelationID,
+          uint32_t());
+      MOCK_METHOD0(GenerateNewHMIAppID,
+          uint32_t());
+      MOCK_METHOD1(EndNaviServices,
+          void(uint32_t app_id));
+      MOCK_METHOD0(BeginAudioPassThrough,
+          bool());
+      MOCK_METHOD0(EndAudioPassThrough,
+          bool());
+      MOCK_METHOD1(ConnectToDevice,
+          void(const std::string& device_mac));
+      MOCK_METHOD0(OnHMIStartedCooperation,
+          void());
+      MOCK_CONST_METHOD0(IsHMICooperating,
+          bool());
+      MOCK_METHOD2(IviInfoUpdated,
+          std::vector<application_manager::ApplicationSharedPtr>(application_manager::VehicleDataType vehicle_info, int value));
+      MOCK_METHOD1(RegisterApplication,
+          application_manager::ApplicationSharedPtr(const utils::SharedPtr< smart_objects::SmartObject>& request_for_registration));
+      MOCK_METHOD0(SendUpdateAppList,
+          void());
+      MOCK_METHOD2(MarkAppsGreyOut,
+          void(const connection_handler::DeviceHandle handle, bool is_greyed_out));
+      MOCK_CONST_METHOD1(IsAppsQueriedFrom,
+          bool(const connection_handler::DeviceHandle handle));
+      MOCK_CONST_METHOD0(IsStopping,
+          bool());
+      MOCK_METHOD1(RemoveAppFromTTSGlobalPropertiesList,
+          void(const uint32_t app_id));
+      MOCK_METHOD4(SaveBinary,
+          mobile_apis::Result::eType(const std::vector<uint8_t>& binary_data, const std::string& file_path, const std::string& file_name, const int64_t offset));
+      MOCK_METHOD1(SetAllAppsAllowed,
+          void(const bool& allowed));
+      MOCK_METHOD1(set_driver_distraction,
+          void(bool is_distracting));
+      MOCK_METHOD6(StartAudioPassThruThread,
+          void(int32_t session_key, int32_t correlation_id, int32_t max_duration, int32_t sampling_rate, int32_t bits_per_sample, int32_t audio_type));
+      MOCK_METHOD0(StartDevicesDiscovery,
+          void());
+      MOCK_METHOD1(StopAudioPassThru,
+          void(int32_t application_key));
+      MOCK_METHOD2(TerminateRequest,
+          void(uint32_t connection_key, uint32_t corr_id));
+      MOCK_METHOD4(UnregisterApplication,
+          void(const uint32_t&, mobile_apis::Result::eType, bool, bool));
+      MOCK_METHOD3(updateRequestTimeout,
+          void(uint32_t connection_key, uint32_t mobile_correlation_id, uint32_t new_timeout_value));
+      MOCK_METHOD0(state_controller,
+          application_manager::StateController&());
+      MOCK_METHOD1(SetUnregisterAllApplicationsReason,
+          void(mobile_apis::AppInterfaceUnregisteredReason::eType reason));
+      MOCK_METHOD1(HeadUnitReset,
+          void(mobile_apis::AppInterfaceUnregisteredReason::eType reason));
+      MOCK_CONST_METHOD2(HMILevelAllowsStreaming,
+          bool(uint32_t app_id, protocol_handler::ServiceType service_type));
+      MOCK_METHOD5(CheckPolicyPermissions,
+          mobile_apis::Result::eType(
+                     const std::string&,
+                     mobile_apis::HMILevel::eType,
+                     mobile_apis::FunctionID::eType,
+                     const application_manager::RPCParams&,
+                     application_manager::CommandParametersPermissions*));
+      MOCK_CONST_METHOD2(IsApplicationForbidden,
+          bool(uint32_t connection_key, const std::string& policy_app_id));
+      MOCK_METHOD0(resume_controller,
+          resumption::ResumeCtrl&());
+      MOCK_METHOD1(GetDeviceTransportType,
+          hmi_apis::Common_TransportType::eType(const std::string& transport_type));
+      MOCK_METHOD1(AddAppToTTSGlobalPropertiesList,
+          void(const uint32_t app_id));
+      MOCK_METHOD0(GenerateGrammarID,
+          uint32_t());
+      MOCK_CONST_METHOD1(GetUserConsentForDevice,
+          policy::DeviceConsent(const std::string& device_id));
+      MOCK_METHOD1(OnAppUnauthorized,
+          void(const uint32_t& app_id));
+      MOCK_METHOD1(ActivateApplication,
+          bool(application_manager::ApplicationSharedPtr app));
+      MOCK_METHOD3(OnAppStreaming,
+          void(uint32_t app_id, protocol_handler::ServiceType service_type, bool state));
+      MOCK_CONST_METHOD4(CreateRegularState,
+          application_manager::HmiStatePtr(uint32_t app_id, mobile_apis::HMILevel::eType hmi_level, mobile_apis::AudioStreamingState::eType audio_state, mobile_apis::SystemContext::eType system_context));
+      MOCK_METHOD2(SendAudioPassThroughNotification,
+          void(uint32_t session_key, std::vector<uint8_t>& binary_data));
+      MOCK_CONST_METHOD2(CanAppStream,
+          bool(uint32_t app_id, protocol_handler::ServiceType service_type));
+      MOCK_METHOD1(ForbidStreaming,
+          void(uint32_t app_id));
+      MOCK_CONST_METHOD0(get_settings,
+          const application_manager::ApplicationManagerSettings&());
+      MOCK_METHOD0(event_dispatcher,
+          application_manager::event_engine::EventDispatcher&());
 
-  MOCK_CONST_METHOD0(active_application, am::ApplicationSharedPtr());
-  MOCK_CONST_METHOD1(application_by_policy_id,
-                     am::ApplicationSharedPtr(const std::string&));
-  MOCK_METHOD1(applications_by_button,
-               std::vector<am::ApplicationSharedPtr>(uint32_t));
-  MOCK_METHOD0(applications_with_navi, std::vector<am::ApplicationSharedPtr>());
-  MOCK_CONST_METHOD0(get_limited_media_application, am::ApplicationSharedPtr());
-  MOCK_CONST_METHOD0(get_limited_navi_application, am::ApplicationSharedPtr());
-  MOCK_CONST_METHOD0(get_limited_voice_application, am::ApplicationSharedPtr());
-  MOCK_METHOD2(set_application_id, void(const int32_t, const uint32_t));
-  MOCK_METHOD1(application_id, const uint32_t(const int32_t));
-  MOCK_METHOD3(OnHMILevelChanged,
-               void(uint32_t,
-                    mobile_apis::HMILevel::eType,
-                    mobile_apis::HMILevel::eType));
-  MOCK_METHOD1(SendHMIStatusNotification, void(const am::ApplicationSharedPtr));
-  MOCK_CONST_METHOD1(
-      GetDefaultHmiLevel,
-      mobile_apis::HMILevel::eType(am::ApplicationConstSharedPtr));
-  MOCK_METHOD0(hmi_capabilities, am::HMICapabilities&());
-  MOCK_METHOD0(is_attenuated_supported, bool());
-  MOCK_CONST_METHOD1(IsAppTypeExistsInFullOrLimited,
-                     bool(am::ApplicationConstSharedPtr));
-  MOCK_METHOD1(OnApplicationRegistered, void(am::ApplicationSharedPtr));
-  MOCK_METHOD2(SendMessageToMobile,
-               void(const smart_objects::SmartObjectSPtr message,
-                    bool final_message));
-  MOCK_METHOD1(SendMessageToMobile,
-               void(const smart_objects::SmartObjectSPtr message));
-  MOCK_METHOD1(SendMessageToHMI,
-               void(const smart_objects::SmartObjectSPtr message));
-  MOCK_METHOD2(ManageMobileCommand,
-               bool(const smart_objects::SmartObjectSPtr message,
-                    am::commands::Command::CommandOrigin origin));
-  MOCK_METHOD1(ManageHMICommand,
-               bool(const smart_objects::SmartObjectSPtr message));
-  MOCK_CONST_METHOD2(CanAppStream, bool (uint32_t app_id,
-                                         protocol_handler::ServiceType service_type));
-  MOCK_METHOD1(ForbidStreaming, void (uint32_t app_id));
-  MOCK_METHOD2(SendAudioPassThroughNotification, void (uint32_t session_key,
-                                                       std::vector<uint8_t>& binary_data));
-  MOCK_CONST_METHOD0(connection_handler,
-                     connection_handler::ConnectionHandler&());
-  MOCK_METHOD0(GetPolicyHandler,
-                     policy::PolicyHandlerInterface&());
+      MOCK_CONST_METHOD1(IsAppSubscribedForWayPoints, bool(const uint32_t));
+      MOCK_METHOD1(SubscribeAppForWayPoints, void(const uint32_t));
+      MOCK_METHOD1(UnsubscribeAppFromWayPoints, void(const uint32_t));
+      MOCK_CONST_METHOD0(IsAnyAppSubscribedForWayPoints, bool());
+      MOCK_CONST_METHOD0(GetAppsSubscribedForWayPoints,
+                         const std::set<int32_t>());
 };
+
 }  // namespace application_manager_test
 }  // namespace components
 }  // namespace test
diff --git a/src/components/application_manager/test/include/application_manager/mock_event_dispatcher.h b/src/components/application_manager/test/include/application_manager/mock_event_dispatcher.h
new file mode 100644
index 0000000000..2ea0cb60a9
--- /dev/null
+++ b/src/components/application_manager/test/include/application_manager/mock_event_dispatcher.h
@@ -0,0 +1,67 @@
+/*
+ Copyright (c) 2016, 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_INCLUDE_APPLICATION_MANAGER_MOCK_EVENT_DISPATCHER_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_EVENT_DISPATCHER_H_
+
+#include <list>
+#include "application_manager/event_engine/event.h"
+#include "application_manager/event_engine/event_dispatcher.h"
+#include "application_manager/event_engine/event_observer.h"
+
+namespace test {
+namespace components {
+namespace event_engine_test {
+
+
+class MockEventDispatcher : public ::application_manager::event_engine::EventDispatcher {
+ public:
+  MOCK_METHOD1(raise_event,
+      void(const ::application_manager::event_engine::Event& event));
+  MOCK_METHOD3(add_observer,
+      void(const ::application_manager::event_engine::Event::EventID& event_id,
+           int32_t hmi_correlation_id,
+           ::application_manager::event_engine::EventObserver* const observer));
+  MOCK_METHOD2(remove_observer,
+      void(const ::application_manager::event_engine::Event::EventID& event_id,
+           ::application_manager::event_engine::EventObserver* const observer));
+  MOCK_METHOD1(remove_observer,
+      void(::application_manager::event_engine::EventObserver* const observer));
+};
+
+
+}  // namespace event_engine_test
+}  // namespace components
+}  // namespace test
+
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_EVENT_DISPATCHER_H_
diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h
index 7904006a04..799d59f003 100644
--- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h
+++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h
@@ -36,7 +36,8 @@
 #include "application_manager/application.h"
 #include "interfaces/HMI_API.h"
 #include "policy/policy_types.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/policies/policy_handler_interface.h"
+#include "application_manager/application_manager.h"
 
 namespace application_manager {
 
@@ -45,7 +46,8 @@ class MockMessageHelper {
  public:
   MOCK_METHOD1(GetHashUpdateNotification,
                smart_objects::SmartObjectSPtr(const uint32_t app_id));
-  MOCK_METHOD1(SendHashUpdateNotification, void(const uint32_t app_id));
+  MOCK_METHOD2(SendHashUpdateNotification, void(const uint32_t app_id,
+                                                ApplicationManager &app_mngr));
   MOCK_METHOD1(HMIResultToString,
                std::string(hmi_apis::Common_Result::eType hmi_result));
   MOCK_METHOD1(HMIResultFromString,
@@ -65,89 +67,101 @@ class MockMessageHelper {
   MOCK_METHOD1(CreateDeviceListSO,
                smart_objects::SmartObjectSPtr(
                    const connection_handler::DeviceMap& devices));
-  MOCK_METHOD1(SendNaviStartStream, void(int32_t connection_key));
-  MOCK_METHOD1(SendNaviStopStream, void(int32_t connection_key));
-  MOCK_METHOD2(SendOnAppPermissionsChangedNotification,
+  MOCK_METHOD2(SendNaviStartStream, void(int32_t connection_key,
+                                         ApplicationManager &app_mngr));
+  MOCK_METHOD2(SendNaviStopStream, void(int32_t connection_key,
+                                        ApplicationManager &app_mngr));
+  MOCK_METHOD3(SendOnAppPermissionsChangedNotification,
                void(uint32_t connection_key,
-                    const policy::AppPermissions& permissions));
-  MOCK_METHOD1(SendAudioStartStream, void(int32_t connection_key));
-  MOCK_METHOD1(SendAudioStopStream, void(int32_t connection_key));
-  MOCK_METHOD2(SendOnDataStreaming,
-               void(protocol_handler::ServiceType service, bool available));
-  MOCK_METHOD2(CreateGetVehicleDataRequest,
+                    const policy::AppPermissions& permissions,
+                    ApplicationManager& app_mngr));
+  MOCK_METHOD2(SendAudioStartStream, void(int32_t connection_key,
+                                          ApplicationManager &app_mngr));
+  MOCK_METHOD2(SendAudioStopStream, void(int32_t connection_key,
+                                         ApplicationManager &app_mngr));
+  MOCK_METHOD3(SendOnDataStreaming,
+               void(protocol_handler::ServiceType service, bool available,
+                    ApplicationManager &app_mngr));
+  MOCK_METHOD3(CreateGetVehicleDataRequest,
                void(uint32_t correlation_id,
-                    const std::vector<std::string>& params));
-  MOCK_METHOD2(SendUpdateSDLResponse,
-               void(const std::string& result, uint32_t correlation_id));
-  MOCK_METHOD2(SendGetUserFriendlyMessageResponse,
+                    const std::vector<std::string>& params,
+                    ApplicationManager &app_mngr));
+  MOCK_METHOD3(SendUpdateSDLResponse,
+               void(const std::string& result, uint32_t correlation_id,
+                    ApplicationManager &app_mngr));
+  MOCK_METHOD3(SendGetUserFriendlyMessageResponse,
                void(const std::vector<policy::UserFriendlyMessage>& msg,
-                    uint32_t correlation_id));
-  MOCK_METHOD2(SendGetStatusUpdateResponse,
-               void(const std::string& status, uint32_t correlation_id));
-  MOCK_METHOD1(SendOnStatusUpdate, void(const std::string& status));
-  MOCK_METHOD2(SendSDLActivateAppResponse,
+                    uint32_t correlation_id, ApplicationManager &app_mngr));
+  MOCK_METHOD3(SendGetStatusUpdateResponse,
+               void(const std::string& status, uint32_t correlation_id,
+                    ApplicationManager &app_mngr));
+  MOCK_METHOD2(SendOnStatusUpdate, void(const std::string& status,
+                                        ApplicationManager &app_mngr));
+  MOCK_METHOD3(SendSDLActivateAppResponse,
                void(policy::AppPermissions& permissions,
-                    uint32_t correlation_id));
-  MOCK_METHOD0(SendGetSystemInfoRequest, void());
-  MOCK_METHOD1(SendDecryptCertificateToHMI, void(const std::string& file_name));
-  MOCK_METHOD3(SendPolicyUpdate,
+                    uint32_t correlation_id,
+                    ApplicationManager &app_mngr));
+  MOCK_METHOD1(SendGetSystemInfoRequest, void(ApplicationManager &app_mngr));
+//  MOCK_METHOD2(SendDecryptCertificateToHMI, void(const std::string& file_name,
+//                                                 ApplicationManager &app_mngr));
+  MOCK_METHOD4(SendPolicyUpdate,
                void(const std::string& file_path,
                     int timeout,
-                    const std::vector<int>& retries));
-  MOCK_METHOD2(
+                    const std::vector<int>& retries,
+                    ApplicationManager &app_mngr));
+  MOCK_METHOD3(
       SendGetListOfPermissionsResponse,
       void(const std::vector<policy::FunctionalGroupPermission>& permissions,
-           uint32_t correlation_id));
-  MOCK_METHOD2(SendOnPermissionsChangeNotification,
+           uint32_t correlation_id,
+           ApplicationManager& app_mngr));
+  MOCK_METHOD3(SendOnPermissionsChangeNotification,
+               void(uint32_t connection_key,
+                    const policy::Permissions& permissions,
+                    ApplicationManager& app_mngr));
+  MOCK_METHOD4(SendPolicySnapshotNotification,
                void(uint32_t connection_key,
-                    const policy::Permissions& permissions));
-  MOCK_METHOD3(SendPolicySnapshotNotification,
-               void(unsigned int connection_key,
                     const std::vector<uint8_t>& policy_data,
-                    const std::string& url));
-  MOCK_METHOD2(SendOnAppInterfaceUnregisteredNotificationToMobile,
-               void(int32_t connection_key,
-                    mobile_apis::AppInterfaceUnregisteredReason::eType reason));
-  MOCK_METHOD1(SendOnLanguageChangeToMobile,
-               void(uint32_t connection_key));
-  MOCK_METHOD1(CommonLanguageFromString, hmi_apis::Common_Language::eType(
-          const std::string& language)) ;
-  MOCK_METHOD1(CommonLanguageToString, std::string(
-          hmi_apis::Common_Language::eType));
-  MOCK_METHOD1(MobileLanguageFromString,
-               mobile_apis::Language::eType(const std::string& lanugage));
-  MOCK_METHOD1(MobileToCommonLanguage,
-               hmi_apis::Common_Language::eType(const mobile_apis::Language::eType language));
-  MOCK_METHOD1(CommonToMobileLanguage,
-               mobile_apis::Language::eType(const hmi_apis::Common_Language::eType language));
-
-  MOCK_METHOD1(CreateModuleInfoSO, smart_objects::SmartObjectSPtr(uint32_t function_id));
-  MOCK_METHOD1(SendAllOnButtonSubscriptionNotificationsForApp,
-               void(ApplicationConstSharedPtr app));
-
-  MOCK_METHOD1(SendOnResumeAudioSourceToHMI, void(uint32_t app_id));
-  MOCK_METHOD1(CreateAddSubMenuRequestToHMI,
-               smart_objects::SmartObjectList(ApplicationConstSharedPtr app));
-  MOCK_METHOD1(CreateAddCommandRequestToHMI,
-               smart_objects::SmartObjectList(ApplicationConstSharedPtr app));
+                    const std::string& url,
+                    ApplicationManager& app_mngr));
+  MOCK_METHOD1(CommonLanguageFromString,
+               hmi_apis::Common_Language::eType(const std::string& language));
+  MOCK_METHOD1(CommonLanguageToString,
+               std::string(hmi_apis::Common_Language::eType));
+  MOCK_METHOD2(CreateModuleInfoSO,
+               smart_objects::SmartObjectSPtr(uint32_t function_id,
+                                              ApplicationManager &app_mngr));
+  MOCK_METHOD2(SendAllOnButtonSubscriptionNotificationsForApp,
+               void(ApplicationConstSharedPtr app,
+                    ApplicationManager &app_mngr));
+  MOCK_METHOD2(SendOnResumeAudioSourceToHMI, void(uint32_t app_id,
+                                                  ApplicationManager &app_mngr));
+  MOCK_METHOD2(CreateAddSubMenuRequestToHMI,
+               smart_objects::SmartObjectList(ApplicationConstSharedPtr app,
+                                              const uint32_t correlation_id));
+  MOCK_METHOD2(CreateAddCommandRequestToHMI,
+               smart_objects::SmartObjectList(ApplicationConstSharedPtr app,
+                                              ApplicationManager &app_mngr));
   MOCK_METHOD1(CreateAddVRCommandRequestFromChoiceToHMI,
                smart_objects::SmartObjectList(ApplicationConstSharedPtr app));
   MOCK_METHOD1(SendGlobalPropertiesToHMI, void(ApplicationConstSharedPtr app));
   MOCK_METHOD1(GetIVISubscriptionRequests,
                smart_objects::SmartObjectList(ApplicationSharedPtr app));
-  MOCK_METHOD2(VerifyImageFiles,
+  MOCK_METHOD3(VerifyImageFiles,
                mobile_apis::Result::eType(smart_objects::SmartObject& message,
-                                          ApplicationConstSharedPtr app));
-  MOCK_METHOD2(CheckWithPolicy,
-               bool(mobile_apis::SystemAction::eType, const std::string&));
 
-  MOCK_METHOD5(GetBCActivateAppRequestToHMI,
+                                          ApplicationConstSharedPtr app,
+                                          ApplicationManager& app_mngr));
+  MOCK_METHOD6(GetBCActivateAppRequestToHMI,
                smart_objects::SmartObjectSPtr(
                    ApplicationConstSharedPtr app,
-                   const protocol_handler::SessionObserver& session_observer,
-                   const policy::PolicyHandlerInterface& policy_handler,
-                   hmi_apis::Common_HMILevel::eType level,
-                   bool send_policy_priority));
+                         const protocol_handler::SessionObserver& session_observer,
+                         const policy::PolicyHandlerInterface& policy_handler,
+                         hmi_apis::Common_HMILevel::eType level,
+                         bool send_policy_priority, ApplicationManager &app_mngr));
+  MOCK_METHOD2(GetOnAppInterfaceUnregisteredNotificationToMobile,
+               NsSmartDeviceLink::NsSmartObjects::SmartObjectSPtr(
+                   int32_t connection_key,
+                   mobile_apis::AppInterfaceUnregisteredReason::eType reason));
 
   static MockMessageHelper* message_helper_mock();
 };
diff --git a/src/components/application_manager/test/include/application_manager/test_resumption_data_db.h b/src/components/application_manager/test/include/application_manager/test_resumption_data_db.h
new file mode 100644
index 0000000000..6c84fc1077
--- /dev/null
+++ b/src/components/application_manager/test/include/application_manager/test_resumption_data_db.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2015, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_TEST_RESUMPTION_DATA_DB_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_TEST_RESUMPTION_DATA_DB_H_
+
+#include "utils/sqlite_wrapper/sql_database.h"
+#include "application_manager/resumption/resumption_data_db.h"
+#include "application_manager/mock_application_manager_settings.h"
+
+using ::resumption::ResumptionDataDB;
+
+namespace test {
+namespace components {
+namespace resumption_test {
+
+class TestResumptionDataDB : public ResumptionDataDB {
+ public:
+  TestResumptionDataDB(application_manager_test::MockApplicationManagerSettings& mock_application_manager_settings)
+    : ResumptionDataDB(mock_application_manager_settings) {}
+};
+
+}  // namespace resumption_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_TEST_RESUMPTION_DATA_DB_H_
diff --git a/src/components/application_manager/test/libPolicy.so b/src/components/application_manager/test/libPolicy.so
deleted file mode 100644
index 0f2840d558..0000000000
--- a/src/components/application_manager/test/libPolicy.so
+++ /dev/null
diff --git a/src/components/application_manager/test/message_helper/CMakeLists.txt b/src/components/application_manager/test/message_helper/CMakeLists.txt
index 7f4c3303b3..bfc0228bbb 100755
--- a/src/components/application_manager/test/message_helper/CMakeLists.txt
+++ b/src/components/application_manager/test/message_helper/CMakeLists.txt
@@ -43,6 +43,7 @@ include_directories(
 set(LIBRARIES
     gmock
     ApplicationManager
+    MessageHelper
     jsoncpp
     connectionHandler
     MediaManager
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 48aaef1f9d..73f2de0544 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
@@ -41,6 +41,10 @@
 #include "utils/custom_string.h"
 #include "policy/mock_policy_settings.h"
 #include "application_manager/policies/policy_handler.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/event_engine/event_dispatcher.h"
+#include "application_manager/state_controller.h"
+#include "application_manager/resumption/resume_ctrl.h"
 
 namespace application_manager {
 namespace test {
@@ -135,16 +139,15 @@ TEST(MessageHelperTestCreate,
 
 TEST(MessageHelperTestCreate,
    CreateGlobalPropertiesRequestsToHMI_SmartObject_EmptyList) {
-  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
-  
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<MockApplication>();
   EXPECT_CALL(*appSharedMock, vr_help_title()).Times(AtLeast(1));
   EXPECT_CALL(*appSharedMock, vr_help()).Times(AtLeast(1));
   EXPECT_CALL(*appSharedMock, help_prompt()).Times(AtLeast(1));
   EXPECT_CALL(*appSharedMock, timeout_prompt()).Times(AtLeast(1));
-  
+
   smart_objects::SmartObjectList ptr =
-      MessageHelper::CreateGlobalPropertiesRequestsToHMI(appSharedMock);
-  
+      MessageHelper::CreateGlobalPropertiesRequestsToHMI(appSharedMock, 0u);
+
   EXPECT_TRUE(ptr.empty());
 }
 
@@ -179,7 +182,7 @@ TEST(MessageHelperTestCreate,
   EXPECT_CALL(*appSharedMock, app_id()).WillRepeatedly(Return(0));
   
   smart_objects::SmartObjectList ptr =
-      MessageHelper::CreateGlobalPropertiesRequestsToHMI(appSharedMock);
+      MessageHelper::CreateGlobalPropertiesRequestsToHMI(appSharedMock, 0u);
 
   EXPECT_FALSE(ptr.empty());
 
@@ -209,7 +212,7 @@ TEST(MessageHelperTestCreate,
       show_command()).Times(AtLeast(2)).WillRepeatedly(Return(&object));
   
   smart_objects::SmartObjectList ptr =
-      MessageHelper::CreateShowRequestToHMI(appSharedMock);
+      MessageHelper::CreateShowRequestToHMI(appSharedMock, 0u);
 
   EXPECT_FALSE(ptr.empty());
 
@@ -223,15 +226,15 @@ TEST(MessageHelperTestCreate,
 
 TEST(MessageHelperTestCreate,
    CreateAddCommandRequestToHMI_SendSmartObject_Empty) {
-  MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
-  CommandsMap vis;
-  DataAccessor< CommandsMap> data_accessor(vis, true);
+  MockApplicationSharedPtr appSharedMock = utils::MakeShared<MockApplication>();
+  ::application_manager::CommandsMap vis;
+  DataAccessor<application_manager::CommandsMap> data_accessor(vis, true);
   
   EXPECT_CALL(*appSharedMock,
       commands_map()).WillOnce(Return(data_accessor));
-  
+  application_manager_test::MockApplicationManager mock_application_manager;
   smart_objects::SmartObjectList ptr =
-      MessageHelper::CreateAddCommandRequestToHMI(appSharedMock);
+      MessageHelper::CreateAddCommandRequestToHMI(appSharedMock, mock_application_manager);
   
   EXPECT_TRUE(ptr.empty());
 }
@@ -256,10 +259,10 @@ TEST(MessageHelperTestCreate,
   EXPECT_CALL(*appSharedMock,
       commands_map()).WillOnce(Return(data_accessor));
   EXPECT_CALL(*appSharedMock,
-      app_id()).WillOnce(Return(1u));
-
+      app_id()).WillOnce(Return(1u));  
+  application_manager_test::MockApplicationManager mock_application_manager;
   smart_objects::SmartObjectList ptr =
-      MessageHelper::CreateAddCommandRequestToHMI(appSharedMock);
+      MessageHelper::CreateAddCommandRequestToHMI(appSharedMock, mock_application_manager);
 
   EXPECT_FALSE(ptr.empty());
 
@@ -286,9 +289,9 @@ TEST(MessageHelperTestCreate,
   
   EXPECT_CALL(*appSharedMock,
       choice_set_map()).WillOnce(Return(data_accessor));
-  
+  application_manager_test::MockApplicationManager mock_application_manager;
   smart_objects::SmartObjectList ptr =
-      MessageHelper::CreateAddVRCommandRequestFromChoiceToHMI(appSharedMock);
+      MessageHelper::CreateAddVRCommandRequestFromChoiceToHMI(appSharedMock, mock_application_manager);
   
   EXPECT_TRUE(ptr.empty());
 }
@@ -323,9 +326,9 @@ TEST(MessageHelperTestCreate,
       choice_set_map()).WillOnce(Return(data_accessor));
   EXPECT_CALL(*appSharedMock,
       app_id()).Times(AtLeast(5)).WillRepeatedly(Return(1u));
-  
+  application_manager_test::MockApplicationManager mock_application_manager;
   smart_objects::SmartObjectList ptr =
-      MessageHelper::CreateAddVRCommandRequestFromChoiceToHMI(appSharedMock);
+      MessageHelper::CreateAddVRCommandRequestFromChoiceToHMI(appSharedMock, mock_application_manager);
 
   EXPECT_FALSE(ptr.empty());
 
@@ -364,8 +367,9 @@ TEST(MessageHelperTestCreate, CreateAddSubMenuRequestToHMI_SendObject_Equal) {
   EXPECT_CALL(*appSharedMock,
       app_id()).Times(AtLeast(1)).WillOnce(Return(1u));
 
+  const uint32_t cor_id = 0u;
   smart_objects::SmartObjectList ptr =
-      MessageHelper::CreateAddSubMenuRequestToHMI(appSharedMock);
+      MessageHelper::CreateAddSubMenuRequestToHMI(appSharedMock, cor_id);
 
   EXPECT_FALSE(ptr.empty());
 
@@ -395,8 +399,9 @@ TEST(MessageHelperTestCreate,
   EXPECT_CALL(*appSharedMock,
       sub_menu_map() ).WillOnce(Return(data_accessor));
 
+  const uint32_t cor_id = 0u;
   smart_objects::SmartObjectList ptr =
-      MessageHelper::CreateAddSubMenuRequestToHMI(appSharedMock);
+      MessageHelper::CreateAddSubMenuRequestToHMI(appSharedMock, cor_id);
 
   EXPECT_TRUE(ptr.empty());
 }
@@ -510,6 +515,7 @@ class MessageHelperTest : public ::testing::Test {
         delta_from_functions_id(32768) {}
 
   protected:
+    application_manager_test::MockApplicationManager mock_application_manager;
     const StringArray language_strings;
     const StringArray hmi_result_strings;
     const StringArray mobile_result_strings;
@@ -670,8 +676,9 @@ TEST_F(MessageHelperTest,
       .WillOnce(Return(1u));
   EXPECT_CALL(*appSharedMock, SubscribedIVI())
       .WillOnce(Return(data_accessor));
+
   smart_objects::SmartObjectList outList =
-      MessageHelper::GetIVISubscriptionRequests(appSharedMock);
+      MessageHelper::GetIVISubscriptionRequests(appSharedMock, mock_application_manager);
   // Expect not empty request
   EXPECT_FALSE(outList.empty());
 }
@@ -683,10 +690,10 @@ TEST_F(MessageHelperTest,
   // Creating input data for method
   smart_objects::SmartObject object;
   policy_handler_test::MockPolicySettings policy_settings_;
-  const policy::PolicyHandler policy_handler (policy_settings_);
+  const policy::PolicyHandler policy_handler (policy_settings_, mock_application_manager);
   // Method call
   mobile_apis::Result::eType result =
-      MessageHelper::ProcessSoftButtons(object, appSharedMock, policy_handler);
+      MessageHelper::ProcessSoftButtons(object, appSharedMock, policy_handler, mock_application_manager);
   // Expect
   EXPECT_EQ(mobile_apis::Result::SUCCESS, result);
 }
@@ -701,10 +708,10 @@ TEST_F(MessageHelperTest,
   // Setting invalid image string to button
   buttons[0][strings::image][strings::value] = "invalid\\nvalue";
   policy_handler_test::MockPolicySettings policy_settings_;
-  const policy::PolicyHandler policy_handler (policy_settings_);
+  const policy::PolicyHandler policy_handler (policy_settings_, mock_application_manager);
   // Method call
   mobile_apis::Result::eType result =
-      MessageHelper::ProcessSoftButtons(object, appSharedMock, policy_handler);
+      MessageHelper::ProcessSoftButtons(object, appSharedMock, policy_handler, mock_application_manager);
   // Expect
   EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result);
 }
@@ -718,7 +725,7 @@ TEST_F(MessageHelperTest,
   image[strings::image_type] = mobile_apis::ImageType::STATIC;
   // Method call
   mobile_apis::Result::eType result =
-      MessageHelper::VerifyImage(image, appSharedMock);
+      MessageHelper::VerifyImage(image, appSharedMock, mock_application_manager);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::SUCCESS, result);
 }
@@ -734,7 +741,7 @@ TEST_F(MessageHelperTest,
   image[strings::value] = "   ";
   // Method call
   mobile_apis::Result::eType result =
-      MessageHelper::VerifyImage(image, appSharedMock);
+      MessageHelper::VerifyImage(image, appSharedMock, mock_application_manager);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result);
 }
@@ -750,7 +757,7 @@ TEST_F(MessageHelperTest,
   images[1][strings::image_type] = mobile_apis::ImageType::STATIC;
   // Method call
   mobile_apis::Result::eType result =
-      MessageHelper::VerifyImageFiles(images, appSharedMock);
+      MessageHelper::VerifyImageFiles(images, appSharedMock, mock_application_manager);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::SUCCESS, result);
 }
@@ -768,7 +775,7 @@ TEST_F(MessageHelperTest,
   images[1][strings::value] = "image\\n";
   // Method call
   mobile_apis::Result::eType result =
-      MessageHelper::VerifyImageFiles(images, appSharedMock);
+      MessageHelper::VerifyImageFiles(images, appSharedMock, mock_application_manager);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result);
 }
@@ -785,7 +792,7 @@ TEST_F(MessageHelperTest,
       mobile_apis::ImageType::STATIC;
   // Method call
   mobile_apis::Result::eType result =
-      MessageHelper::VerifyImageVrHelpItems(message, appSharedMock);
+      MessageHelper::VerifyImageVrHelpItems(message, appSharedMock, mock_application_manager);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::SUCCESS, result);
 }
@@ -805,7 +812,7 @@ TEST_F(MessageHelperTest,
   message[1][strings::image][strings::value] = "image\\n";
   // Method call
   mobile_apis::Result::eType result =
-      MessageHelper::VerifyImageVrHelpItems(message, appSharedMock);
+      MessageHelper::VerifyImageVrHelpItems(message, appSharedMock, mock_application_manager);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result);
 }
diff --git a/src/components/application_manager/test/mock/event_observer_mock.h b/src/components/application_manager/test/mock/event_observer_mock.h
index 3e25c2b084..f61d0377bb 100644
--- a/src/components/application_manager/test/mock/event_observer_mock.h
+++ b/src/components/application_manager/test/mock/event_observer_mock.h
@@ -37,16 +37,20 @@
 #include "application_manager/event_engine/event.h"
 #include "gmock/gmock.h"
 
-namespace application_manager {
-namespace event_engine {
+namespace test {
+namespace components {
+namespace event_engine_test {
 
-class MockEventObserver : public EventObserver {
+class MockEventObserver : public application_manager::event_engine::EventObserver {
  public:
-  MOCK_METHOD1(on_event, void(const application_manager::event_engine::Event& event));
+    MockEventObserver(::application_manager::event_engine::EventDispatcher& event_dispatcher): application_manager::event_engine::EventObserver(event_dispatcher){}
+  MOCK_METHOD1(on_event,
+               void(const application_manager::event_engine::Event& event));
 };
 
-}  // namespace event_engine
-}  // namespace application_manager
+}  // namespace event_engine_test
+}  // namespace components
+}  // namespace test
 
 #endif // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_MOCK_EVENT_OBSERVER_MOCK_H_
 
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 8ac52d72bd..88b9faedf6 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
@@ -285,8 +285,8 @@ class ApplicationManagerImpl
   MOCK_METHOD0(GenerateGrammarID, uint32_t());
   MOCK_METHOD0(GenerateNewHMIAppID, uint32_t());
   MOCK_METHOD1(GetAvailableSpaceForApp, uint32_t(const std::string&));
-  MOCK_METHOD0(begin_audio_pass_thru, bool());
-  MOCK_METHOD0(end_audio_pass_thru, uint32_t());
+  MOCK_METHOD0(BeginAudioPassThrough, bool());
+  MOCK_METHOD0(EndAudioPassThrough, uint32_t());
   MOCK_METHOD1(StopAudioPassThru, void(uint32_t));
   MOCK_METHOD1(applications_by_button,
                std::vector<ApplicationSharedPtr>(uint32_t));
@@ -405,7 +405,7 @@ class ApplicationManagerImpl
    */
   class ApplicationListAccessor : public DataAccessor<ApplicationSet> {
    public:
-    ApplicationListAccessor()
+    ApplicationListAccessor(const application_manager::ApplicationManagerImpl& app_man)
         : DataAccessor<ApplicationSet>(ApplicationSet(),
                                        sync_primitives::Lock()) {}
     MOCK_CONST_METHOD0(applications, const ApplicationSet());
diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc
index e460928123..66e9f6cdc8 100644
--- a/src/components/application_manager/test/mock_message_helper.cc
+++ b/src/components/application_manager/test/mock_message_helper.cc
@@ -32,31 +32,40 @@
 
 #include "application_manager/message_helper.h"
 #include "application_manager/mock_message_helper.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/policies/policy_handler_interface.h"
 
 namespace application_manager {
 
-void MessageHelper::SendHashUpdateNotification(uint32_t const app_id) {
-  MockMessageHelper::message_helper_mock()->SendHashUpdateNotification(app_id);
+void MessageHelper::SendHashUpdateNotification(uint32_t const app_id,
+                                               ApplicationManager& app_mngr) {
+  MockMessageHelper::message_helper_mock()->SendHashUpdateNotification(
+      app_id, app_mngr);
 }
-
-void MessageHelper::SendNaviStartStream(int32_t connection_key) {
-  MockMessageHelper::message_helper_mock()->SendNaviStartStream(connection_key);
+void MessageHelper::SendNaviStartStream(int32_t connection_key,
+                                        ApplicationManager& app_mngr) {
+  MockMessageHelper::message_helper_mock()->SendNaviStartStream(connection_key,
+                                                                app_mngr);
 }
-void MessageHelper::SendNaviStopStream(int32_t connection_key) {
-  MockMessageHelper::message_helper_mock()->SendNaviStopStream(connection_key);
+void MessageHelper::SendNaviStopStream(int32_t connection_key,
+                                       ApplicationManager& app_mngr) {
+  MockMessageHelper::message_helper_mock()->SendNaviStopStream(connection_key,
+                                                               app_mngr);
 }
-void MessageHelper::SendAudioStartStream(int32_t connection_key) {
-  MockMessageHelper::message_helper_mock()->SendAudioStartStream(
-      connection_key);
+void MessageHelper::SendAudioStartStream(int32_t connection_key,
+                                         ApplicationManager& app_mngr) {
+  MockMessageHelper::message_helper_mock()->SendAudioStartStream(connection_key,
+                                                                 app_mngr);
 }
-void MessageHelper::SendAudioStopStream(int32_t connection_key) {
-  MockMessageHelper::message_helper_mock()->SendAudioStopStream(connection_key);
+void MessageHelper::SendAudioStopStream(int32_t connection_key,
+                                        ApplicationManager& app_mngr) {
+  MockMessageHelper::message_helper_mock()->SendAudioStopStream(connection_key,
+                                                                app_mngr);
 }
 void MessageHelper::SendOnDataStreaming(protocol_handler::ServiceType service,
-                                        bool available) {
-  MockMessageHelper::message_helper_mock()->SendOnDataStreaming(service,
-                                                                available);
+                                        bool available,
+                                        ApplicationManager& app_mngr) {
+  MockMessageHelper::message_helper_mock()->SendOnDataStreaming(
+      service, available, app_mngr);
 }
 
 smart_objects::SmartObjectSPtr GetHashUpdateNotification(
@@ -112,92 +121,86 @@ smart_objects::SmartObjectSPtr CreateDeviceListSO(
 }
 
 void MessageHelper::SendOnAppPermissionsChangedNotification(
-    uint32_t connection_key, const policy::AppPermissions& permissions) {
+    uint32_t connection_key, const policy::AppPermissions& permissions,
+    ApplicationManager& app_mngr) {
   MockMessageHelper::message_helper_mock()
-      ->SendOnAppPermissionsChangedNotification(connection_key, permissions);
+      ->SendOnAppPermissionsChangedNotification(connection_key, permissions,
+                                                app_mngr);
 }
 
 void MessageHelper::SendGetUserFriendlyMessageResponse(
     const std::vector<policy::UserFriendlyMessage>& msg,
-    uint32_t correlation_id) {
+    uint32_t correlation_id, ApplicationManager& app_mngr) {
   MockMessageHelper::message_helper_mock()->SendGetUserFriendlyMessageResponse(
-      msg, correlation_id);
+      msg, correlation_id, app_mngr);
 }
 
 void MessageHelper::SendGetStatusUpdateResponse(const std::string& status,
-                                                uint32_t correlation_id) {
+                                                uint32_t correlation_id,
+                                                ApplicationManager& app_mngr) {
   MockMessageHelper::message_helper_mock()->SendGetStatusUpdateResponse(
-      status, correlation_id);
+      status, correlation_id, app_mngr);
 }
 
-void MessageHelper::SendOnStatusUpdate(const std::string& status) {
-  MockMessageHelper::message_helper_mock()->SendOnStatusUpdate(status);
+void MessageHelper::SendOnStatusUpdate(const std::string& status,
+                                       ApplicationManager& app_mngr) {
+  MockMessageHelper::message_helper_mock()->SendOnStatusUpdate(status,
+                                                               app_mngr);
 }
 
-void MessageHelper::SendGetSystemInfoRequest() {
-  MockMessageHelper::message_helper_mock()->SendGetSystemInfoRequest();
+void MessageHelper::SendGetSystemInfoRequest(ApplicationManager& app_mngr) {
+  MockMessageHelper::message_helper_mock()->SendGetSystemInfoRequest(app_mngr);
 }
 
 void MessageHelper::CreateGetVehicleDataRequest(
-    uint32_t correlation_id, const std::vector<std::string>& params) {
+    uint32_t correlation_id, const std::vector<std::string>& params,
+    ApplicationManager& app_mngr) {
   MockMessageHelper::message_helper_mock()->CreateGetVehicleDataRequest(
-      correlation_id, params);
+      correlation_id, params, app_mngr);
 }
 
 void MessageHelper::SendGetListOfPermissionsResponse(
     const std::vector<policy::FunctionalGroupPermission>& permissions,
-    uint32_t correlation_id) {
+    uint32_t correlation_id, ApplicationManager& app_mngr) {
   MockMessageHelper::message_helper_mock()->SendGetListOfPermissionsResponse(
-      permissions, correlation_id);
+      permissions, correlation_id, app_mngr);
 }
 
 void MessageHelper::SendOnPermissionsChangeNotification(
-    uint32_t connection_key, const policy::Permissions& permissions) {
+    uint32_t connection_key, const policy::Permissions& permissions,
+    ApplicationManager& app_mngr) {
   MockMessageHelper::message_helper_mock()->SendOnPermissionsChangeNotification(
-      connection_key, permissions);
+      connection_key, permissions, app_mngr);
 }
 
 void MessageHelper::SendPolicySnapshotNotification(
-    unsigned int connection_key,
+    uint32_t connection_key,
     const std::vector<uint8_t>& policy_data,
-    const std::string& url) {
+    const std::string& url,
+    ApplicationManager& app_mngr) {
   MockMessageHelper::message_helper_mock()->SendPolicySnapshotNotification(
-      connection_key, policy_data, url);
-}
-void MessageHelper::SendOnAppInterfaceUnregisteredNotificationToMobile(
-    int32_t connection_key,
-    mobile_apis::AppInterfaceUnregisteredReason::eType reason) {
-  MockMessageHelper::message_helper_mock()
-      ->SendOnAppInterfaceUnregisteredNotificationToMobile(connection_key,
-                                                           reason);
+      connection_key, policy_data, url, app_mngr);
 }
 
 void MessageHelper::SendSDLActivateAppResponse(
-    policy::AppPermissions& permissions, uint32_t correlation_id) {
+    policy::AppPermissions& permissions, uint32_t correlation_id,
+    ApplicationManager& app_mngr) {
   MockMessageHelper::message_helper_mock()->SendSDLActivateAppResponse(
-      permissions, correlation_id);
+      permissions, correlation_id, app_mngr);
 }
 
-void MessageHelper::SendPolicyUpdate(const std::string& file_path,
-                                     int timeout,
-                                     const std::vector<int>& retries) {
-  MockMessageHelper::message_helper_mock()->SendPolicyUpdate(
-      file_path, timeout, retries);
+void MessageHelper::SendPolicyUpdate(const std::string& file_path, int timeout,
+                                     const std::vector<int>& retries,
+                                     ApplicationManager& app_mngr) {
+  MockMessageHelper::message_helper_mock()->SendPolicyUpdate(file_path, timeout,
+                                                             retries, app_mngr);
 }
 
 void MessageHelper::SendUpdateSDLResponse(const std::string& result,
-                                          uint32_t correlation_id) {
+                                          uint32_t correlation_id,
+                                          ApplicationManager& app_mngr) {
   MockMessageHelper::message_helper_mock()->SendUpdateSDLResponse(
-      result, correlation_id);
-}
-
-void MessageHelper::SendOnLanguageChangeToMobile(uint32_t connection_key) {
-  MockMessageHelper::message_helper_mock()->SendOnLanguageChangeToMobile(connection_key);
-}
-
-void MessageHelper::SendDecryptCertificateToHMI(const std::string& file_name) {
-  MockMessageHelper::message_helper_mock()->SendDecryptCertificateToHMI(
-      file_name);
+      result, correlation_id, app_mngr);
 }
 
 hmi_apis::Common_Language::eType MessageHelper::CommonLanguageFromString(const std::string& language) {
@@ -205,21 +208,10 @@ hmi_apis::Common_Language::eType MessageHelper::CommonLanguageFromString(const s
         language);
 }
 
-mobile_apis::Language::eType MessageHelper::MobileLanguageFromString(const std::string& language) {
-  return  MockMessageHelper::message_helper_mock()->MobileLanguageFromString(language);
-}
-
-hmi_apis::Common_Language::eType MessageHelper::MobileToCommonLanguage(const mobile_apis::Language::eType language) {
-  return MockMessageHelper::message_helper_mock()->MobileToCommonLanguage(language);
-}
-
-mobile_apis::Language::eType MessageHelper::CommonToMobileLanguage(const hmi_apis::Common_Language::eType language) {
-  return  MockMessageHelper::message_helper_mock()->CommonToMobileLanguage(language);
-}
-
-smart_objects::SmartObjectSPtr MessageHelper::CreateModuleInfoSO (uint32_t function_id) {
-    return  MockMessageHelper::message_helper_mock()->CreateModuleInfoSO(
-                function_id);
+smart_objects::SmartObjectSPtr MessageHelper::CreateModuleInfoSO(
+    uint32_t function_id, ApplicationManager& app_mngr) {
+  return MockMessageHelper::message_helper_mock()->CreateModuleInfoSO(
+      function_id, app_mngr);
 }
 
 MockMessageHelper* MockMessageHelper::message_helper_mock() {
@@ -227,63 +219,77 @@ MockMessageHelper* MockMessageHelper::message_helper_mock() {
   return &message_helper_mock;
 }
 void MessageHelper::SendAllOnButtonSubscriptionNotificationsForApp(
-    ApplicationConstSharedPtr app) {
+    ApplicationConstSharedPtr app, ApplicationManager& app_mngr) {
   MockMessageHelper::message_helper_mock()
-      ->SendAllOnButtonSubscriptionNotificationsForApp(app);
+      ->SendAllOnButtonSubscriptionNotificationsForApp(app, app_mngr);
 }
 
-void MessageHelper::SendOnResumeAudioSourceToHMI(const uint32_t app_id) {
+void MessageHelper::SendOnResumeAudioSourceToHMI(const uint32_t app_id,
+                                                 ApplicationManager& app_mngr) {
   MockMessageHelper::message_helper_mock()->SendOnResumeAudioSourceToHMI(
-      app_id);
+      app_id, app_mngr);
 }
 
 smart_objects::SmartObjectList MessageHelper::CreateAddSubMenuRequestToHMI(
-    ApplicationConstSharedPtr app) {
+    ApplicationConstSharedPtr app, const uint32_t correlation_id) {
   return MockMessageHelper::message_helper_mock()->CreateAddSubMenuRequestToHMI(
-      app);
+      app, correlation_id);
 }
 
 smart_objects::SmartObjectList MessageHelper::CreateAddCommandRequestToHMI(
-    ApplicationConstSharedPtr app) {
+    ApplicationConstSharedPtr app, ApplicationManager& app_mngr) {
   return MockMessageHelper::message_helper_mock()->CreateAddCommandRequestToHMI(
-      app);
+      app, app_mngr);
 }
 
 smart_objects::SmartObjectList
 MessageHelper::CreateAddVRCommandRequestFromChoiceToHMI(
-    ApplicationConstSharedPtr app) {
+    ApplicationConstSharedPtr app, ApplicationManager& app_mngr) {
   return MockMessageHelper::message_helper_mock()
       ->CreateAddVRCommandRequestFromChoiceToHMI(app);
 }
 
-void MessageHelper::SendGlobalPropertiesToHMI(ApplicationConstSharedPtr app) {
+void MessageHelper::SendGlobalPropertiesToHMI(ApplicationConstSharedPtr app,
+                                              ApplicationManager& app_mngr) {
   return MockMessageHelper::message_helper_mock()->SendGlobalPropertiesToHMI(
       app);
 }
 
 smart_objects::SmartObjectList MessageHelper::GetIVISubscriptionRequests(
-    ApplicationSharedPtr app) {
+    ApplicationSharedPtr app, ApplicationManager& app_mngr) {
   return MockMessageHelper::message_helper_mock()->GetIVISubscriptionRequests(
       app);
 }
 
 mobile_apis::Result::eType MessageHelper::VerifyImageFiles(
-    smart_objects::SmartObject& message, ApplicationConstSharedPtr app) {
-  return MockMessageHelper::message_helper_mock()->VerifyImageFiles(message,
-                                                                    app);
+    smart_objects::SmartObject& message, ApplicationConstSharedPtr app,
+    ApplicationManager& app_mngr) {
+  return MockMessageHelper::message_helper_mock()->VerifyImageFiles(
+      message, app, app_mngr);
 }
 std::string MessageHelper::CommonLanguageToString(
     hmi_apis::Common_Language::eType lang) {
   return MockMessageHelper::message_helper_mock()->CommonLanguageToString(lang);
 }
 
-smart_objects::SmartObjectSPtr MessageHelper::GetBCActivateAppRequestToHMI(ApplicationConstSharedPtr app,
+smart_objects::SmartObjectSPtr MessageHelper::GetBCActivateAppRequestToHMI(
+    ApplicationConstSharedPtr app,
     const protocol_handler::SessionObserver& session_observer,
-    const policy::PolicyHandlerInterface &policy_handler,
-    hmi_apis::Common_HMILevel::eType level,
-    bool send_policy_priority) {
+    const policy::PolicyHandlerInterface& policy_handler,
+    hmi_apis::Common_HMILevel::eType level, bool send_policy_priority,
+    ApplicationManager& app_mngr) {
   return MockMessageHelper::message_helper_mock()->GetBCActivateAppRequestToHMI(
-      app, session_observer, policy_handler, level, send_policy_priority);
+      app, session_observer, policy_handler, level, send_policy_priority,
+      app_mngr);
+}
+
+NsSmartDeviceLink::NsSmartObjects::SmartObjectSPtr
+MessageHelper::GetOnAppInterfaceUnregisteredNotificationToMobile(
+    int32_t connection_key,
+    mobile_apis::AppInterfaceUnregisteredReason::eType reason) {
+  return MockMessageHelper::message_helper_mock()
+      ->GetOnAppInterfaceUnregisteredNotificationToMobile(connection_key,
+                                                          reason);
 }
 
 }  // namespace application_manager
diff --git a/src/components/application_manager/test/policy_event_observer_test.cc b/src/components/application_manager/test/policy_event_observer_test.cc
new file mode 100644
index 0000000000..4bc7f6a1e6
--- /dev/null
+++ b/src/components/application_manager/test/policy_event_observer_test.cc
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2015, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "application_manager/policies/policy_event_observer.h"
+#include "application_manager/policies/mock_policy_handler_interface.h"
+
+#include "gmock/gmock.h"
+#include "policy/policy_types.h"
+#include "smart_objects/smart_object.h"
+#include "application_manager/mock_event_dispatcher.h"
+
+namespace test {
+namespace components {
+namespace policy_test {
+
+namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
+using application_manager::event_engine::Event;
+using namespace policy;
+
+using testing::_;
+using ::testing::Return;
+
+class PolicyEventObserverTest : public ::testing::Test {
+ public:
+  PolicyEventObserverTest()
+      : policy_event_observer_(NULL),
+        event_(NULL),
+        field_name("odometer") {}
+
+ protected:
+  MockPolicyHandlerInterface policy_handler_mock_;
+  event_engine_test::MockEventDispatcher mock_event_dispatcher_;
+  PolicyEventObserver* policy_event_observer_;
+  Event* event_;
+  smart_objects::SmartObject smart_object_;
+  const std::string field_name;
+  const int field_value = 100;
+
+  virtual void SetUp() OVERRIDE {
+    policy_event_observer_ = new PolicyEventObserver(&policy_handler_mock_,
+                                                     mock_event_dispatcher_);
+  }
+
+  virtual void TearDown() OVERRIDE {
+    delete policy_event_observer_;
+    DeleteEvent();
+  }
+
+  void CreateEvent(const Event::EventID& event_id) {
+    event_ = new Event(event_id);
+  }
+
+  void CookSmartObject(const hmi_apis::Common_Result::eType& result,
+                       const std::string& msg_params_field,
+                       int msg_params_field_value) {
+    smart_object_["params"]["code"] = result;
+    smart_object_["msg_params"][msg_params_field] = msg_params_field_value;
+  }
+
+  void CheckResultsOnEvent(uint32_t pt_updated_calls_number,
+                           uint32_t on_system_ready_calls_number) {
+    event_->set_smart_object(smart_object_);
+    EXPECT_CALL(policy_handler_mock_, PTUpdatedAt(Counters::KILOMETERS, field_value))
+        .Times(pt_updated_calls_number);
+    EXPECT_CALL(policy_handler_mock_, OnSystemReady())
+        .Times(on_system_ready_calls_number);
+    policy_event_observer_->on_event(*event_);
+  }
+
+  void DeleteEvent() { delete event_; }
+};
+
+TEST_F(PolicyEventObserverTest, OnEvent_EventInvalid_ExpectNoProcessingEvent) {
+  // Arrange
+  CreateEvent(Event::EventID::INVALID_ENUM);
+  CookSmartObject(hmi_apis::Common_Result::SUCCESS, field_name, field_value);
+  CheckResultsOnEvent(0u, 0u);
+}
+
+TEST_F(PolicyEventObserverTest,
+       OnEvent_EventInvalidCommonResult_ExpectNoProcessingEvent) {
+  // Arrange
+  CreateEvent(Event::EventID::VehicleInfo_GetVehicleData);
+  CookSmartObject(hmi_apis::Common_Result::INVALID_DATA, field_name,
+                  field_value);
+  // Check
+  CheckResultsOnEvent(0u, 0u);
+}
+
+TEST_F(PolicyEventObserverTest,
+       OnEvent_EventGetVehicleData_ExpectProcessOdometerEvent) {
+  // Arrange
+  CreateEvent(Event::EventID::VehicleInfo_GetVehicleData);
+  CookSmartObject(hmi_apis::Common_Result::SUCCESS, field_name, field_value);
+  // Check
+  CheckResultsOnEvent(1u, 0u);
+}
+
+TEST_F(PolicyEventObserverTest,
+       OnEvent_EventBasicCommunication_OnReady_ExpectOnSystemReady) {
+  // Arrange
+  CreateEvent(Event::EventID::BasicCommunication_OnReady);
+  CookSmartObject(hmi_apis::Common_Result::SUCCESS, field_name, field_value);
+  // Check
+  CheckResultsOnEvent(0u, 1u);
+}
+
+}  // namespace policy_event_observer
+}  // namespace components
+}  // namespace test
diff --git a/src/components/application_manager/test/policy_handler_test.cc b/src/components/application_manager/test/policy_handler_test.cc
new file mode 100644
index 0000000000..c61d4a1546
--- /dev/null
+++ b/src/components/application_manager/test/policy_handler_test.cc
@@ -0,0 +1,935 @@
+/*
+ * Copyright (c) 2016, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <string>
+#include <vector>
+#include <fstream>
+#include "gmock/gmock.h"
+
+#include "application_manager/policies/policy_handler.h"
+#include "policy/mock_policy_manager.h"
+#include "connection_handler/connection_handler_impl.h"
+#include "application_manager/application_manager_impl.h"
+#include "application_manager/application_impl.h"
+#include "security_manager/mock_security_manager.h"
+#include "security_manager/mock_crypto_manager.h"
+#include "application_manager/mock_message_helper.h"
+#include "connection_handler/mock_connection_handler_settings.h"
+#include "transport_manager/mock_transport_manager.h"
+#include "policy/policy_types.h"
+#include "json/reader.h"
+#include "json/writer.h"
+#include "json/value.h"
+#include "smart_objects/smart_object.h"
+#include "utils/file_system.h"
+#include "utils/make_shared.h"
+#include "utils/custom_string.h"
+#include "policy/usage_statistics/counter.h"
+#include "policy/usage_statistics/statistics_manager.h"
+#include "interfaces/MOBILE_API.h"
+#include "policy/mock_policy_settings.h"
+#include  "utils/make_shared.h"
+#include "application_manager/mock_application.h"
+#include "policy/usage_statistics/mock_statistics_manager.h"
+#include "protocol_handler/mock_session_observer.h"
+#include "connection_handler/mock_connection_handler.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/policies/mock_policy_handler_observer.h"
+#include "application_manager/mock_event_dispatcher.h"
+
+namespace test {
+namespace components {
+namespace policy_handler_test {
+
+using namespace application_manager;
+using namespace policy;
+using namespace utils::custom_string;
+using testing::_;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::NiceMock;
+
+class PolicyHandlerTest : public ::testing::Test {
+ public:
+  PolicyHandlerTest()
+      : policy_handler_(policy_settings_, app_manager_),
+        app_id_("fake_app_id"),
+        mac_addr("mac_address"),
+        device_id_("fake_device_id"),
+        hmi_level_("default"),
+        rpc_("fake_rpc"),
+        priority_("fake_priority"),        
+        default_hmi_("fake_hmi")
+        ,kPreloadPTFile("sdl_preloaded_pt.json")
+        ,kAppStorageFolder("storage") {}
+
+ protected:
+  NiceMock<MockPolicySettings> policy_settings_;
+  NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_;
+  PolicyHandler policy_handler_;
+  utils::SharedPtr<policy_manager_test::MockPolicyManager> pm_;
+  application_manager_test::MockApplicationManager app_manager_;
+  const std::string app_id_;
+  const std::string mac_addr;
+  const std::string device_id_;
+  const std::string hmi_level_;
+  const std::string rpc_;
+  std::string priority_;
+  std::string default_hmi_;
+  const std::string kPreloadPTFile;
+  const std::string kAppStorageFolder;
+
+
+  virtual void SetUp() OVERRIDE {
+    ON_CALL(policy_settings_, enable_policy()).WillByDefault(Return(true));
+    ON_CALL(app_manager_, event_dispatcher()).WillByDefault(ReturnRef(mock_event_dispatcher_));
+    std::string path = file_system::CreateDirectory("storage");
+    file_system::CreateFile(path + "/" + "certificate");
+    pm_ = utils::MakeShared<policy_manager_test::MockPolicyManager>();
+    ASSERT_TRUE(pm_.valid());
+  }
+
+  virtual void TearDown() OVERRIDE {
+    ON_CALL(mock_event_dispatcher_, remove_observer(_,_));
+  }
+
+  void ChangePolicyManagerToMock() { policy_handler_.SetPolicyManager(pm_); }
+
+  void EnablePolicy() {
+    ON_CALL(policy_settings_, enable_policy()).WillByDefault(Return(true));
+    ON_CALL(policy_settings_, preloaded_pt_file()).WillByDefault(ReturnRef(kPreloadPTFile));
+    ON_CALL(policy_settings_, app_storage_folder()).WillByDefault(ReturnRef(kAppStorageFolder));
+  }
+
+  void EnablePolicyAndPolicyManagerMock() {
+    EnablePolicy();
+    ChangePolicyManagerToMock();
+  }
+};
+
+TEST_F(PolicyHandlerTest, Test_LoadPolicyLibrary_Method_ExpectLibraryLoaded) {
+  // Check before policy enabled from ini file
+  EXPECT_CALL(policy_settings_, enable_policy()).WillRepeatedly(Return(false));
+  EXPECT_FALSE(policy_handler_.LoadPolicyLibrary());
+  EXPECT_CALL(policy_settings_, enable_policy()).WillRepeatedly(Return(true));
+  // Check
+  EXPECT_TRUE(policy_handler_.LoadPolicyLibrary());
+
+  EXPECT_TRUE(policy_handler_.UnloadPolicyLibrary());
+}
+
+TEST_F(PolicyHandlerTest,
+       InitPolicyTable_WithoutPreloadedFile_ExpectPolicyTableNotInitialized) {
+  // Check
+  EXPECT_FALSE(policy_handler_.InitPolicyTable());
+}
+
+TEST_F(PolicyHandlerTest,
+       InitPolicyTable_WithPreloadedFile_ExpectPolicyTableInitialized) {
+  // Arrange
+  EnablePolicy();
+  EXPECT_TRUE(policy_handler_.LoadPolicyLibrary());
+  // Check
+  EXPECT_TRUE(policy_handler_.InitPolicyTable());
+  EXPECT_TRUE(policy_handler_.UnloadPolicyLibrary());
+}
+
+TEST_F(PolicyHandlerTest,
+       ResetPolicyTable_WithoutPreloadedFile_ExpectPolicyTableNotReset) {
+  // Check
+  EXPECT_FALSE(policy_handler_.ResetPolicyTable());
+}
+
+TEST_F(PolicyHandlerTest, ResetPolicyTable_PTNotInitialised_PTNotReset) {
+  // Arrange
+  EnablePolicy();
+  EXPECT_TRUE(policy_handler_.LoadPolicyLibrary());
+  // Check
+  EXPECT_FALSE(policy_handler_.ResetPolicyTable());
+}
+
+TEST_F(PolicyHandlerTest,
+       ResetPolicyTable_WithPreloadedFile_ExpectPolicyTableReset) {
+  // Arrange
+  EnablePolicy();
+  EXPECT_TRUE(policy_handler_.LoadPolicyLibrary());
+  EXPECT_TRUE(policy_handler_.InitPolicyTable());
+  // Check
+  EXPECT_TRUE(policy_handler_.ResetPolicyTable());
+}
+
+TEST_F(PolicyHandlerTest, ResetPolicyTable_ExpectCallPMResetPT) {
+  ChangePolicyManagerToMock();
+  EnablePolicy();
+  EXPECT_CALL(*pm_, ResetPT(_));
+  policy_handler_.ResetPolicyTable();
+}
+
+
+
+TEST_F(PolicyHandlerTest, Test_ClearUserConsent_method) {
+  EnablePolicyAndPolicyManagerMock();
+  EXPECT_CALL(*pm_, ResetUserConsent());
+  policy_handler_.ClearUserConsent();
+}
+
+TEST_F(PolicyHandlerTest, Test_ReceiveMessageFromSDK_method) {
+  // Arrange
+  EnablePolicy();
+  EXPECT_TRUE(policy_handler_.LoadPolicyLibrary());
+  // Check
+  EXPECT_TRUE(policy_handler_.InitPolicyTable());
+  ChangePolicyManagerToMock();
+  std::string file_name("sdl_pt_update.json");
+  std::ifstream ifile(file_name);
+  Json::Reader reader;
+  std::string json;
+  Json::Value root(Json::objectValue);
+  if (ifile.is_open() && reader.parse(ifile, root, true)) {
+    json = root.toStyledString();
+  }
+  ifile.close();
+  BinaryMessage msg(json.begin(), json.end());
+  // Checks
+  EXPECT_CALL(app_manager_, GetNextHMICorrelationID());
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              CreateGetVehicleDataRequest(_, _, _));
+  EXPECT_CALL(*pm_, PTUpdatedAt(_, _));
+  EXPECT_CALL(*pm_, LoadPT("", msg)).WillOnce(Return(true));
+  EXPECT_CALL(*pm_, CleanupUnpairedDevices());
+  policy_handler_.ReceiveMessageFromSDK("", msg);
+}
+
+TEST_F(PolicyHandlerTest,
+       Test_UnloadPolicyLibrary_method_ExpectLibraryUnloaded) {
+  // Arrange
+  EnablePolicy();
+  EXPECT_TRUE(policy_handler_.LoadPolicyLibrary());
+  EXPECT_TRUE(policy_handler_.InitPolicyTable());
+  ChangePolicyManagerToMock();
+  // Act
+  EXPECT_TRUE(policy_handler_.UnloadPolicyLibrary());
+  // Check
+  EXPECT_FALSE(policy_handler_.InitPolicyTable());
+}
+
+TEST_F(PolicyHandlerTest, Test_OnPermissionsUpdated_method_With2Parameters) {
+  // Check expectations
+  EXPECT_CALL(app_manager_, application_by_policy_id(_))
+      .WillOnce(Return(ApplicationSharedPtr()));
+  // Act
+  Permissions perms;
+  policy_handler_.OnPermissionsUpdated(app_id_, perms);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnPermissionsUpdated_method_With3Parameters) {
+  // Check expectations
+  EXPECT_CALL(app_manager_, application_by_policy_id(_))
+      .Times(2)
+      .WillRepeatedly(Return(ApplicationSharedPtr()));
+  // Act
+  Permissions perms;
+  policy_handler_.OnPermissionsUpdated(app_id_, perms, hmi_level_);
+}
+
+TEST_F(PolicyHandlerTest, Test_GetPriority_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, GetPriority(app_id_, &priority_));
+  // Act
+  policy_handler_.GetPriority(app_id_, &priority_);
+}
+
+TEST_F(PolicyHandlerTest, Test_CheckPermissions_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  CheckPermissionResult result;
+  RPCParams rpc_params;
+  // Check expectations
+  EXPECT_CALL(*pm_, CheckPermissions(app_id_, hmi_level_, rpc_, rpc_params, _));
+  // Act
+  policy_handler_.CheckPermissions(app_id_, hmi_level_, rpc_, rpc_params, result);
+}
+
+TEST_F(PolicyHandlerTest, Test_GetNotificationsNumber_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, GetNotificationsNumber(priority_));
+  // Act
+  policy_handler_.GetNotificationsNumber(priority_);
+}
+
+TEST_F(PolicyHandlerTest, Test_GetUserConsentForDevice_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, GetUserConsentForDevice(device_id_))
+      .WillOnce(Return(DeviceConsent::kDeviceHasNoConsent));
+  // Act
+  policy_handler_.GetUserConsentForDevice(device_id_);
+}
+
+TEST_F(PolicyHandlerTest, Test_GetDefaultHmi_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, GetDefaultHmi(app_id_, &default_hmi_));
+  // Act
+  policy_handler_.GetDefaultHmi(app_id_, &default_hmi_);
+}
+
+TEST_F(PolicyHandlerTest, Test_GetInitialAppData_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  StringArray* nicknames = NULL;
+  StringArray* app_hmi_types = NULL;
+  // Check expectations
+  EXPECT_CALL(*pm_, GetInitialAppData(app_id_, nicknames, app_hmi_types));
+  // Act
+  policy_handler_.GetInitialAppData(app_id_, nicknames, app_hmi_types);
+}
+
+TEST_F(PolicyHandlerTest, Test_GetUpdateUrls_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  EndpointUrls endpoints;
+  const int service_type_ = 1;
+  // Check expectations
+  EXPECT_CALL(*pm_, GetUpdateUrls(service_type_, _));
+  // Act
+  policy_handler_.GetUpdateUrls(service_type_, endpoints);
+}
+
+TEST_F(PolicyHandlerTest, Test_ResetRetrySequence_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, ResetRetrySequence());
+  // Act
+  policy_handler_.ResetRetrySequence();
+}
+
+TEST_F(PolicyHandlerTest, Test_NextRetryTimeout_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, NextRetryTimeout());
+  // Act
+  policy_handler_.NextRetryTimeout();
+}
+
+TEST_F(PolicyHandlerTest, Test_TimeoutExchange_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, TimeoutExchange());
+  // Act
+  policy_handler_.TimeoutExchange();
+}
+
+TEST_F(PolicyHandlerTest, Test_OnExceededTimeout_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, OnExceededTimeout());
+  // Act
+  policy_handler_.OnExceededTimeout();
+}
+
+TEST_F(PolicyHandlerTest, Test_OnSystemReady_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, OnSystemReady());
+  // Act
+  policy_handler_.OnSystemReady();
+}
+
+TEST_F(PolicyHandlerTest, Test_PTUpdatedAt_method_UseCounter_KILOMETERS) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  const int value = 1000;
+  // Check expectations
+  EXPECT_CALL(*pm_, PTUpdatedAt(Counters::KILOMETERS, value));
+  // Act
+  policy_handler_.PTUpdatedAt(Counters::KILOMETERS, value);
+}
+
+TEST_F(PolicyHandlerTest, Test_PTUpdatedAt_method_UseCounter_DAYS_AFTER_EPOCH) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  const int value = 16000;
+  // Check expectations
+  EXPECT_CALL(*pm_, PTUpdatedAt(Counters::DAYS_AFTER_EPOCH, value));
+  // Act
+  policy_handler_.PTUpdatedAt(Counters::DAYS_AFTER_EPOCH, value);
+}
+
+TEST_F(PolicyHandlerTest, Test_CheckSystemAction_method_WithType_KEEP_CONTEXT) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  mobile_apis::SystemAction::eType system_action =
+      mobile_apis::SystemAction::eType::KEEP_CONTEXT;
+  // Check expectations
+  EXPECT_CALL(*pm_, CanAppKeepContext(app_id_));
+  // Act
+  policy_handler_.CheckSystemAction(system_action, app_id_);
+}
+
+TEST_F(PolicyHandlerTest, Test_CheckSystemAction_method_WithType_STEAL_FOCUS) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  mobile_apis::SystemAction::eType system_action =
+      mobile_apis::SystemAction::eType::STEAL_FOCUS;
+  // Check expectations
+  EXPECT_CALL(*pm_, CanAppStealFocus(app_id_));
+  // Act
+  policy_handler_.CheckSystemAction(system_action, app_id_);
+}
+
+TEST_F(PolicyHandlerTest,
+       Test_CheckSystemAction_method_WithType_DEFAULT_ACTION) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  mobile_apis::SystemAction::eType system_action =
+      mobile_apis::SystemAction::eType::DEFAULT_ACTION;
+  // Check expectations
+  EXPECT_CALL(*pm_, CanAppStealFocus(app_id_)).Times(0);
+  EXPECT_CALL(*pm_, CanAppKeepContext(app_id_)).Times(0);
+  // Act
+  EXPECT_TRUE(policy_handler_.CheckSystemAction(system_action, app_id_));
+}
+
+TEST_F(PolicyHandlerTest, Test_CheckSystemAction_method_WithType_INVALID_ENUM) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  mobile_apis::SystemAction::eType system_action =
+      mobile_apis::SystemAction::eType::INVALID_ENUM;
+  // Check expectations
+  EXPECT_CALL(*pm_, CanAppStealFocus(app_id_)).Times(0);
+  EXPECT_CALL(*pm_, CanAppKeepContext(app_id_)).Times(0);
+  // Act
+  EXPECT_FALSE(policy_handler_.CheckSystemAction(system_action, app_id_));
+}
+
+TEST_F(PolicyHandlerTest, Test_KmsChanged_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  const int kilometers = 1600;
+  // Check expectations
+  EXPECT_CALL(*pm_, KmsChanged(kilometers));
+  // Act
+  policy_handler_.KmsChanged(kilometers);
+}
+// policy_handler l:1026
+TEST_F(PolicyHandlerTest, Test_OnActivateApp_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  std::string policy_app_id("mobile_app_id");
+  const uint32_t connection_key = 1;
+  const uint32_t correlation_id = 2;
+
+  utils::SharedPtr<application_manager_test::MockApplication> application1 =
+          utils::MakeShared<application_manager_test::MockApplication>();
+
+  connection_handler_test::MockConnectionHandlerSettings mock_connection_handler_settings;
+  transport_manager_test::MockTransportManager mock_transport_manager;
+  connection_handler::ConnectionHandlerImpl* conn_handler =
+       new connection_handler::ConnectionHandlerImpl(mock_connection_handler_settings,mock_transport_manager);
+  EXPECT_CALL(app_manager_,connection_handler()).WillOnce(ReturnRef(*conn_handler));
+  EXPECT_CALL(app_manager_, application(connection_key))
+      .Times(1)
+      .WillRepeatedly(Return(application1));
+
+  AppPermissions permissions(policy_app_id);
+  // Check expectations
+  UsageStatistics usage_stats(
+      "0",
+      utils::SharedPtr<usage_statistics::StatisticsManager>(
+          utils::MakeShared<usage_statistics_test::MockStatisticsManager>()));
+  EXPECT_CALL(*application1, policy_app_id()).WillOnce(Return(policy_app_id));
+  EXPECT_CALL(*application1, usage_report()).WillOnce(ReturnRef(usage_stats));
+  EXPECT_CALL(*pm_, GetAppPermissionsChanges(_)).WillOnce(Return(permissions));
+  EXPECT_CALL(*pm_, GetUserConsentForDevice(_))
+      .WillOnce(Return(DeviceConsent::kDeviceHasNoConsent));
+  ON_CALL(*pm_, Increment(_, _)).WillByDefault(Return());
+  EXPECT_CALL(*pm_, RemovePendingPermissionChanges(_));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendSDLActivateAppResponse(_, _, _));
+  // Act
+  policy_handler_.OnActivateApp(connection_key, correlation_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnIgnitionCycleOver_method) {
+  // Arrange
+  ChangePolicyManagerToMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, IncrementIgnitionCycles());
+  // Act
+  policy_handler_.OnIgnitionCycleOver();
+}
+
+TEST_F(PolicyHandlerTest, Test_OnPendingPermissionChange_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  uint32_t app_id = 123;
+  std::string policy_app_id("mobile_app_id");
+
+  utils::SharedPtr<application_manager_test::MockApplication> application =
+          utils::MakeShared<application_manager_test::MockApplication>();
+
+  EXPECT_CALL(app_manager_, application_by_policy_id(policy_app_id))
+      .WillOnce(Return(application));
+  EXPECT_CALL(*application, app_id()).WillOnce(Return(app_id));
+
+  EXPECT_CALL(*application, hmi_level()).WillOnce(Return(mobile_apis::HMILevel::HMI_FULL));
+  AppPermissions permissions(policy_app_id);
+  EXPECT_CALL(*pm_, GetAppPermissionsChanges(_)).WillOnce(Return(permissions));
+  EXPECT_CALL(*pm_, RemovePendingPermissionChanges(policy_app_id)).Times(0);
+  // Act
+  policy_handler_.OnPendingPermissionChange(policy_app_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_PTExchangeAtUserRequest_method) {
+  // Arrange
+  ChangePolicyManagerToMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, ForcePTExchange());
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendUpdateSDLResponse(_, _, _));
+  // Act
+  const uint32_t correlation_id = 2;
+  policy_handler_.PTExchangeAtUserRequest(correlation_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_AddDevice_method) {
+  // Arrange
+  ChangePolicyManagerToMock();
+  // Check expectations
+  const std::string connection_type("BT");
+  EXPECT_CALL(*pm_, AddDevice(device_id_, connection_type));
+  // Act
+  policy_handler_.AddDevice(device_id_, connection_type);
+}
+
+TEST_F(PolicyHandlerTest, Test_SetDeviceInfo_method) {
+  // Arrange
+  ChangePolicyManagerToMock();
+  // Check expectations
+  std::string device_id_;
+  const DeviceInfo device_info;
+  EXPECT_CALL(*pm_, SetDeviceInfo(device_id_, _));
+  // Act
+  policy_handler_.SetDeviceInfo(device_id_, device_info);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnGetUserFriendlyMessage_method) {
+  // Arrange
+  ChangePolicyManagerToMock();
+  // Check expectations
+  std::vector<std::string> message_codes;
+  const std::string language("ru-ru");
+  const uint32_t correlation_id = 2;
+  EXPECT_CALL(*pm_, GetUserFriendlyMessages(message_codes, language))
+      .WillOnce(Return(std::vector<UserFriendlyMessage>()));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendGetUserFriendlyMessageResponse(_, _, _));
+  // Act
+  policy_handler_.OnGetUserFriendlyMessage(message_codes, language, correlation_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnGetStatusUpdate_method) {
+  // Arrange
+  ChangePolicyManagerToMock();
+  const uint32_t correlation_id = 2;
+  // Check expectations
+  EXPECT_CALL(*pm_, GetPolicyTableStatus());
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendGetStatusUpdateResponse(_, correlation_id, _));
+  // Act
+  policy_handler_.OnGetStatusUpdate(correlation_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnUpdateStatusChanged_method) {
+  // Check expectations
+  const std::string& status("new status");
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendOnStatusUpdate(status, _));
+  // Act
+  policy_handler_.OnUpdateStatusChanged(status);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnCurrentDeviceIdUpdateRequired_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  std::string policy_app_id("mobile_app_id");
+  connection_handler_test::MockConnectionHandler conn_handler;
+  utils::SharedPtr<application_manager_test::MockApplication> application =
+          utils::MakeShared<application_manager_test::MockApplication>();
+  EXPECT_CALL(app_manager_, application_by_policy_id(policy_app_id))
+      .WillOnce(Return(application));
+  EXPECT_CALL(app_manager_,connection_handler()).WillOnce(ReturnRef(conn_handler));
+  protocol_handler_test::MockSessionObserver session_observer;
+
+  EXPECT_CALL(conn_handler,get_session_observer()).WillOnce(ReturnRef(session_observer));
+
+  EXPECT_CALL(session_observer,GetDataOnDeviceID(0u,_,_,_,_));
+
+
+  // Act
+  policy_handler_.OnCurrentDeviceIdUpdateRequired(policy_app_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnSystemInfoChanged_method) {
+  // Arrange
+  ChangePolicyManagerToMock();
+  // Check expectations
+  const std::string language("ru-ru");
+  EXPECT_CALL(*pm_, SetSystemLanguage(language));
+  // Act
+  policy_handler_.OnSystemInfoChanged(language);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnGetSystemInfo_method) {
+  // Arrange
+  ChangePolicyManagerToMock();
+  // Check expectations
+  const std::string ccpu_version("4.1.3.B_EB355B");
+  const std::string wers_country_code("WAEGB");
+  const std::string language("ru-ru");
+  EXPECT_CALL(*pm_, SetSystemInfo(ccpu_version, wers_country_code, language));
+  // Act
+  policy_handler_.OnGetSystemInfo(ccpu_version, wers_country_code, language);
+}
+
+TEST_F(PolicyHandlerTest, Test_IsApplicationRevoked_method) {
+  // Arrange
+  EnablePolicy();
+  std::string policy_app_id("mobile_app_id");
+  ChangePolicyManagerToMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, IsApplicationRevoked(policy_app_id));
+  // Act
+  policy_handler_.IsApplicationRevoked(policy_app_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnSystemInfoUpdateRequired_method) {
+  // Arrange
+  ChangePolicyManagerToMock();
+  // Check expectations
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendGetSystemInfoRequest(_));
+  // Act
+  policy_handler_.OnSystemInfoUpdateRequired();
+}
+
+TEST_F(PolicyHandlerTest, Test_GetAppRequestTypes_method) {
+  // Arrange
+  EnablePolicy();
+  ChangePolicyManagerToMock();
+  // Check expectations
+  std::string policy_app_id("mobile_app_id");
+  EXPECT_CALL(*pm_, GetAppRequestTypes(policy_app_id))
+      .WillOnce(Return(std::vector<std::string>()));
+  // Act
+  policy_handler_.GetAppRequestTypes(policy_app_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnVIIsReady_method) {
+  // Arrange
+  ChangePolicyManagerToMock();
+  // Check expectations
+  EXPECT_CALL(app_manager_, GetNextHMICorrelationID());
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              CreateGetVehicleDataRequest(_, _, _));
+  // Act
+  policy_handler_.OnVIIsReady();
+}
+
+TEST_F(PolicyHandlerTest, Test_OnVehicleDataUpdated_method) {
+  // Arrange
+  ChangePolicyManagerToMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, SetVINValue(_));
+  // Act
+  ::smart_objects::SmartObject message_(::smart_objects::SmartType_Map);
+  message_[strings::msg_params][strings::vin] = "XXXXX";
+  policy_handler_.OnVehicleDataUpdated(message_);
+}
+
+TEST_F(PolicyHandlerTest, Test_RemoveDevice_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  connection_handler_test::MockConnectionHandlerSettings mock_connection_handler_settings;
+  transport_manager_test::MockTransportManager mock_transport_manager;
+  connection_handler::ConnectionHandlerImpl* conn_handler =
+       new connection_handler::ConnectionHandlerImpl(mock_connection_handler_settings,mock_transport_manager);;
+  EXPECT_CALL(app_manager_, connection_handler())
+      .WillOnce(ReturnRef(*conn_handler));
+  EXPECT_CALL(*pm_, MarkUnpairedDevice(device_id_));
+  // Act
+  policy_handler_.RemoveDevice(device_id_);
+}
+
+TEST_F(PolicyHandlerTest, Test_GetAppName_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  std::string policy_app_id("mobile_app_id");
+  CustomString app_name("my_mobile_app");
+
+  utils::SharedPtr<application_manager_test::MockApplication> application =
+          utils::MakeShared<application_manager_test::MockApplication>();
+
+  EXPECT_CALL(*application, name()).WillOnce(ReturnRef(app_name));
+  EXPECT_CALL(app_manager_, application_by_policy_id(policy_app_id))
+      .WillOnce(Return(application));
+  // Act
+  EXPECT_EQ(app_name, policy_handler_.GetAppName(policy_app_id));
+}
+
+TEST_F(PolicyHandlerTest, Test_OnUpdateRequestSentToMobile_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, OnUpdateStarted());
+  // Act
+  policy_handler_.OnUpdateRequestSentToMobile();
+}
+
+TEST_F(PolicyHandlerTest, Test_OnUpdateHMIAppType_method) {
+  // Arrange
+  EnablePolicy();
+  application_manager_test::MockPolicyHandlerObserver policy_handler_observer;
+  policy_handler_.add_listener(&policy_handler_observer);
+  std::map<std::string, StringArray> app_hmi_types;
+  StringArray arr;
+  arr.push_back("test_hmi_type");
+  app_hmi_types["app1"] = arr;
+  // Check expectations
+  EXPECT_CALL(policy_handler_observer, OnUpdateHMIAppType(_));
+  // Act
+  policy_handler_.OnUpdateHMIAppType(app_hmi_types);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnCertificateDecrypted_NotDectypted) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+
+  security_manager_test::MockCryptoManager crypto_manager;
+  // security_manager::CryptoManagerImpl crypto_manager;
+  policy_handler_.add_listener(&crypto_manager);
+  // Check expectations
+  EXPECT_CALL(crypto_manager, OnCertificateUpdated(_)).Times(0);
+  // Check expectations
+  EXPECT_CALL(*pm_, SetDecryptedCertificate(_)).Times(0);
+  // Act
+  policy_handler_.OnCertificateDecrypted(false);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnCertificateDecrypted_Decrypted) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+
+  security_manager_test::MockCryptoManager crypto_manager;
+  // security_manager::CryptoManagerImpl crypto_manager;
+  policy_handler_.add_listener(&crypto_manager);
+  // Check expectations
+  EXPECT_CALL(crypto_manager, OnCertificateUpdated(_));
+  // Check expectations
+  EXPECT_CALL(*pm_, SetDecryptedCertificate(_));
+  // Act
+  policy_handler_.OnCertificateDecrypted(true);
+}
+
+TEST_F(PolicyHandlerTest, Test_SendOnAppPermissionsChanged_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  std::string policy_app_id("mobile_app_id");
+
+  utils::SharedPtr<application_manager_test::MockApplication> application =
+          utils::MakeShared<application_manager_test::MockApplication>();
+  // Check expectations
+  EXPECT_CALL(app_manager_, application_by_policy_id(policy_app_id))
+      .WillOnce(Return(application));
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
+              SendOnAppPermissionsChangedNotification(_, _, _));
+  AppPermissions permissions(policy_app_id);
+  // Act
+  policy_handler_.SendOnAppPermissionsChanged(permissions, policy_app_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnPTExchangeNeeded_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, ForcePTExchange());
+  EXPECT_CALL(*MockMessageHelper::message_helper_mock(), SendOnStatusUpdate(_, _));
+  // Act
+  policy_handler_.OnPTExchangeNeeded();
+}
+
+TEST_F(PolicyHandlerTest, Test_AddApplication_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  std::string policy_app_id("mobile_app_id");
+  // Check expectations
+  EXPECT_CALL(*pm_, AddApplication(policy_app_id));
+  // Act
+  policy_handler_.AddApplication(policy_app_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_HeartBeatTimeout_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  std::string policy_app_id("mobile_app_id");
+  EXPECT_CALL(*pm_, HeartBeatTimeout(policy_app_id));
+  // Act
+  policy_handler_.HeartBeatTimeout(policy_app_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_OnAppsSearchStarted_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, OnAppsSearchStarted());
+  // Act
+  policy_handler_.OnAppsSearchStarted();
+}
+
+TEST_F(PolicyHandlerTest, Test_OnAppsSearchCompleted_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, OnAppsSearchCompleted());
+  // Act
+  policy_handler_.OnAppsSearchCompleted();
+}
+
+TEST_F(PolicyHandlerTest, Test_OnAppRegisteredOnMobile_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  std::string policy_app_id("mobile_app_id");
+  EXPECT_CALL(*pm_, OnAppRegisteredOnMobile(policy_app_id));
+  // Act
+  policy_handler_.OnAppRegisteredOnMobile(policy_app_id);
+}
+
+TEST_F(PolicyHandlerTest, Test_IsRequestTypeAllowed_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  std::string policy_app_id("mobile_app_id");
+  mobile_apis::RequestType::eType type =
+      mobile_apis::RequestType::eType::EMERGENCY;
+  EXPECT_CALL(*pm_, GetAppRequestTypes(policy_app_id))
+      .WillOnce(Return(std::vector<std::string>()));
+  // Act
+  policy_handler_.IsRequestTypeAllowed(policy_app_id, type);
+}
+
+TEST_F(PolicyHandlerTest, Test_GetVehicleInfo_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, GetVehicleInfo()).WillOnce(Return(VehicleInfo()));
+  // Act
+  policy_handler_.GetVehicleInfo();
+}
+
+TEST_F(PolicyHandlerTest, Test_GetMetaInfo_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  EXPECT_CALL(*pm_, GetMetaInfo()).WillOnce(Return(MetaInfo()));
+  // Act
+  policy_handler_.GetMetaInfo();
+}
+
+TEST_F(PolicyHandlerTest, Test_Increment_method_WithOneParameter) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  usage_statistics::GlobalCounterId type =
+      usage_statistics::GlobalCounterId::IAP_BUFFER_FULL;
+  EXPECT_CALL(*pm_, Increment(type));
+  // Act
+  policy_handler_.Increment(type);
+}
+
+TEST_F(PolicyHandlerTest, Test_Increment_method_WithTwoParameters) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  std::string policy_app_id("mobile_app_id");
+  usage_statistics::AppCounterId type =
+      usage_statistics::AppCounterId::USER_SELECTIONS;
+  EXPECT_CALL(*pm_, Increment(policy_app_id, type));
+  // Act
+  policy_handler_.Increment(policy_app_id, type);
+}
+
+TEST_F(PolicyHandlerTest, Test_Set_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  std::string policy_app_id("mobile_app_id");
+  const std::string value("ru-ru");
+  usage_statistics::AppInfoId type = usage_statistics::AppInfoId::LANGUAGE_GUI;
+  EXPECT_CALL(*pm_, Set(policy_app_id, type, value));
+  // Act
+  policy_handler_.Set(policy_app_id, type, value);
+}
+
+TEST_F(PolicyHandlerTest, Test_Add_method) {
+  // Arrange
+  EnablePolicyAndPolicyManagerMock();
+  // Check expectations
+  std::string policy_app_id("mobile_app_id");
+  int32_t timespan_seconds = 100;
+  usage_statistics::AppStopwatchId type =
+      usage_statistics::AppStopwatchId::SECONDS_HMI_FULL;
+  EXPECT_CALL(*pm_, Add(policy_app_id, type, timespan_seconds));
+  // Act
+  policy_handler_.Add(policy_app_id, type, timespan_seconds);
+}
+
+}  // namespace policy_handler_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/application_manager/test/request_controller/request_controller_test.cc b/src/components/application_manager/test/request_controller/request_controller_test.cc
new file mode 100644
index 0000000000..e249f6de18
--- /dev/null
+++ b/src/components/application_manager/test/request_controller/request_controller_test.cc
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2015, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "gtest/gtest.h"
+#include "application_manager/request_controller.h"
+#include "application_manager/mock_request.h"
+#include "utils/shared_ptr.h"
+#include "smart_objects/smart_object.h"
+#include "application_manager/commands/command_request_impl.h"
+#include "application_manager/message_helper.h"
+#include "application_manager/application_impl.h"
+#include "utils/make_shared.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/event_engine/event_dispatcher.h"
+#include "resumption/last_state.h"
+#include "application_manager/policies/policy_handler.h"
+#include "application_manager/state_controller.h"
+#include "application_manager/resumption/resume_ctrl.h"
+#include "application_manager/mock_request_controller_settings.h"
+#include "application_manager/mock_application_manager.h"
+
+namespace test {
+namespace components {
+namespace request_controller_test {
+
+using application_manager::request_controller::RequestController;
+using application_manager::request_controller::RequestInfo;
+
+using ::testing::Return;
+using ::testing::ReturnRef;
+
+typedef utils::SharedPtr<application_manager_test::MockRequest> RequestPtr;
+typedef utils::SharedPtr<RequestController> RequestControllerSPtr;
+
+class RequestControllerTestClass : public ::testing::Test {
+ public:
+  RequestControllerTestClass()
+      : request_ctrl_(utils::MakeShared<RequestController>(mock_request_controller_settings_)) {
+    register_request_ = GetMockRequest();
+  }
+
+  RequestController::TResult AddRequest(
+      const RequestInfo::RequestType request_type,
+      const bool RegisterRequest = false,
+      const mobile_apis::HMILevel::eType& hmi_level =
+          mobile_apis::HMILevel::INVALID_ENUM) {
+    RequestPtr request;
+    if (RegisterRequest) {
+      request = register_request_;
+      EXPECT_CALL(*register_request_, default_timeout()).WillOnce(Return(0));
+    } else {
+      request = empty_register_request_;
+    }
+    if (RequestInfo::RequestType::HMIRequest == request_type) {
+      return request_ctrl_->addHMIRequest(request);
+    }
+    return request_ctrl_->addMobileRequest(request, hmi_level);
+  }
+
+  RequestPtr GetMockRequest(const uint32_t id = 1,
+                            const uint32_t connection_key = 0) {
+    return utils::MakeShared<application_manager_test::MockRequest>(
+        connection_key, id);
+  }
+  void CallSettings() {
+    EXPECT_CALL(mock_request_controller_settings_,
+                app_hmi_level_none_time_scale())
+        .WillOnce(ReturnRef(kDefaultAppHmiLevelNoneRequestsTimeScale));
+    EXPECT_CALL(mock_request_controller_settings_,
+                app_hmi_level_none_time_scale_max_requests())
+        .WillOnce(ReturnRef(kDefaultAppHmiLevelNoneTimeScaleMaxRequests));
+
+    EXPECT_CALL(mock_request_controller_settings_, app_time_scale())
+        .WillOnce(ReturnRef(kDefaultAppRequestsTimeScale));
+    EXPECT_CALL(mock_request_controller_settings_,
+                app_time_scale_max_requests())
+        .WillOnce(ReturnRef(kDefaultAppTimeScaleMaxRequests));
+
+    EXPECT_CALL(mock_request_controller_settings_, pending_requests_amount())
+        .WillOnce(ReturnRef(kDefaultPendingRequestsAmount));
+  }
+
+  application_manager_test::MockRequestControlerSettings
+      mock_request_controller_settings_;
+  RequestPtr register_request_;
+  RequestPtr empty_register_request_;
+  RequestControllerSPtr request_ctrl_;
+
+  const uint32_t kDefaultAppHmiLevelNoneRequestsTimeScale = 10;
+  const uint32_t kDefaultAppHmiLevelNoneTimeScaleMaxRequests = 100u;
+  const uint32_t kDefaultAppTimeScaleMaxRequests = 0;
+  const uint32_t kDefaultAppRequestsTimeScale = 0;
+  const uint32_t kDefaultPendingRequestsAmount = 0;
+};
+
+TEST_F(RequestControllerTestClass, CheckPosibilitytoAdd_HMI_FULL_SUCCESS) {
+  CallSettings();
+  EXPECT_EQ(RequestController::TResult::SUCCESS,
+            AddRequest(RequestInfo::RequestType::MobileRequest, true,
+                       mobile_apis::HMILevel::HMI_FULL));
+}
+
+TEST_F(RequestControllerTestClass, CheckPosibilitytoAdd_HMI_NONE_SUCCESS) {
+  CallSettings();
+  EXPECT_EQ(RequestController::TResult::SUCCESS,
+            AddRequest(RequestInfo::RequestType::MobileRequest, true,
+                       mobile_apis::HMILevel::HMI_NONE));
+}
+
+TEST_F(RequestControllerTestClass, IsLowVoltage_SetOnLowVoltage_TRUE) {
+  request_ctrl_->OnLowVoltage();
+  const bool result = true;
+  EXPECT_EQ(result, request_ctrl_->IsLowVoltage());
+}
+
+TEST_F(RequestControllerTestClass, IsLowVoltage_SetOnWakeUp_FALSE) {
+  request_ctrl_->OnWakeUp();
+  const bool result = false;
+  EXPECT_EQ(result, request_ctrl_->IsLowVoltage());
+}
+
+TEST_F(RequestControllerTestClass,
+       AddMobileRequest_SetInvalidData_INVALID_DATA) {
+  EXPECT_EQ(RequestController::INVALID_DATA,
+            AddRequest(RequestInfo::RequestType::MobileRequest,
+                       false,
+                       mobile_apis::HMILevel::HMI_NONE));
+}
+
+TEST_F(RequestControllerTestClass, addHMIRequest_AddRequest_SUCCESS) {
+  EXPECT_EQ(RequestController::SUCCESS,
+            AddRequest(RequestInfo::RequestType::HMIRequest, true));
+}
+
+TEST_F(RequestControllerTestClass, addHMIRequest_AddInvalidData_INVALID_DATA) {
+  EXPECT_EQ(RequestController::INVALID_DATA,
+            AddRequest(RequestInfo::RequestType::HMIRequest));
+}
+
+TEST_F(RequestControllerTestClass, ZeroValuePendingRequestsAmount) {
+  // Bigger than pending_requests_amount count
+  const uint32_t big_count_of_requests_for_test_ = 10;
+  for (uint32_t i = 0; i < big_count_of_requests_for_test_; ++i) {
+    CallSettings();
+    EXPECT_EQ(RequestController::SUCCESS, AddRequest(RequestInfo::RequestType::MobileRequest,
+                                                     true,
+                                                     mobile_apis::HMILevel::HMI_FULL));
+  }
+}
+
+
+}  // namespace request_controller
+}  // namespace components
+}  // namespace test
diff --git a/src/components/application_manager/test/resumption/include/resumption_data_mock.h b/src/components/application_manager/test/resumption/include/resumption_data_mock.h
index 793f306490..af481c3f89 100644
--- a/src/components/application_manager/test/resumption/include/resumption_data_mock.h
+++ b/src/components/application_manager/test/resumption/include/resumption_data_mock.h
@@ -35,6 +35,8 @@
 #include "gmock/gmock.h"
 #include "application_manager/resumption/resumption_data.h"
 #include "application_manager/application.h"
+#include "application_manager/mock_application_manager_settings.h"
+#include "application_manager/mock_application_manager.h"
 
 namespace test {
 namespace components {
@@ -42,8 +44,10 @@ namespace resumption_test {
 namespace app_mngr = application_manager;
 namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
 
-class ResumptionDataMock : public ::resumption::ResumptionData {
+class MockResumptionData : public ::resumption::ResumptionData {
  public:
+  MockResumptionData(const application_manager_test::MockApplicationManager& application_manager):
+      ResumptionData(application_manager) {}
   MOCK_METHOD1(SaveApplication,
                void(app_mngr::ApplicationSharedPtr application));
   MOCK_CONST_METHOD2(GetStoredHMILevel,
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
deleted file mode 100644
index ad6aef55ea..0000000000
--- a/src/components/application_manager/test/resumption/include/resumption_data_test.h
+++ /dev/null
@@ -1,134 +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.
- */
-
-#include <string>
-#include <algorithm>
-#include "gtest/gtest.h"
-#include "application_manager/usage_statistics.h"
-#include "application_mock.h"
-#include "application_manager/application_manager_impl.h"
-#include "utils/data_accessor.h"
-
-namespace test {
-namespace components {
-namespace resumption_test {
-
-using ::testing::NiceMock;
-namespace am = application_manager;
-namespace sm = smart_objects;
-using namespace Json;
-
-using namespace resumption;
-using namespace mobile_apis;
-
-class ResumptionDataTest : public ::testing::Test {
- protected:
-  // Check structure in saved application
-  void CheckSavedApp(sm::SmartObject& saved_data);
-
-  // Set data for resumption
-  virtual void PrepareData();
-  utils::SharedPtr<NiceMock<state_controller_test::MockApplication>> app_mock;
-
-  HMILevel::eType hmi_level_;
-  size_t app_id_;
-  size_t hmi_app_id_;
-  std::string mobile_app_id_;
-  std::string mac_address_;
-  size_t ign_off_count_;
-  const size_t tts_chunks_count = 4;
-
-  size_t grammar_id_;
-  std::string hash_;
-  bool is_audio_;
-  const connection_handler::DeviceHandle device_handle_ = 10;
-
-  sm::SmartObject* help_prompt_;
-  sm::SmartObject* timeout_prompt_;
-  sm::SmartObject* vr_help_;
-  sm::SmartObject* vr_help_title_;
-  sm::SmartObject* vr_synonyms_;
-  sm::SmartObject* keyboard_props_;
-  sm::SmartObject* menu_title_;
-  sm::SmartObject* menu_icon_;
-
-  void SetCommands();
-  void SetSubmenues();
-  void SetChoiceSet();
-  void SetAppFiles();
-  void SetGlobalProporties();
-  void SetKeyboardProperties();
-  void SetMenuTitleAndIcon();
-  void SetHelpAndTimeoutPrompt();
-  void SetVRHelpTitle();
-  void SetSubscriptions();
-
-  void CheckCommands(sm::SmartObject& res_list);
-  void CheckGlobalProporties(sm::SmartObject& res_list);
-  void CheckSubmenues(sm::SmartObject& res_list);
-  void CheckChoiceSet(sm::SmartObject& res_list);
-  void CheckAppFiles(sm::SmartObject& res_list);
-  void CheckKeyboardProperties(sm::SmartObject& res_list);
-  void CheckMenuTitle(sm::SmartObject& res_list);
-  void CheckMenuIcon(sm::SmartObject& res_list);
-  void CheckHelpPrompt(sm::SmartObject& res_list);
-  void CheckTimeoutPrompt(sm::SmartObject& res_list);
-  void CheckVRHelp(NsSmartDeviceLink::NsSmartObjects::SmartObject& res_list);
-  void CheckVRTitle(sm::SmartObject& res_list);
-  void CheckSubscriptions(sm::SmartObject& res_list);
-
-  const size_t count_of_commands = 5;
-  const size_t count_of_choice = 2;
-  const size_t count_of_choice_sets = 4;
-  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";
-
-  am::CommandsMap test_commands_map;
-  am::SubMenuMap test_submenu_map;
-  am::ChoiceSetMap test_choiceset_map;
-  am::AppFilesMap app_files_map_;
-
-  am::ButtonSubscriptions btn_subscr;
-  am::VehicleInfoSubscriptions ivi;
-
-  sync_primitives::Lock sublock_;
-  sync_primitives::Lock comlock_;
-  sync_primitives::Lock setlock_;
-  sync_primitives::Lock btnlock_;
-  sync_primitives::Lock ivilock_;
-};
-
-}  // namespace resumption_test
-}  // namespace components
-}  // namespace test
diff --git a/src/components/application_manager/test/resumption/resume_ctrl_test.cc b/src/components/application_manager/test/resumption/resume_ctrl_test.cc
new file mode 100644
index 0000000000..d3dbd16c69
--- /dev/null
+++ b/src/components/application_manager/test/resumption/resume_ctrl_test.cc
@@ -0,0 +1,780 @@
+/*
+ * Copyright (c) 2016, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "application_manager/resumption/resume_ctrl.h"
+#include <string>
+#include <algorithm>
+#include "gtest/gtest.h"
+#include "application_manager/usage_statistics.h"
+#include "application_manager/mock_application.h"
+#include "include/resumption_data_mock.h"
+#include "interfaces/MOBILE_API.h"
+#include "application_manager/application_manager_impl.h"
+#include "application_manager/application.h"
+#include "utils/data_accessor.h"
+#include "utils/make_shared.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_application_manager_settings.h"
+#include "application_manager/mock_event_dispatcher.h"
+#include "application_manager/mock_state_controller.h"
+#include "resumption/last_state.h"
+
+namespace test {
+namespace components {
+namespace resumption_test {
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::DoAll;
+using ::testing::SetArgReferee;
+using ::testing::Mock;
+using ::testing::NiceMock;
+using ::testing::AtLeast;
+using namespace application_manager_test;
+
+using namespace resumption;
+using namespace mobile_apis::HMILevel;
+
+class ResumeCtrlTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, event_dispatcher()).WillByDefault(ReturnRef(mock_event_dispatcher_));
+    mock_storage =
+        ::utils::MakeShared<NiceMock<resumption_test::MockResumptionData> >(mock_application_manager_settings_);
+    app_mock = utils::MakeShared<NiceMock<MockApplication>>();
+    res_ctrl = utils::MakeShared<ResumeCtrl>(app_mngr_);
+    res_ctrl->set_resumption_storage(mock_storage);
+    test_app_id = 10;
+    default_test_type = eType::HMI_NONE;
+    test_dev_id = 5;
+    test_policy_app_id = "test_policy_app_id";
+    mac_address = "12345";
+    test_grammar_id = 10;
+    hash = "saved_hash";
+    ON_CALL(app_mngr_,get_settings()).
+            WillByDefault(ReturnRef(mock_application_manager_settings_));
+
+    ON_CALL(mock_application_manager_settings_, use_db_for_resumption()).
+            WillByDefault(Return(false));
+    ON_CALL(mock_application_manager_settings_, app_resuming_timeout()).
+            WillByDefault(ReturnRef(kAppResumingTimeout));
+  }
+  void GetInfoFromApp() {
+    ON_CALL(*app_mock, policy_app_id())
+        .WillByDefault(Return(test_policy_app_id));
+    ON_CALL(*app_mock, mac_address()).WillByDefault(ReturnRef(mac_address));
+    ON_CALL(*app_mock, device()).WillByDefault(Return(test_dev_id));
+    ON_CALL(*app_mock, app_id()).WillByDefault(Return(test_app_id));
+
+  }
+
+  NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_;
+  application_manager_test::MockApplicationManagerSettings mock_application_manager_settings_;
+  application_manager_test::MockApplicationManager app_mngr_;
+  utils::SharedPtr<ResumeCtrl> res_ctrl;
+  utils::SharedPtr<NiceMock<resumption_test::MockResumptionData> > mock_storage;
+  utils::SharedPtr<NiceMock<MockApplication>> app_mock;
+  // app_mock.app_id() will return this value
+  uint32_t test_app_id;
+  std::string test_policy_app_id;
+  std::string mac_address;
+  mobile_apis::HMILevel::eType default_test_type;
+  const uint32_t cor_id=10;
+  // app_mock.Device() will return this value
+  uint32_t test_dev_id;
+  uint32_t test_grammar_id;
+  std::string hash;
+  const uint32_t kAppResumingTimeout = 30000000u;
+};
+
+/**
+ * @brief  Group of tests which check starting resumption with different data
+ */
+
+TEST_F(ResumeCtrlTest, StartResumption_AppWithGrammarId) {
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::hash_id] = hash;
+  saved_app[application_manager::strings::grammar_id] = test_grammar_id;
+
+  // Check RestoreApplicationData
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage,
+              GetSavedApplication(test_policy_app_id, mac_address, _))
+      .Times(3)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+  EXPECT_CALL(*app_mock, UpdateHash());
+  EXPECT_CALL(*app_mock, set_grammar_id(test_grammar_id));
+
+  bool res = res_ctrl->StartResumption(app_mock, hash);
+  EXPECT_TRUE(res);
+}
+
+MATCHER_P4(CheckAppFile, is_persistent, is_download, file_name, file_type, "") {
+  application_manager::AppFile app_file = arg;
+  return app_file.is_persistent == is_persistent &&
+         app_file.is_download_complete == is_download &&
+         app_file.file_name == file_name && app_file.file_type == file_type;
+}
+
+TEST_F(ResumeCtrlTest, StartResumption_WithoutGrammarId) {
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::hash_id] = hash;
+
+  GetInfoFromApp();
+  // Check RestoreApplicationData
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .Times(3)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+  EXPECT_CALL(*app_mock, UpdateHash());
+  EXPECT_CALL(*app_mock, set_grammar_id(test_grammar_id)).Times(0);
+
+  bool res = res_ctrl->StartResumption(app_mock, hash);
+  EXPECT_FALSE(res);
+}
+
+TEST_F(ResumeCtrlTest, StartResumption_AppWithFiles) {
+  GetInfoFromApp();
+  smart_objects::SmartObject test_application_files;
+  smart_objects::SmartObject test_file;
+  const uint32_t count_of_files = 8;
+
+  int file_types[count_of_files];
+  std::string file_names[count_of_files];
+  const size_t max_size = 12;
+  char numb[max_size];
+  for (uint32_t i = 0; i < count_of_files; i++) {
+    file_types[i] = i;
+    std::snprintf(numb, max_size, "%d", i);
+    file_names[i] = "test_file" + std::string(numb);
+  }
+
+  // Should not been added
+  test_file[application_manager::strings::persistent_file] = false;
+  test_application_files[0] = test_file;
+
+  for (uint32_t i = 0; i < count_of_files; ++i) {
+    test_file[application_manager::strings::persistent_file] = true;
+    test_file[application_manager::strings::is_download_complete] = true;
+    test_file[application_manager::strings::file_type] = file_types[i];
+    test_file[application_manager::strings::sync_file_name] = file_names[i];
+    test_application_files[i + 1] = test_file;
+  }
+
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::hash_id] = hash;
+  saved_app[application_manager::strings::grammar_id] = test_grammar_id;
+  saved_app[application_manager::strings::application_files] =
+      test_application_files;
+
+  // Check RestoreApplicationData
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .Times(3)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+  EXPECT_CALL(*app_mock, UpdateHash());
+  EXPECT_CALL(*app_mock, set_grammar_id(test_grammar_id));
+  for (uint32_t i = 0; i < count_of_files; ++i) {
+    EXPECT_CALL(*app_mock,
+                AddFile(CheckAppFile(
+                    true,
+                    true,
+                    file_names[i],
+                    static_cast<mobile_apis::FileType::eType>(file_types[i]))));
+  }
+
+  bool res = res_ctrl->StartResumption(app_mock, hash);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, StartResumption_AppWithSubmenues) {
+  GetInfoFromApp();
+  smart_objects::SmartObject test_application_submenues;
+  smart_objects::SmartObject test_submenu;
+
+  const uint32_t count_of_submenues = 20;
+  for (uint32_t i = 0; i < count_of_submenues; ++i) {
+    test_submenu[application_manager::strings::menu_id] = i;
+    test_application_submenues[i] = test_submenu;
+  }
+
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::hash_id] = hash;
+  saved_app[application_manager::strings::grammar_id] = test_grammar_id;
+  saved_app[application_manager::strings::application_submenus] =
+      test_application_submenues;
+
+  // Check RestoreApplicationData
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .Times(3)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+
+  EXPECT_CALL(*app_mock, set_grammar_id(test_grammar_id));
+
+  for (uint32_t i = 0; i < count_of_submenues; ++i) {
+    EXPECT_CALL(*app_mock, AddSubMenu(i, test_application_submenues[i]));
+  }
+  smart_objects::SmartObjectList requests;
+
+  EXPECT_CALL(app_mngr_, GetNextHMICorrelationID()).WillRepeatedly(Return(cor_id));
+  EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
+              CreateAddSubMenuRequestToHMI(_,cor_id)).WillRepeatedly(Return(requests));
+
+  EXPECT_CALL(*app_mock, UpdateHash());
+  bool res = res_ctrl->StartResumption(app_mock, hash);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, StartResumption_AppWithCommands) {
+  GetInfoFromApp();
+  smart_objects::SmartObject test_application_commands;
+  smart_objects::SmartObject test_commands;
+  const uint32_t count_of_commands = 20;
+
+  for (uint32_t i = 0; i < count_of_commands; ++i) {
+    test_commands[application_manager::strings::cmd_id] = i;
+    test_application_commands[i] = test_commands;
+  }
+
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::hash_id] = hash;
+  saved_app[application_manager::strings::grammar_id] = test_grammar_id;
+  saved_app[application_manager::strings::application_commands] =
+      test_application_commands;
+
+  // Check RestoreApplicationData
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .Times(3)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+  EXPECT_CALL(*app_mock, UpdateHash());
+  EXPECT_CALL(*app_mock, set_grammar_id(test_grammar_id));
+
+  for (uint32_t i = 0; i < count_of_commands; ++i) {
+    EXPECT_CALL(*app_mock, AddCommand(i, test_application_commands[i]));
+  }
+
+  smart_objects::SmartObjectList requests;
+  EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
+              CreateAddCommandRequestToHMI(_,_)).WillRepeatedly(Return(requests));
+
+  bool res = res_ctrl->StartResumption(app_mock, hash);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, StartResumption_AppWithChoiceSet) {
+  smart_objects::SmartObject application_choice_sets;
+  smart_objects::SmartObject app_choice_set;
+
+  const uint32_t count_of_choice = 10;
+  smart_objects::SmartObject choice_vector;
+  smart_objects::SmartObject choice;
+  const size_t max_size = 12;
+  char numb[max_size];
+  for (uint32_t i = 0; i < count_of_choice; ++i) {
+    std::snprintf(numb, max_size, "%d", i);
+    choice[application_manager::strings::vr_commands] =
+        "VrCommand" + std::string(numb);
+    choice[application_manager::strings::choice_id] = i;
+    choice_vector[i] = choice;
+  }
+  const uint32_t count_of_choice_sets = 5;
+  for (uint32_t i = 0; i < count_of_choice_sets; ++i) {
+    app_choice_set[application_manager::strings::interaction_choice_set_id] = i;
+    app_choice_set[application_manager::strings::choice_set] = choice_vector;
+    application_choice_sets[i] = app_choice_set;
+  }
+
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::hash_id] = hash;
+  saved_app[application_manager::strings::grammar_id] = test_grammar_id;
+  saved_app[application_manager::strings::application_choice_sets] =
+      application_choice_sets;
+
+  // Check RestoreApplicationData
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .Times(3)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+  EXPECT_CALL(*app_mock, UpdateHash());
+  EXPECT_CALL(*app_mock, set_grammar_id(test_grammar_id));
+
+  for (uint32_t i = 0; i < count_of_choice_sets; ++i) {
+    EXPECT_CALL(*app_mock, AddChoiceSet(i, application_choice_sets[i]));
+  }
+
+  smart_objects::SmartObjectList requests;
+  EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
+              CreateAddVRCommandRequestFromChoiceToHMI(_))
+      .WillRepeatedly(Return(requests));
+
+  bool res = res_ctrl->StartResumption(app_mock, hash);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, StartResumption_AppWithGlobalProperties) {
+  // Prepare Data
+  smart_objects::SmartObject test_global_properties;
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::hash_id] = hash;
+  saved_app[application_manager::strings::grammar_id] = test_grammar_id;
+  saved_app[application_manager::strings::application_global_properties] =
+      test_global_properties;
+
+  // Check RestoreApplicationData
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .Times(3)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+
+  EXPECT_CALL(*app_mock, set_grammar_id(test_grammar_id));
+
+  EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
+              SendGlobalPropertiesToHMI(_));
+
+  EXPECT_CALL(*app_mock, load_global_properties(test_global_properties));
+
+  EXPECT_CALL(*app_mock, UpdateHash());
+  bool res = res_ctrl->StartResumption(app_mock, hash);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscribeOnButtons) {
+  // Prepare Data
+  smart_objects::SmartObject test_subscriptions;
+  smart_objects::SmartObject app_buttons;
+
+  uint32_t count_of_buttons = 17;
+  for (uint32_t i = 0; i < count_of_buttons; ++i) {
+    app_buttons[i] = i;
+  }
+
+  test_subscriptions[application_manager::strings::application_buttons] =
+      app_buttons;
+
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::hash_id] = hash;
+  saved_app[application_manager::strings::grammar_id] = test_grammar_id;
+  saved_app[application_manager::strings::application_subscribtions] =
+      test_subscriptions;
+
+  // Check RestoreApplicationData
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .Times(3)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+
+  EXPECT_CALL(*app_mock, set_grammar_id(test_grammar_id));
+
+  for (uint32_t i = 0; i < count_of_buttons; ++i) {
+    EXPECT_CALL(
+        *app_mock,
+        SubscribeToButton(static_cast<mobile_apis::ButtonName::eType>(i)));
+  }
+  EXPECT_CALL(*app_mock, UpdateHash());
+
+  EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
+              SendAllOnButtonSubscriptionNotificationsForApp(_,_)).Times(2);
+
+  bool res = res_ctrl->StartResumption(app_mock, hash);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscriptionToIVI) {
+  // Prepare Data
+  smart_objects::SmartObject test_subscriptions;
+  smart_objects::SmartObject app_vi;
+
+  int vtype = application_manager::VehicleDataType::GPS;
+  uint i = 0;
+  for (; vtype < application_manager::VehicleDataType::STEERINGWHEEL;
+       ++i, ++vtype) {
+    app_vi[i] = vtype;
+  }
+
+  test_subscriptions[application_manager::strings::application_vehicle_info] =
+      app_vi;
+
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::hash_id] = hash;
+  saved_app[application_manager::strings::grammar_id] = test_grammar_id;
+  saved_app[application_manager::strings::application_subscribtions] =
+      test_subscriptions;
+
+  // Check RestoreApplicationData
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .Times(3)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+
+  EXPECT_CALL(*app_mock, set_grammar_id(test_grammar_id));
+
+  for (size_t i = 0; i < app_vi.length(); ++i) {
+    EXPECT_CALL(
+        *app_mock,
+        SubscribeToIVI(static_cast<application_manager::VehicleDataType>(i)));
+  }
+
+  smart_objects::SmartObjectList requests;
+  EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
+              GetIVISubscriptionRequests(_)).WillRepeatedly(Return(requests));
+
+  EXPECT_CALL(*app_mock, UpdateHash());
+  bool res = res_ctrl->StartResumption(app_mock, hash);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, StartResumptionOnlyHMILevel) {
+  smart_objects::SmartObject saved_app;
+
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(test_policy_app_id, _, _))
+      .WillOnce(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+  bool res = res_ctrl->StartResumptionOnlyHMILevel(app_mock);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, StartAppHmiStateResumption_AppInFull) {
+  mobile_apis::HMILevel::eType restored_test_type = eType::HMI_FULL;
+  uint32_t ign_off_count = 0;
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::ign_off_count] = ign_off_count;
+  saved_app[application_manager::strings::hmi_level] = restored_test_type;
+
+  MockStateController state_controller_;
+  EXPECT_CALL(app_mngr_, state_controller()).WillOnce(ReturnRef(state_controller_));
+  EXPECT_CALL(state_controller_, SetRegularState(_, restored_test_type))
+      .Times(AtLeast(1));
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(test_policy_app_id, _, _))
+      .Times(2)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+
+  EXPECT_CALL(*mock_storage, RemoveApplicationFromSaved(_, _))
+      .WillOnce(Return(true));
+
+  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345"))
+      .WillRepeatedly(Return(policy::kDeviceAllowed));
+  res_ctrl->StartAppHmiStateResumption(app_mock);
+}
+
+TEST_F(ResumeCtrlTest, StartAppHmiStateResumption_AppInBackground) {
+  uint32_t ign_off_count = 0;
+  smart_objects::SmartObject saved_app;
+
+  mobile_apis::HMILevel::eType restored_test_type = eType::HMI_BACKGROUND;
+  saved_app[application_manager::strings::ign_off_count] = ign_off_count;
+  saved_app[application_manager::strings::hmi_level] = restored_test_type;
+
+  EXPECT_CALL(app_mngr_, state_controller()).Times(0);
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(test_policy_app_id, _, _))
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+
+  res_ctrl->StartAppHmiStateResumption(app_mock);
+}
+
+/**
+ * @brief  Group of tests which check restoring resumption with different data
+ */
+
+TEST_F(ResumeCtrlTest, RestoreAppHMIState_RestoreHMILevelFull) {
+  mobile_apis::HMILevel::eType restored_test_type = eType::HMI_FULL;
+
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::hash_id] = hash;
+  saved_app[application_manager::strings::grammar_id] = test_grammar_id;
+  saved_app[application_manager::strings::hmi_level] = restored_test_type;
+
+  MockStateController state_controller_;
+  EXPECT_CALL(app_mngr_, state_controller()).WillOnce(ReturnRef(state_controller_));
+  EXPECT_CALL(state_controller_, SetRegularState(_, restored_test_type))
+      .Times(AtLeast(1));
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .WillOnce(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+
+  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345"))
+      .WillOnce(Return(policy::kDeviceAllowed));
+  EXPECT_CALL(*app_mock, set_is_resuming(true));
+
+  bool res = res_ctrl->RestoreAppHMIState(app_mock);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, SetupDefaultHMILevel) {
+  smart_objects::SmartObject saved_app;
+
+  saved_app[application_manager::strings::hmi_level] = default_test_type;
+
+  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+      .WillRepeatedly(Return(default_test_type));
+  GetInfoFromApp();
+  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0);
+
+  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+      .WillOnce(Return(default_test_type));
+
+  MockStateController state_controller_;
+  EXPECT_CALL(app_mngr_, state_controller()).WillOnce(ReturnRef(state_controller_));
+  EXPECT_CALL(state_controller_, SetRegularState(_, default_test_type))
+      .Times(AtLeast(1));
+
+  res_ctrl->SetupDefaultHMILevel(app_mock);
+}
+
+/**
+ * @brief group of tests which check correct SetAppHMIState
+*/
+
+TEST_F(ResumeCtrlTest, SetAppHMIState_HMINone_WithoutCheckPolicy) {
+  GetInfoFromApp();
+
+  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0);
+
+  EXPECT_CALL(*app_mock, set_is_resuming(true));
+  MockStateController state_controller_;
+  EXPECT_CALL(app_mngr_, state_controller()).WillOnce(ReturnRef(state_controller_));
+  EXPECT_CALL(state_controller_, SetRegularState(_, default_test_type))
+      .Times(AtLeast(1));
+  bool res = res_ctrl->SetAppHMIState(app_mock, default_test_type, false);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, SetAppHMIState_HMILimited_WithoutCheckPolicy) {
+  mobile_apis::HMILevel::eType test_type = eType::HMI_LIMITED;
+  GetInfoFromApp();
+  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0);
+
+  EXPECT_CALL(*app_mock, set_is_resuming(true));
+  MockStateController state_controller_;
+  EXPECT_CALL(app_mngr_, state_controller()).WillOnce(ReturnRef(state_controller_));
+  EXPECT_CALL(state_controller_, SetRegularState(_, test_type))
+      .Times(AtLeast(1));
+  bool res = res_ctrl->SetAppHMIState(app_mock, test_type, false);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, SetAppHMIState_HMIFull_WithoutCheckPolicy) {
+  mobile_apis::HMILevel::eType test_type = eType::HMI_FULL;
+  GetInfoFromApp();
+  // GetDefaultHmiLevel should not be called
+  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_)).Times(0);
+  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0);
+
+  EXPECT_CALL(*app_mock, set_is_resuming(true));
+  MockStateController state_controller_;
+  EXPECT_CALL(app_mngr_, state_controller()).WillOnce(ReturnRef(state_controller_));
+  EXPECT_CALL(state_controller_, SetRegularState(_, test_type))
+      .Times(AtLeast(1));
+
+  bool res = res_ctrl->SetAppHMIState(app_mock, test_type, false);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, SetAppHMIState_HMIFull_WithPolicy_DevAllowed) {
+  mobile_apis::HMILevel::eType test_type = eType::HMI_FULL;
+
+  GetInfoFromApp();
+  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345"))
+      .WillOnce(Return(policy::kDeviceAllowed));
+
+  EXPECT_CALL(*app_mock, set_is_resuming(true));
+  MockStateController state_controller_;
+  EXPECT_CALL(app_mngr_, state_controller()).WillOnce(ReturnRef(state_controller_));
+  EXPECT_CALL(state_controller_, SetRegularState(_, test_type))
+      .Times(AtLeast(1));
+
+  bool res = res_ctrl->SetAppHMIState(app_mock, test_type, true);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, SetAppHMIState_HMIFull_WithPolicy_DevDisallowed) {
+  mobile_apis::HMILevel::eType test_type = eType::HMI_FULL;
+
+  GetInfoFromApp();
+  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345"))
+      .WillOnce(Return(policy::kDeviceDisallowed));
+
+  EXPECT_CALL(*app_mock, set_is_resuming(true));
+  MockStateController state_controller_;
+  EXPECT_CALL(app_mngr_, state_controller()).WillOnce(ReturnRef(state_controller_));
+  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+      .WillOnce(Return(default_test_type));
+  EXPECT_CALL(state_controller_, SetRegularState(_, default_test_type))
+      .Times(AtLeast(1));
+  bool res = res_ctrl->SetAppHMIState(app_mock, test_type, true);
+  EXPECT_FALSE(res);
+}
+
+TEST_F(ResumeCtrlTest, SaveApplication) {
+  utils::SharedPtr<application_manager::Application> app_sh_mock =
+      ::utils::MakeShared<application_manager_test::MockApplication>();
+
+  EXPECT_CALL(*mock_storage, SaveApplication(app_sh_mock));
+  res_ctrl->SaveApplication(app_sh_mock);
+}
+
+TEST_F(ResumeCtrlTest, OnAppActivated_ResumptionHasStarted) {
+  smart_objects::SmartObject saved_app;
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(test_policy_app_id, _, _))
+      .WillOnce(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+  ON_CALL(*app_mock, app_id()).WillByDefault(Return(test_app_id));
+
+  bool res = res_ctrl->StartResumptionOnlyHMILevel(app_mock);
+  EXPECT_TRUE(res);
+
+  utils::SharedPtr<application_manager_test::MockApplication> app_sh_mock =
+      ::utils::MakeShared<application_manager_test::MockApplication>();
+
+  EXPECT_CALL(*app_sh_mock, app_id()).WillOnce(Return(test_app_id));
+  res_ctrl->OnAppActivated(app_sh_mock);
+}
+
+TEST_F(ResumeCtrlTest, OnAppActivated_ResumptionNotActive) {
+  utils::SharedPtr<application_manager_test::MockApplication> app_sh_mock =
+      ::utils::MakeShared<application_manager_test::MockApplication>();
+  EXPECT_CALL(*app_sh_mock, app_id()).Times(0);
+  res_ctrl->OnAppActivated(app_sh_mock);
+}
+
+TEST_F(ResumeCtrlTest, IsHMIApplicationIdExist) {
+  uint32_t hmi_app_id = 10;
+
+  EXPECT_CALL(*mock_storage, IsHMIApplicationIdExist(hmi_app_id))
+      .WillOnce(Return(true));
+  EXPECT_TRUE(res_ctrl->IsHMIApplicationIdExist(hmi_app_id));
+}
+
+TEST_F(ResumeCtrlTest, GetHMIApplicationID) {
+  uint32_t hmi_app_id = 10;
+  std::string device_id = "test_device_id";
+
+  EXPECT_CALL(*mock_storage, GetHMIApplicationID(test_policy_app_id, device_id))
+      .WillOnce(Return(hmi_app_id));
+  EXPECT_EQ(hmi_app_id,
+            res_ctrl->GetHMIApplicationID(test_policy_app_id, device_id));
+}
+
+TEST_F(ResumeCtrlTest, IsApplicationSaved) {
+  std::string policy_app_id = "policy_app_id";
+  std::string device_id = "device_id";
+
+  EXPECT_CALL(*mock_storage, IsApplicationSaved(policy_app_id, device_id))
+      .WillOnce(Return(true));
+  EXPECT_TRUE(res_ctrl->IsApplicationSaved(policy_app_id, device_id));
+}
+
+TEST_F(ResumeCtrlTest, CheckPersistenceFiles_WithoutCommandAndChoiceSets) {
+  uint32_t ign_off_count = 0;
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::ign_off_count] = ign_off_count;
+  saved_app[application_manager::strings::hmi_level] = HMI_FULL;
+
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .WillOnce(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+
+  EXPECT_TRUE(res_ctrl->CheckPersistenceFilesForResumption(app_mock));
+}
+
+TEST_F(ResumeCtrlTest, CheckPersistenceFilesForResumption_WithCommands) {
+  smart_objects::SmartObject test_application_commands;
+  uint32_t ign_off_count = 0;
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::ign_off_count] = ign_off_count;
+  saved_app[application_manager::strings::hmi_level] = HMI_FULL;
+  saved_app[application_manager::strings::application_commands] =
+      test_application_commands;
+
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .WillOnce(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+
+  EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
+              VerifyImageFiles(_, _, _))
+      .WillRepeatedly(Return(mobile_apis::Result::SUCCESS));
+
+  EXPECT_TRUE(res_ctrl->CheckPersistenceFilesForResumption(app_mock));
+}
+
+TEST_F(ResumeCtrlTest, CheckPersistenceFilesForResumption_WithChoiceSet) {
+  smart_objects::SmartObject test_choice_sets;
+  uint32_t ign_off_count = 0;
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::ign_off_count] = ign_off_count;
+  saved_app[application_manager::strings::hmi_level] = HMI_FULL;
+  saved_app[application_manager::strings::application_choice_sets] =
+      test_choice_sets;
+
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .WillOnce(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+
+  EXPECT_TRUE(res_ctrl->CheckPersistenceFilesForResumption(app_mock));
+}
+
+// TODO (VVeremjova) APPLINK-16718
+TEST_F(ResumeCtrlTest, DISABLED_OnSuspend) {
+  EXPECT_CALL(*mock_storage, OnSuspend());
+  res_ctrl->OnSuspend();
+}
+
+TEST_F(ResumeCtrlTest, OnAwake) {
+  uint32_t timeout = 10u;
+  EXPECT_CALL(mock_application_manager_settings_, app_resumption_save_persistent_data_timeout()).WillOnce(ReturnRef(timeout));
+  EXPECT_CALL(*mock_storage, OnAwake());
+  res_ctrl->OnAwake();
+}
+
+TEST_F(ResumeCtrlTest, RemoveApplicationFromSaved) {
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, RemoveApplicationFromSaved(_, _))
+      .WillOnce(Return(true));
+  EXPECT_TRUE(res_ctrl->RemoveApplicationFromSaved(app_mock));
+}
+
+TEST_F(ResumeCtrlTest, CheckApplicationHash) {
+  smart_objects::SmartObject saved_app;
+
+  std::string test_hash = "saved_hash";
+  saved_app[application_manager::strings::hash_id] = test_hash;
+
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(test_policy_app_id, _, _))
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+  EXPECT_TRUE(res_ctrl->CheckApplicationHash(app_mock, test_hash));
+}
+
+}  // namespace resumption_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/application_manager/test/resumption/resumption_data_db_test.cc b/src/components/application_manager/test/resumption/resumption_data_db_test.cc
index 247f269fff..adc5447beb 100644
--- a/src/components/application_manager/test/resumption/resumption_data_db_test.cc
+++ b/src/components/application_manager/test/resumption/resumption_data_db_test.cc
@@ -38,12 +38,10 @@
 #include "sql_database.h"
 #include "sql_query.h"
 #include "utils/make_shared.h"
-
-#include "application_manager/application_manager_impl.h"
-#include "config_profile/profile.h"
 #include "utils/file_system.h"
-#include "application_manager/resumption_data_test.h"
 #include "application_manager/test_resumption_data_db.h"
+#include "resumption_data_test.h"
+
 
 #include "application_manager/resumption/resumption_sql_queries.h"
 #include "application_manager/resumption/resumption_data_db.h"
@@ -53,6 +51,7 @@ namespace components {
 namespace resumption_test {
 
 using ::testing::NiceMock;
+using ::testing::ReturnRef;
 using application_manager_test::MockApplication;
 
 namespace am = application_manager;
@@ -83,18 +82,12 @@ class ResumptionDataDBTest : public ResumptionDataTest {
 
   static void SetUpTestCase() {
     kDatabaseName = "resumption";
-    if (is_in_file) {
-      ::profile::Profile::instance()->config_file_name(
-          "smartDeviceLink_test.ini");
-      path_ = profile::Profile::instance()->app_storage_folder();
-      CreateDirectory("./" + path_);
-      test_db_ = new utils::dbms::SQLDatabase(kDatabaseName);
-      test_db_->set_path(path_ + "/");
-      res_db_ = new TestResumptionDataDB(In_File_Storage);
-    } else {
-      res_db_ = new TestResumptionDataDB(In_Memory_Storage);
-      test_db_ = res_db_->get_db_handle();
-    }
+    path_ = "test_storage";
+    CreateDirectory("./" + path_);
+    ON_CALL(mock_application_manager_settings_, app_storage_folder()).WillByDefault(ReturnRef(path_));
+    test_db_ = new utils::dbms::SQLDatabase(kDatabaseName);
+    test_db_->set_path(path_ + "/");
+    res_db_ = new TestResumptionDataDB(mock_application_manager_settings_);
 
     EXPECT_TRUE(test_db_->Open());
     EXPECT_TRUE(test_db_->IsReadWrite());
@@ -107,7 +100,6 @@ class ResumptionDataDBTest : public ResumptionDataTest {
   static void TearDownTestCase() {
     test_db_->Close();
     if (is_in_file) {
-      ::profile::Profile::instance()->config_file_name("smartDeviceLink.ini");
       RemoveDirectory("./" + path_, true);
     }
     delete res_db_;
@@ -122,11 +114,11 @@ class ResumptionDataDBTest : public ResumptionDataTest {
   }
 
   void SetZeroIgnOffTime() {
-    utils::dbms::SQLQuery query(test_db());
-    EXPECT_TRUE(query.Prepare(kUpdateLastIgnOffTime));
-    query.Bind(0, 0);
-    EXPECT_TRUE(query.Exec());
-  }
+      utils::dbms::SQLQuery query(test_db());
+      EXPECT_TRUE(query.Prepare(KUpdateLastIgnOffTime));
+      query.Bind(0, 0);
+      EXPECT_TRUE(query.Exec());
+    }
 
   static TestResumptionDataDB* res_db_;
 
diff --git a/src/components/application_manager/test/resumption/resumption_data_json_test.cc b/src/components/application_manager/test/resumption/resumption_data_json_test.cc
index 92f27da92e..5a5346e17f 100644
--- a/src/components/application_manager/test/resumption/resumption_data_json_test.cc
+++ b/src/components/application_manager/test/resumption/resumption_data_json_test.cc
@@ -36,11 +36,11 @@
 
 #include "application_manager/usage_statistics.h"
 #include "application_manager/mock_application.h"
-#include "application_manager/mock_resumption_data.h"
+#include "include/resumption_data_mock.h"
 #include "interfaces/MOBILE_API.h"
 #include "resumption/last_state.h"
 
-#include "application_manager/resumption_data_test.h"
+#include "resumption_data_test.h"
 #include "formatters/CFormatterJsonBase.h"
 #include "config_profile/profile.h"
 #include "utils/file_system.h"
@@ -65,7 +65,8 @@ namespace Formatters = NsSmartDeviceLink::NsJSONHandler::Formatters;
 class ResumptionDataJsonTest : public ResumptionDataTest {
  protected:
   ResumptionDataJsonTest() : last_state_("app_storage_folder",
-                                         "app_info_storage"), res_json(last_state_) {}
+                                         "app_info_storage"), res_json(last_state_,
+                                                                       mock_application_manager_settings_) {}
   virtual void SetUp() {
     app_mock = new NiceMock<application_manager_test::MockApplication>();
 
@@ -104,7 +105,8 @@ class ResumptionDataJsonTest : public ResumptionDataTest {
 
   resumption::LastState last_state_;
   ResumptionDataJson res_json;
-
+  application_manager_test::MockApplicationManagerSettings mock_application_manager_settings_;
+  std::string policy_app_id_;
 };
 
 TEST_F(ResumptionDataJsonTest, SaveApplication) {
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 6cfcd93c14..06ecff8d7a 100644
--- a/src/components/application_manager/test/resumption/resumption_data_test.cc
+++ b/src/components/application_manager/test/resumption/resumption_data_test.cc
@@ -37,12 +37,11 @@
 #include "application_manager/usage_statistics.h"
 #include "include/resumption_data_mock.h"
 #include "utils/custom_string.h"
-#include "application_manager/application_manager_impl.h"
 #include "application_manager/application.h"
 #include "utils/data_accessor.h"
 #include "application_manager/message_helper.h"
 
-#include "include/resumption_data_test.h"
+#include "resumption_data_test.h"
 
 namespace test {
 namespace components {
@@ -53,7 +52,7 @@ using ::testing::ReturnRef;
 using ::testing::ReturnPointee;
 
 void ResumptionDataTest::CheckSavedApp(sm::SmartObject& resume_app_list) {
-  EXPECT_EQ(mobile_app_id_, resume_app_list[am::strings::app_id].asString());
+  EXPECT_EQ(policy_app_id_, resume_app_list[am::strings::app_id].asString());
   EXPECT_EQ(grammar_id_, resume_app_list[am::strings::grammar_id].asUInt());
   EXPECT_EQ(app_id_, resume_app_list[am::strings::connection_key].asUInt());
   EXPECT_EQ(hmi_app_id_, resume_app_list[am::strings::hmi_app_id].asUInt());
@@ -346,7 +345,7 @@ void ResumptionDataTest::PrepareData() {
 
   ON_CALL(*app_mock, is_application_data_changed()).WillByDefault(Return(true));
 
-  ON_CALL(*app_mock, mobile_app_id()).WillByDefault(Return(mobile_app_id_));
+  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_));
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 7fc49a53d0..bea28b1e1e 100755
--- a/src/components/application_manager/test/resumption/resumption_data_test.h
+++ b/src/components/application_manager/test/resumption/resumption_data_test.h
@@ -34,9 +34,15 @@
 #include <algorithm>
 #include "gtest/gtest.h"
 #include "application_manager/usage_statistics.h"
-#include "application_mock.h"
-#include "application_manager/application_manager_impl.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
 #include "utils/data_accessor.h"
+#include "config_profile/profile.h"
+#include "application_manager/policies/policy_handler.h"
+#include "application_manager/state_controller.h"
+#include "application_manager/resumption/resume_ctrl.h"
+#include "application_manager/event_engine/event_dispatcher.h"
+#include "application_manager/mock_application_manager_settings.h"
 
 namespace test {
 namespace components {
@@ -51,20 +57,23 @@ using namespace resumption;
 using namespace mobile_apis;
 
 class ResumptionDataTest : public ::testing::Test {
+ public :
+    ResumptionDataTest() :tts_chunks_count(4) {}
  protected:
   // Check structure in saved application
   void CheckSavedApp(sm::SmartObject& saved_data);
 
   // Set data for resumption
   virtual void PrepareData();
-  utils::SharedPtr<NiceMock<MockApplication>> app_mock;
+  utils::SharedPtr<NiceMock<application_manager_test::MockApplication>> app_mock;
 
+  profile::Profile profile_;
   HMILevel::eType hmi_level_;
   size_t app_id_;
   size_t hmi_app_id_;
   std::string policy_app_id_;
   size_t ign_off_count_;
-  const size_t tts_chunks_count = 4;
+  const size_t tts_chunks_count;
 
   size_t grammar_id_;
   std::string hash_;
@@ -111,7 +120,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 mac_address = "12345";
+  const std::string mac_address_ = "12345";
 
   am::CommandsMap test_commands_map;
   am::SubMenuMap test_submenu_map;
@@ -126,6 +135,7 @@ class ResumptionDataTest : public ::testing::Test {
   sync_primitives::Lock setlock_;
   sync_primitives::Lock btnlock_;
   sync_primitives::Lock ivilock_;
+  const std::string app_storage_folder_ = "";
 };
 
 }  // namespace resumption_test
diff --git a/src/components/application_manager/test/resumption_sql_queries_test.cc b/src/components/application_manager/test/resumption_sql_queries_test.cc
index 1e2ca6c7c1..46402b3a80 100644
--- a/src/components/application_manager/test/resumption_sql_queries_test.cc
+++ b/src/components/application_manager/test/resumption_sql_queries_test.cc
@@ -37,15 +37,17 @@
 #include <utility>
 #include "gtest/gtest.h"
 
-#include "sqlite_wrapper/sql_database.h"
-#include "sqlite_wrapper/sql_query.h"
+#include "utils/sqlite_wrapper/sql_database.h"
+#include "utils/sqlite_wrapper/sql_query.h"
 #include "utils/file_system.h"
-#include "config_profile/profile.h"
-#include "resumption_sql_queries.h"
+#include "application_manager/resumption/resumption_sql_queries.h"
 #include "policy/sql_pt_queries.h"
 
-namespace resumption {
 namespace test {
+namespace components {
+namespace resumption_test {
+
+using namespace ::resumption;
 
 using std::string;
 using std::pair;
@@ -115,7 +117,7 @@ class ResumptionSqlQueriesTest : public ::testing::Test {
     ASSERT_TRUE(db_->Open());
     ASSERT_TRUE(db_->IsReadWrite());
     SQLQuery query(db_);
-    ASSERT_TRUE(query.Exec(resumption::kCreateSchema));
+    ASSERT_TRUE(query.Exec(kCreateSchema));
     SQLQuery query_logging_off(db_);
     ASSERT_TRUE(query_logging_off.Exec(kJournalOff));
   }
@@ -126,8 +128,7 @@ class ResumptionSqlQueriesTest : public ::testing::Test {
     string file_to_delete = kDatabaseName + ".sqlite";
     file_system::DeleteFile(file_to_delete);
   }
-  void TearDown() { DeleteTablesData();
-                  }
+  void TearDown() { DeleteTablesData(); }
 
   void CheckDeleteQuery(const string& count_query, const string& query_to_check,
                         pair<int, string> app_info, pair<int, string> dev_info,
@@ -944,7 +945,7 @@ TEST_F(ResumptionSqlQueriesTest, kUpdateIgnOffCount_ExpectDataUpdated) {
   CheckSelectQuery(kSelectIgnOffCount, ign_off_count, 0);
   SQLQuery query(db());
   // Act
-  EXPECT_TRUE(query.Exec(resumption::kUpdateIgnOffCount));
+  EXPECT_TRUE(query.Exec(kUpdateIgnOffCount));
   // Check after action
   CheckSelectQuery(kSelectIgnOffCount, ign_off_count - 1, 0);
 }
@@ -1010,21 +1011,6 @@ TEST_F(ResumptionSqlQueriesTest, kUpdateSuspendData_ExpectDataUpdated) {
   CheckSelectQuery(kSelectIgnOffCount, 4, 0);
 }
 
-TEST_F(ResumptionSqlQueriesTest, KUpdateLastIgnOffTime_ExpectDataUpdated) {
-  // Arrange
-  SQLQuery query_insert_init_data(db());
-  EXPECT_TRUE(query_insert_init_data.Exec(kInsertInitData));
-  // Check before action
-  CheckSelectQuery(kSelectIgnOffTime, 0, 0);
-  // Act
-  SQLQuery query_update_ign_off_time(db());
-  EXPECT_TRUE(query_update_ign_off_time.Prepare(KUpdateLastIgnOffTime));
-  query_update_ign_off_time.Bind(0, 1);
-  EXPECT_TRUE(query_update_ign_off_time.Exec());
-  // Check after action
-  CheckSelectQuery(kSelectIgnOffTime, 1, 0);
-}
-
 TEST_F(ResumptionSqlQueriesTest, kDeleteFile_ExpectDataDeleted) {
   // Arrange
   SQLQuery temp_query(db());
@@ -2021,7 +2007,6 @@ TEST_F(ResumptionSqlQueriesTest, kSelectSubMenu_ExpectDataCorrect) {
                            hmiAppID, hmiLevel, ign_off_count, timeStamp, false,
                            app_id1, device_id, 9).LastInsertId();
   int64_t submenu_key =
-
       FillSubMenuTable(temp_query, 1, "menu_name", 1).LastInsertId();
 
   FillApplicationSubMenuArrayTable(temp_query, app_key, submenu_key);
@@ -2418,5 +2403,6 @@ TEST_F(ResumptionSqlQueriesTest, kSelectAppTable_ExpectDataCorrect) {
   CheckSelectQuery(kSelectAppTable, p1, p2, true, 9);
 }
 
+}  // namespace resumption_test
+}  // namespace components
 }  // namespace test
-}  // namespace resumption
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 c9120bee98..4c97b15dcd 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
@@ -43,7 +43,7 @@ namespace state_controller_test {
 
 namespace us = usage_statistics;
 
-class StatisticsManagerMock : public us::StatisticsManager {
+class MockStatisticsManager : public us::StatisticsManager {
  public:
   MOCK_METHOD1(Increment, void (us::GlobalCounterId));
   MOCK_METHOD2(Increment, void (const std::string&, us::AppCounterId));
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 f6e86e3400..452d269855 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
@@ -32,10 +32,10 @@
 
 #include "gtest/gtest.h"
 #include "application_manager/hmi_state.h"
-#include "application_manager/state_controller.h"
+#include "application_manager/state_controller_impl.h"
 #include "application_manager/usage_statistics.h"
 #include "application_manager/application_manager_impl.h"
-#include "application_mock.h"
+#include "application_manager/mock_application.h"
 #include "connection_handler/mock_connection_handler_settings.h"
 #include "connection_handler/connection_handler_impl.h"
 #include "transport_manager/mock_transport_manager.h"
@@ -51,6 +51,8 @@
 #include "protocol_handler/mock_session_observer.h"
 #include "connection_handler/mock_connection_handler.h"
 #include "application_manager/policies/mock_policy_handler_interface.h"
+#include "application_manager/mock_event_dispatcher.h"
+#include "application_manager/resumption/resume_ctrl.h"
 #include "application_manager/mock_application_manager.h"
 
 namespace am = application_manager;
@@ -122,57 +124,58 @@ enum ApplicationType {
   APP_TYPE_ATTENUATED
 };
 
-class StateControllerTest : public ::testing::Test {
+class StateControllerImplTest : public ::testing::Test {
  public:
-  StateControllerTest()
+  StateControllerImplTest()
       : ::testing::Test()
       , usage_stat("0",
                    utils::SharedPtr<usage_statistics::StatisticsManager>(
-                       new state_controller_test::StatisticsManagerMock))
-      , applications_(application_set_, applications_lock_)
-      , state_ctrl_(&app_manager_mock_) {}
+
+                       new state_controller_test::MockStatisticsManager))
+      , applications_(application_set_, applications_lock_){}
   NiceMock<application_manager_test::MockApplicationManager> app_manager_mock_;
   NiceMock<policy_test::MockPolicyHandlerInterface> policy_interface_;
   NiceMock<connection_handler_test::MockConnectionHandler> mock_connection_handler_;
   NiceMock<protocol_handler_test::MockSessionObserver> mock_session_observer_;
 
   am::UsageStatistics usage_stat;
+  NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_;
 
   am::ApplicationSet application_set_;
   mutable sync_primitives::Lock applications_lock_;
   DataAccessor<am::ApplicationSet> applications_;
-  am::StateController state_ctrl_;
+  utils::SharedPtr<am::StateControllerImpl> state_ctrl_;
 
   am::ApplicationSharedPtr simple_app_;
-  NiceMock<MockApplication>* simple_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* simple_app_ptr_;
   uint32_t simple_app_id_ = 1721;
 
   am::ApplicationSharedPtr navi_app_;
-  NiceMock<MockApplication>* navi_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* navi_app_ptr_;
   uint32_t navi_app_id_ = 1762;
 
   am::ApplicationSharedPtr media_app_;
-  NiceMock<MockApplication>* media_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* media_app_ptr_;
   uint32_t media_app_id_ = 1801;
 
   am::ApplicationSharedPtr vc_app_;
-  NiceMock<MockApplication>* vc_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* vc_app_ptr_;
   uint32_t vc_app_id_ = 1825;
 
   am::ApplicationSharedPtr media_navi_app_;
-  NiceMock<MockApplication>* media_navi_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* media_navi_app_ptr_;
   uint32_t media_navi_app_id_ = 1855;
 
   am::ApplicationSharedPtr media_vc_app_;
-  NiceMock<MockApplication>* media_vc_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* media_vc_app_ptr_;
   uint32_t media_vc_app_id_ = 1881;
 
   am::ApplicationSharedPtr navi_vc_app_;
-  NiceMock<MockApplication>* navi_vc_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* navi_vc_app_ptr_;
   uint32_t navi_vc_app_id_ = 1894;
 
   am::ApplicationSharedPtr media_navi_vc_app_;
-  NiceMock<MockApplication>* media_navi_vc_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* media_navi_vc_app_ptr_;
   uint32_t media_navi_vc_app_id_ = 1922;
 
   std::vector<am::HmiStatePtr> valid_states_for_audio_app_;
@@ -197,7 +200,7 @@ class StateControllerTest : public ::testing::Test {
     namespace SystemContext = mobile_apis::SystemContext;
 
     am::HmiStatePtr state =
-        utils::MakeShared<am::HmiState>(simple_app_id_, &app_manager_mock_);
+        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);
@@ -474,7 +477,7 @@ class StateControllerTest : public ::testing::Test {
   void TestSetState(am::ApplicationSharedPtr app,
                     am::HmiStatePtr hmi_state,
                     ApplicationType app_t,
-                    void (StateControllerTest::*call_back)(
+                    void (StateControllerImplTest::*call_back)(
                         std::vector<am::HmiStatePtr>&, ApplicationType)) {
     InsertApplication(app);
     std::vector<am::HmiStatePtr> result_hmi_state;
@@ -506,7 +509,7 @@ class StateControllerTest : public ::testing::Test {
       am::HmiStatePtr first_hmi_state,
       am::HmiStatePtr second_hmi_state,
       ApplicationType app_t,
-      void (StateControllerTest::*call_back)(std::vector<am::HmiStatePtr>&,
+      void (StateControllerImplTest::*call_back)(std::vector<am::HmiStatePtr>&,
                                              ApplicationType)) {
     InsertApplication(app);
     std::vector<am::HmiStatePtr> result_hmi_state;
@@ -540,7 +543,7 @@ class StateControllerTest : public ::testing::Test {
   }
 
   template <typename T, typename Q>
-  void TestMixState(void (StateControllerTest::*call_back_result)(
+  void TestMixState(void (StateControllerImplTest::*call_back_result)(
       std::vector<am::HmiStatePtr>&, ApplicationType)) {
     std::vector<am::ApplicationSharedPtr>::iterator it_begin =
         applications_list_.begin();
@@ -554,9 +557,9 @@ class StateControllerTest : public ::testing::Test {
       app_type = AppType(app_id);
       app = (*it_begin);
       am::HmiStatePtr state_first =
-          utils::MakeShared<T>(app_id, &app_manager_mock_);
+          utils::MakeShared<T>(app_id, app_manager_mock_);
       am::HmiStatePtr state_second =
-          utils::MakeShared<Q>(app_id, &app_manager_mock_);
+          utils::MakeShared<Q>(app_id, app_manager_mock_);
       TestSetSeveralState(
           app, state_first, state_second, app_type, call_back_result);
       TestSetSeveralState(
@@ -565,12 +568,12 @@ class StateControllerTest : public ::testing::Test {
   }
 
  protected:
-  am::ApplicationSharedPtr ConfigureApp(NiceMock<MockApplication>** app_mock,
+  am::ApplicationSharedPtr ConfigureApp(NiceMock<application_manager_test::MockApplication>** app_mock,
                                         uint32_t app_id,
                                         bool media,
                                         bool navi,
                                         bool vc) {
-    *app_mock = new NiceMock<MockApplication>;
+    *app_mock = new NiceMock<application_manager_test::MockApplication>;
 
     Mock::AllowLeak(*app_mock);  // WorkAround for gogletest bug
     am::ApplicationSharedPtr app(*app_mock);
@@ -826,6 +829,9 @@ class StateControllerTest : public ::testing::Test {
   }
 
   virtual void SetUp() OVERRIDE {
+    ON_CALL(app_manager_mock_, event_dispatcher()).WillByDefault(ReturnRef(mock_event_dispatcher_));
+    state_ctrl_ = utils::MakeShared<am::StateControllerImpl>(app_manager_mock_);
+
     ON_CALL(app_manager_mock_, applications())
         .WillByDefault(Return(applications_));
     ConfigureApps();
@@ -855,7 +861,7 @@ class StateControllerTest : public ::testing::Test {
     (*bc_activate_app_request)[am::strings::params]
                               [am::strings::correlation_id] = corr_id;
     ON_CALL(*message_helper_mock_,
-                GetBCActivateAppRequestToHMI(_, _, _,hmi_lvl, _))
+                GetBCActivateAppRequestToHMI(_, _, _,hmi_lvl, _, _))
         .WillByDefault(Return(bc_activate_app_request));
 
     ON_CALL(app_manager_mock_, ManageHMICommand(bc_activate_app_request))
@@ -863,7 +869,7 @@ class StateControllerTest : public ::testing::Test {
   }
 
   void ExpectSuccesfullSetHmiState(am::ApplicationSharedPtr app,
-                                   NiceMock<MockApplication>* app_mock,
+                                   NiceMock<application_manager_test::MockApplication>* app_mock,
                                    am::HmiStatePtr old_state,
                                    am::HmiStatePtr new_state) {
     EXPECT_CALL(*app_mock, CurrentHmiState())
@@ -882,7 +888,7 @@ class StateControllerTest : public ::testing::Test {
 
   void ExpectAppChangeHmiStateDueToConflictResolving(
       am::ApplicationSharedPtr app,
-      NiceMock<MockApplication>* app_mock,
+      NiceMock<application_manager_test::MockApplication>* app_mock,
       am::HmiStatePtr old_state,
       am::HmiStatePtr new_state) {
     EXPECT_CALL(*app_mock, RegularHmiState())
@@ -893,7 +899,7 @@ class StateControllerTest : public ::testing::Test {
 
   void ExpectAppWontChangeHmiStateDueToConflictResolving(
       am::ApplicationSharedPtr app,
-      NiceMock<MockApplication>* app_mock,
+      NiceMock<application_manager_test::MockApplication>* app_mock,
       am::HmiStatePtr state) {
     EXPECT_CALL(*app_mock, RegularHmiState()).WillOnce(Return(state));
     EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(app)).Times(0);
@@ -938,7 +944,7 @@ class StateControllerTest : public ::testing::Test {
   }
 
   void CheckStateApplyingForApplication(
-      NiceMock<MockApplication>& application,
+      NiceMock<application_manager_test::MockApplication>& application,
       std::vector<am::HmiState::StateID>& state_ids) {
     using smart_objects::SmartObject;
     using am::event_engine::Event;
@@ -955,12 +961,12 @@ class StateControllerTest : public ::testing::Test {
       switch (state_id) {
         case am::HmiState::StateID::STATE_ID_VR_SESSION: {
           Event vr_start_event(FunctionID::VR_Started);
-          state_ctrl_.on_event(vr_start_event);
+          state_ctrl_->on_event(vr_start_event);
           break;
         }
         case am::HmiState::StateID::STATE_ID_TTS_SESSION: {
           Event tts_start_event(FunctionID::TTS_Started);
-          state_ctrl_.on_event(tts_start_event);
+          state_ctrl_->on_event(tts_start_event);
           break;
         }
         case am::HmiState::StateID::STATE_ID_PHONE_CALL: {
@@ -971,7 +977,7 @@ class StateControllerTest : public ::testing::Test {
           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);
+          state_ctrl_->on_event(phone_call_event);
           break;
         }
         case am::HmiState::StateID::STATE_ID_SAFETY_MODE: {
@@ -982,11 +988,11 @@ class StateControllerTest : public ::testing::Test {
           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);
+          state_ctrl_->on_event(emergency_event);
           break;
         }
         case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: {
-          state_ctrl_.OnNaviStreamingStarted();
+          state_ctrl_->OnNaviStreamingStarted();
           break;
         }
         default:
@@ -1007,12 +1013,12 @@ class StateControllerTest : public ::testing::Test {
       switch (state_id) {
         case am::HmiState::StateID::STATE_ID_VR_SESSION: {
           Event vr_stop_event(FunctionID::VR_Stopped);
-          state_ctrl_.on_event(vr_stop_event);
+          state_ctrl_->on_event(vr_stop_event);
           break;
         }
         case am::HmiState::StateID::STATE_ID_TTS_SESSION: {
           Event tts_stop_event(FunctionID::TTS_Stopped);
-          state_ctrl_.on_event(tts_stop_event);
+          state_ctrl_->on_event(tts_stop_event);
           break;
         }
         case am::HmiState::StateID::STATE_ID_PHONE_CALL: {
@@ -1023,7 +1029,7 @@ class StateControllerTest : public ::testing::Test {
           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);
+          state_ctrl_->on_event(phone_call_event);
           break;
         }
         case am::HmiState::StateID::STATE_ID_SAFETY_MODE: {
@@ -1034,11 +1040,11 @@ class StateControllerTest : public ::testing::Test {
           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);
+          state_ctrl_->on_event(emergency_event);
           break;
         }
         case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: {
-          state_ctrl_.OnNaviStreamingStopped();
+          state_ctrl_->OnNaviStreamingStopped();
           break;
         }
         default:
@@ -1050,19 +1056,19 @@ class StateControllerTest : public ::testing::Test {
   }
 };
 
-TEST_F(StateControllerTest, OnStateChangedWithEqualStates) {
+TEST_F(StateControllerImplTest, OnStateChangedWithEqualStates) {
   EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(_)).Times(0);
   EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0);
   EXPECT_CALL(*simple_app_ptr_, ResetDataInNone()).Times(0);
 
   for (uint32_t i = 0; i < valid_states_for_not_audio_app_.size(); ++i) {
-    state_ctrl_.OnStateChanged(simple_app_,
+    state_ctrl_->OnStateChanged(simple_app_,
                                valid_states_for_not_audio_app_[i],
                                valid_states_for_not_audio_app_[i]);
   }
 }
 
-TEST_F(StateControllerTest, OnStateChangedWithDifferentStates) {
+TEST_F(StateControllerImplTest, OnStateChangedWithDifferentStates) {
   for (uint32_t i = 0; i < valid_states_for_not_audio_app_.size(); ++i) {
     for (uint32_t j = 0; j < valid_states_for_not_audio_app_.size(); ++j) {
       HmiStatesComparator comp(valid_states_for_not_audio_app_[i]);
@@ -1079,7 +1085,7 @@ TEST_F(StateControllerTest, OnStateChangedWithDifferentStates) {
             valid_states_for_not_audio_app_[j]->hmi_level()) {
           EXPECT_CALL(*simple_app_ptr_, ResetDataInNone()).Times(1);
         }
-        state_ctrl_.OnStateChanged(simple_app_,
+        state_ctrl_->OnStateChanged(simple_app_,
                                    valid_states_for_not_audio_app_[i],
                                    valid_states_for_not_audio_app_[j]);
 
@@ -1091,7 +1097,7 @@ TEST_F(StateControllerTest, OnStateChangedWithDifferentStates) {
   }
 }
 
-TEST_F(StateControllerTest, OnStateChangedToNone) {
+TEST_F(StateControllerImplTest, OnStateChangedToNone) {
   using namespace am;
   using namespace mobile_apis;
 
@@ -1103,13 +1109,13 @@ TEST_F(StateControllerTest, OnStateChangedToNone) {
                                               SystemContext::SYSCTXT_MAIN);
 
   EXPECT_CALL(*simple_app_ptr_, ResetDataInNone()).Times(0);
-  state_ctrl_.OnStateChanged(simple_app_, none_state, not_none_state);
+  state_ctrl_->OnStateChanged(simple_app_, none_state, not_none_state);
 
   EXPECT_CALL(*simple_app_ptr_, ResetDataInNone()).Times(1);
-  state_ctrl_.OnStateChanged(simple_app_, not_none_state, none_state);
+  state_ctrl_->OnStateChanged(simple_app_, not_none_state, none_state);
 }
 
-TEST_F(StateControllerTest, MoveSimpleAppToValidStates) {
+TEST_F(StateControllerImplTest, MoveSimpleAppToValidStates) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1133,18 +1139,18 @@ TEST_F(StateControllerTest, MoveSimpleAppToValidStates) {
 
     EXPECT_CALL(*simple_app_ptr_,
                 SetRegularState(Truly(HmiStatesComparator(state_to_setup))));
-    state_ctrl_.SetRegularState<false>(simple_app_, state_to_setup);
+    state_ctrl_->SetRegularState(simple_app_, state_to_setup, false);
     initial_state = state_to_setup;
   }
 }
 
-TEST_F(StateControllerTest, MoveAudioNotResumeAppToValidStates) {
+TEST_F(StateControllerImplTest, 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<MockApplication>* audio_app_mock = media_navi_vc_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* audio_app_mock = media_navi_vc_app_ptr_;
 
   HmiStatePtr initial_state = createHmiState(HMILevel::INVALID_ENUM,
                                              AudioStreamingState::INVALID_ENUM,
@@ -1166,18 +1172,18 @@ TEST_F(StateControllerTest, MoveAudioNotResumeAppToValidStates) {
 
     EXPECT_CALL(*audio_app_mock,
                 SetRegularState(Truly(HmiStatesComparator(state_to_setup))));
-    state_ctrl_.SetRegularState<false>(media_navi_vc_app_, state_to_setup);
+    state_ctrl_->SetRegularState(media_navi_vc_app_, state_to_setup, false);
     initial_state = state_to_setup;
   }
 }
 
-TEST_F(StateControllerTest, MoveAudioResumeAppToValidStates) {
+TEST_F(StateControllerImplTest, MoveAudioResumeAppToValidStates) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
   am::ApplicationSharedPtr audio_app = media_navi_vc_app_;
-  NiceMock<MockApplication>* audio_app_mock = media_navi_vc_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* audio_app_mock = media_navi_vc_app_ptr_;
 
   HmiStatePtr initial_state = createHmiState(HMILevel::INVALID_ENUM,
                                              AudioStreamingState::INVALID_ENUM,
@@ -1198,7 +1204,7 @@ TEST_F(StateControllerTest, MoveAudioResumeAppToValidStates) {
     if (state_to_setup->hmi_level() == HMILevel::HMI_LIMITED) {
       EXPECT_CALL(*audio_app_mock, is_resuming()).WillRepeatedly(Return(true));
       EXPECT_CALL(*message_helper_mock_,
-                  SendOnResumeAudioSourceToHMI(media_navi_vc_app_id_));
+                  SendOnResumeAudioSourceToHMI(media_navi_vc_app_id_, _));
       state_to_check->set_audio_streaming_state(AudioStreamingState::AUDIBLE);
 
     } else {
@@ -1220,12 +1226,12 @@ TEST_F(StateControllerTest, MoveAudioResumeAppToValidStates) {
     // Check that we set correct state
     EXPECT_CALL(*audio_app_mock,
                 SetRegularState(Truly(HmiStatesComparator(state_to_check))));
-    state_ctrl_.SetRegularState<false>(media_navi_vc_app_, state_to_setup);
+    state_ctrl_->SetRegularState(media_navi_vc_app_, state_to_setup, false);
     initial_state = state_to_setup;
   }
 }
 
-TEST_F(StateControllerTest, MoveAppFromValidStateToInvalid) {
+TEST_F(StateControllerImplTest, MoveAppFromValidStateToInvalid) {
   using am::HmiState;
   using am::HmiStatePtr;
   for (std::vector<HmiStatePtr>::iterator invalid_state_it =
@@ -1237,7 +1243,7 @@ TEST_F(StateControllerTest, MoveAppFromValidStateToInvalid) {
     EXPECT_CALL(*simple_app_ptr_, is_resuming()).Times(0);
     EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0);
     EXPECT_CALL(*simple_app_ptr_, SetRegularState(_)).Times(0);
-    state_ctrl_.SetRegularState<false>(simple_app_, invalid_state);
+    state_ctrl_->SetRegularState(simple_app_, invalid_state, false);
   }
 
   for (std::vector<HmiStatePtr>::iterator invalid_state_it =
@@ -1249,19 +1255,19 @@ TEST_F(StateControllerTest, MoveAppFromValidStateToInvalid) {
     EXPECT_CALL(*media_navi_vc_app_ptr_, is_resuming()).Times(0);
     EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0);
     EXPECT_CALL(*media_navi_vc_app_ptr_, SetRegularState(_)).Times(0);
-    state_ctrl_.SetRegularState<false>(media_navi_vc_app_, invalid_state);
+    state_ctrl_->SetRegularState(media_navi_vc_app_, invalid_state, false);
   }
 }
 
-TEST_F(StateControllerTest, SetFullToSimpleAppWhileAnotherSimpleAppIsInFull) {
+TEST_F(StateControllerImplTest, SetFullToSimpleAppWhileAnotherSimpleAppIsInFull) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
   am::ApplicationSharedPtr app_in_full;
-  NiceMock<MockApplication>* app_in_full_mock;
+  NiceMock<application_manager_test::MockApplication>* app_in_full_mock;
 
   am::ApplicationSharedPtr app_moved_to_full;
-  NiceMock<MockApplication>* app_moved_to_full_mock;
+  NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock;
 
   app_in_full =
       ConfigureApp(&app_in_full_mock, 1761, NOT_MEDIA, NOT_NAVI, NOT_VC);
@@ -1279,18 +1285,18 @@ TEST_F(StateControllerTest, SetFullToSimpleAppWhileAnotherSimpleAppIsInFull) {
   ExpectAppChangeHmiStateDueToConflictResolving(
       app_in_full, app_in_full_mock, FullNotAudibleState(), BackgroundState());
 
-  state_ctrl_.SetRegularState<false>(app_moved_to_full, FullNotAudibleState());
+  state_ctrl_->SetRegularState(app_moved_to_full, FullNotAudibleState(), false);
 }
 
-TEST_F(StateControllerTest, SetFullToSimpleAppWhileAudioAppAppIsInFull) {
+TEST_F(StateControllerImplTest, SetFullToSimpleAppWhileAudioAppAppIsInFull) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
   am::ApplicationSharedPtr app_in_full = media_navi_vc_app_;
-  NiceMock<MockApplication>* app_in_full_mock = media_navi_vc_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* app_in_full_mock = media_navi_vc_app_ptr_;
 
   am::ApplicationSharedPtr app_moved_to_full = simple_app_;
-  NiceMock<MockApplication>* app_moved_to_full_mock = simple_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock = simple_app_ptr_;
 
   InsertApplication(app_in_full);
   InsertApplication(app_moved_to_full);
@@ -1302,20 +1308,20 @@ TEST_F(StateControllerTest, SetFullToSimpleAppWhileAudioAppAppIsInFull) {
 
   ExpectAppChangeHmiStateDueToConflictResolving(
       app_in_full, app_in_full_mock, FullAudibleState(), LimitedState());
-  state_ctrl_.SetRegularState<false>(app_moved_to_full, FullNotAudibleState());
+  state_ctrl_->SetRegularState(app_moved_to_full, FullNotAudibleState(), false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetFullToAudioAppAppWhileAnotherTypeAudioAppAppIsInFull) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
   am::ApplicationSharedPtr app_in_full = media_app_;
-  NiceMock<MockApplication>* app_in_full_mock = media_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* app_in_full_mock = media_app_ptr_;
 
   am::ApplicationSharedPtr app_moved_to_full = navi_app_;
-  NiceMock<MockApplication>* app_moved_to_full_mock = navi_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock = navi_app_ptr_;
 
   InsertApplication(app_in_full);
   InsertApplication(app_moved_to_full);
@@ -1327,19 +1333,19 @@ TEST_F(StateControllerTest,
 
   ExpectAppChangeHmiStateDueToConflictResolving(
       app_in_full, app_in_full_mock, FullAudibleState(), LimitedState());
-  state_ctrl_.SetRegularState<false>(app_moved_to_full, FullAudibleState());
+  state_ctrl_->SetRegularState(app_moved_to_full, FullAudibleState(), false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetFullToAudioAppAppWhileSameTypeAudioAppAppIsInFull) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
-  NiceMock<MockApplication>* app_in_full_mock;
+  NiceMock<application_manager_test::MockApplication>* app_in_full_mock;
   am::ApplicationSharedPtr app_in_full =
       ConfigureApp(&app_in_full_mock, 1761, MEDIA, NOT_NAVI, NOT_VC);
 
-  NiceMock<MockApplication>* app_moved_to_full_mock;
+  NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock;
   am::ApplicationSharedPtr app_moved_to_full =
       ConfigureApp(&app_moved_to_full_mock, 1796, MEDIA, NOT_NAVI, NOT_VC);
 
@@ -1353,20 +1359,20 @@ TEST_F(StateControllerTest,
   ExpectAppChangeHmiStateDueToConflictResolving(
       app_in_full, app_in_full_mock, FullAudibleState(), BackgroundState());
 
-  state_ctrl_.SetRegularState<false>(app_moved_to_full, FullAudibleState());
+  state_ctrl_->SetRegularState(app_moved_to_full, FullAudibleState(), false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetFullToAudioAppAppWhileSameTypeAudioAppAppIsInLimited) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
-  NiceMock<MockApplication>* app_in_limited_mock;
+  NiceMock<application_manager_test::MockApplication>* app_in_limited_mock;
   am::ApplicationSharedPtr app_in_limited =
       ConfigureApp(&app_in_limited_mock, 1761, NOT_MEDIA, NAVI, NOT_VC);
 
-  NiceMock<MockApplication>* app_moved_to_full_mock;
+  NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock;
   am::ApplicationSharedPtr app_moved_to_full =
       ConfigureApp(&app_moved_to_full_mock, 1796, NOT_MEDIA, NAVI, VC);
 
@@ -1380,19 +1386,19 @@ TEST_F(StateControllerTest,
   ExpectAppChangeHmiStateDueToConflictResolving(
       app_in_limited, app_in_limited_mock, LimitedState(), BackgroundState());
 
-  state_ctrl_.SetRegularState<false>(app_moved_to_full, FullAudibleState());
+  state_ctrl_->SetRegularState(app_moved_to_full, FullAudibleState(), false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetLimitedToAudioAppAppWhileSameTypeAudioAppAppIsInLimited) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
-  NiceMock<MockApplication>* app_in_limited_mock;
+  NiceMock<application_manager_test::MockApplication>* app_in_limited_mock;
   am::ApplicationSharedPtr app_in_limited =
       ConfigureApp(&app_in_limited_mock, 1761, NOT_MEDIA, NOT_NAVI, VC);
 
-  NiceMock<MockApplication>* app_moved_to_limited_mock;
+  NiceMock<application_manager_test::MockApplication>* app_moved_to_limited_mock;
   am::ApplicationSharedPtr app_moved_to_limited =
       ConfigureApp(&app_moved_to_limited_mock, 1796, NOT_MEDIA, NOT_NAVI, VC);
 
@@ -1407,20 +1413,20 @@ TEST_F(StateControllerTest,
   ExpectAppChangeHmiStateDueToConflictResolving(
       app_in_limited, app_in_limited_mock, LimitedState(), BackgroundState());
 
-  state_ctrl_.SetRegularState<false>(app_moved_to_limited, LimitedState());
+  state_ctrl_->SetRegularState(app_moved_to_limited, LimitedState(), false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetLimitedToAudioAppAppWhileOtherTypeAudioAppAppIsInLimited) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
   am::ApplicationSharedPtr app_in_limited = navi_app_;
-  NiceMock<MockApplication>* app_in_limited_mock = navi_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* app_in_limited_mock = navi_app_ptr_;
 
   am::ApplicationSharedPtr app_moved_to_limited = vc_app_;
-  NiceMock<MockApplication>* app_moved_to_limited_mock = vc_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* app_moved_to_limited_mock = vc_app_ptr_;
 
   InsertApplication(app_in_limited);
   InsertApplication(app_moved_to_limited);
@@ -1430,19 +1436,19 @@ TEST_F(StateControllerTest,
                               LimitedState());
   ExpectAppWontChangeHmiStateDueToConflictResolving(
       app_in_limited, app_in_limited_mock, LimitedState());
-  state_ctrl_.SetRegularState<false>(app_moved_to_limited, LimitedState());
+  state_ctrl_->SetRegularState(app_moved_to_limited, LimitedState(), false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetLimitedToAudioAppAppWhileOtherTypeAudioAppAppIsInFull) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
   am::ApplicationSharedPtr app_in_full = navi_app_;
-  NiceMock<MockApplication>* app_in_full_mock = navi_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* app_in_full_mock = navi_app_ptr_;
 
   am::ApplicationSharedPtr app_moved_to_limited = vc_app_;
-  NiceMock<MockApplication>* app_moved_to_limited_mock = vc_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* app_moved_to_limited_mock = vc_app_ptr_;
 
   InsertApplication(app_in_full);
   InsertApplication(app_moved_to_limited);
@@ -1454,22 +1460,22 @@ TEST_F(StateControllerTest,
 
   ExpectAppWontChangeHmiStateDueToConflictResolving(
       app_in_full, app_in_full_mock, FullAudibleState());
-  state_ctrl_.SetRegularState<false>(app_moved_to_limited, LimitedState());
+  state_ctrl_->SetRegularState(app_moved_to_limited, LimitedState(), false);
 }
 
-TEST_F(StateControllerTest, SetFullToSimpleAppWhile2AudioAppsInLimited) {
+TEST_F(StateControllerImplTest, SetFullToSimpleAppWhile2AudioAppsInLimited) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
   am::ApplicationSharedPtr app_moved_to_full = simple_app_;
-  NiceMock<MockApplication>* app_moved_to_full_mock = simple_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock = simple_app_ptr_;
 
   am::ApplicationSharedPtr limited_app1 = media_app_;
-  NiceMock<MockApplication>* limited_app1_mock = media_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* limited_app1_mock = media_app_ptr_;
 
   am::ApplicationSharedPtr limited_app2 = navi_vc_app_;
-  NiceMock<MockApplication>* limited_app2_mock = navi_vc_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* limited_app2_mock = navi_vc_app_ptr_;
 
   InsertApplication(app_moved_to_full);
   InsertApplication(limited_app1);
@@ -1485,23 +1491,23 @@ TEST_F(StateControllerTest, SetFullToSimpleAppWhile2AudioAppsInLimited) {
   ExpectAppWontChangeHmiStateDueToConflictResolving(
       limited_app2, limited_app2_mock, LimitedState());
 
-  state_ctrl_.SetRegularState<false>(app_moved_to_full, FullNotAudibleState());
+  state_ctrl_->SetRegularState(app_moved_to_full, FullNotAudibleState(), false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetFullToSimpleAppWhile1AudioAppInLimitedAnd1AudioAppInFull) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
   am::ApplicationSharedPtr app_moved_to_full = simple_app_;
-  NiceMock<MockApplication>* app_moved_to_full_mock = simple_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock = simple_app_ptr_;
 
   am::ApplicationSharedPtr limited_app = media_app_;
-  NiceMock<MockApplication>* limited_app_mock = media_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* limited_app_mock = media_app_ptr_;
 
   am::ApplicationSharedPtr full_app = navi_vc_app_;
-  NiceMock<MockApplication>* full_app_mock = navi_vc_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* full_app_mock = navi_vc_app_ptr_;
 
   InsertApplication(app_moved_to_full);
   InsertApplication(limited_app);
@@ -1518,23 +1524,23 @@ TEST_F(StateControllerTest,
   ExpectAppChangeHmiStateDueToConflictResolving(
       full_app, full_app_mock, FullAudibleState(), LimitedState());
 
-  state_ctrl_.SetRegularState<false>(app_moved_to_full, FullNotAudibleState());
+  state_ctrl_->SetRegularState(app_moved_to_full, FullNotAudibleState(), false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetFullToSimpleAppWhile1AudioAppInLimitedAnd1SimpleAppInFull) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
-  NiceMock<MockApplication>* app_moved_to_full_mock;
+  NiceMock<application_manager_test::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<MockApplication>* limited_app_mock = media_app_ptr_;
+  NiceMock<application_manager_test::MockApplication>* limited_app_mock = media_app_ptr_;
 
-  NiceMock<MockApplication>* full_app_mock;
+  NiceMock<application_manager_test::MockApplication>* full_app_mock;
   am::ApplicationSharedPtr full_app =
       ConfigureApp(&full_app_mock, 1796, NOT_MEDIA, NOT_NAVI, NOT_VC);
 
@@ -1553,25 +1559,25 @@ TEST_F(StateControllerTest,
   ExpectAppChangeHmiStateDueToConflictResolving(
       full_app, full_app_mock, FullNotAudibleState(), BackgroundState());
 
-  state_ctrl_.SetRegularState<false>(app_moved_to_full, FullNotAudibleState());
+  state_ctrl_->SetRegularState(app_moved_to_full, FullNotAudibleState(), false);
 }
 
 TEST_F(
-    StateControllerTest,
+    StateControllerImplTest,
     SetFullToAudioAppWhile1AudioAppWithSameTypeInLimitedAnd1SimpleAppInFull) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
-  NiceMock<MockApplication>* app_moved_to_full_mock;
+  NiceMock<application_manager_test::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<MockApplication>* limited_app_mock;
+  NiceMock<application_manager_test::MockApplication>* limited_app_mock;
   am::ApplicationSharedPtr limited_app =
       ConfigureApp(&limited_app_mock, 1762, MEDIA, NOT_NAVI, NOT_VC);
 
-  NiceMock<MockApplication>* full_app_mock;
+  NiceMock<application_manager_test::MockApplication>* full_app_mock;
   am::ApplicationSharedPtr full_app =
       ConfigureApp(&full_app_mock, 1796, NOT_MEDIA, NOT_NAVI, NOT_VC);
 
@@ -1590,25 +1596,25 @@ TEST_F(
   ExpectAppChangeHmiStateDueToConflictResolving(
       full_app, full_app_mock, FullNotAudibleState(), BackgroundState());
 
-  state_ctrl_.SetRegularState<false>(app_moved_to_full, FullAudibleState());
+  state_ctrl_->SetRegularState(app_moved_to_full, FullAudibleState(), false);
 }
 
 TEST_F(
-    StateControllerTest,
+    StateControllerImplTest,
     SetFullToAudioAppWhileAudioAppWithSameTypeInLimitedAndAudioAppWithOtherTypeInFull) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
 
-  NiceMock<MockApplication>* app_moved_to_full_mock;
+  NiceMock<application_manager_test::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<MockApplication>* limited_app_mock;
+  NiceMock<application_manager_test::MockApplication>* limited_app_mock;
   am::ApplicationSharedPtr limited_app =
       ConfigureApp(&limited_app_mock, 1762, MEDIA, NOT_NAVI, NOT_VC);
 
-  NiceMock<MockApplication>* full_app_mock;
+  NiceMock<application_manager_test::MockApplication>* full_app_mock;
   am::ApplicationSharedPtr full_app =
       ConfigureApp(&full_app_mock, 1796, NOT_MEDIA, NAVI, NOT_VC);
 
@@ -1627,10 +1633,10 @@ TEST_F(
   ExpectAppChangeHmiStateDueToConflictResolving(
       full_app, full_app_mock, FullAudibleState(), LimitedState());
 
-  state_ctrl_.SetRegularState<false>(app_moved_to_full, FullAudibleState());
+  state_ctrl_->SetRegularState(app_moved_to_full, FullAudibleState(), false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetFullToAudioAppWhile3AudioAppsWithSameTypeInLimited) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
@@ -1650,10 +1656,10 @@ TEST_F(StateControllerTest,
       navi_app_, navi_app_ptr_, LimitedState(), BackgroundState());
   ExpectAppChangeHmiStateDueToConflictResolving(
       vc_app_, vc_app_ptr_, LimitedState(), BackgroundState());
-  state_ctrl_.SetRegularState<false>(media_navi_vc_app_, FullAudibleState());
+  state_ctrl_->SetRegularState(media_navi_vc_app_, FullAudibleState(), false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetFullToAudioAppWhile2AudioAppsWithSameTypeInLimitedAndOneInFull) {
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
@@ -1673,12 +1679,11 @@ TEST_F(StateControllerTest,
       navi_app_, navi_app_ptr_, LimitedState(), BackgroundState());
   ExpectAppChangeHmiStateDueToConflictResolving(
       vc_app_, vc_app_ptr_, FullAudibleState(), BackgroundState());
-  state_ctrl_.SetRegularState<false>(media_navi_vc_app_, FullAudibleState());
+  state_ctrl_->SetRegularState(media_navi_vc_app_, FullAudibleState(), false);
 }
 
-
 // TODO {AKozoriz} Changed logic in state_controller
-TEST_F(StateControllerTest, DISABLED_ActivateAppSuccessReceivedFromHMI) {
+TEST_F(StateControllerImplTest, DISABLED_ActivateAppSuccessReceivedFromHMI) {
   using namespace hmi_apis;
   using namespace mobile_apis;
 
@@ -1706,6 +1711,7 @@ TEST_F(StateControllerTest, DISABLED_ActivateAppSuccessReceivedFromHMI) {
       new smart_objects::SmartObject();
   (*bc_activate_app_request)[am::strings::params][am::strings::correlation_id] =
       corr_id;
+
   for (; it != hmi_states.end(); ++it) {
     am::HmiStatePtr hmi_state = it->first;
     am::HmiStatePtr initial_hmi_state = it->first;
@@ -1721,7 +1727,7 @@ TEST_F(StateControllerTest, DISABLED_ActivateAppSuccessReceivedFromHMI) {
           .WillOnce(Return(media_app_));
       ExpectSuccesfullSetHmiState(
           media_app_, media_app_ptr_, initial_hmi_state, hmi_state);
-      state_ctrl_.SetRegularState<true>(media_app_, hmi_state);
+      state_ctrl_->SetRegularState(media_app_, hmi_state, true);
       smart_objects::SmartObject message;
       message[am::strings::params][am::hmi_response::code] =
           Common_Result::SUCCESS;
@@ -1729,7 +1735,7 @@ TEST_F(StateControllerTest, DISABLED_ActivateAppSuccessReceivedFromHMI) {
       am::event_engine::Event event(
           hmi_apis::FunctionID::BasicCommunication_ActivateApp);
       event.set_smart_object(message);
-      state_ctrl_.on_event(event);
+      state_ctrl_->on_event(event);
   }
 }
 
@@ -1764,7 +1770,7 @@ std::vector<hmi_apis::Common_Result::eType> hmi_result() {
   return hmi_results;
 }
 
-TEST_F(StateControllerTest, SendEventBCActivateApp_HMIReceivesError) {
+TEST_F(StateControllerImplTest, SendEventBCActivateApp_HMIReceivesError) {
   using namespace hmi_apis;
   const uint32_t corr_id = 314;
   const uint32_t hmi_app_id = 2718;
@@ -1791,11 +1797,11 @@ TEST_F(StateControllerTest, SendEventBCActivateApp_HMIReceivesError) {
     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);
+    state_ctrl_->on_event(event);
   }
 }
 
-TEST_F(StateControllerTest, ActivateAppInvalidCorrelationId) {
+TEST_F(StateControllerImplTest, ActivateAppInvalidCorrelationId) {
   using namespace hmi_apis;
   const uint32_t corr_id = 314;
   const uint32_t hmi_app_id = 2718;
@@ -1810,420 +1816,420 @@ TEST_F(StateControllerTest, ActivateAppInvalidCorrelationId) {
   EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(simple_app_->app_id(), _, _))
       .Times(0);
   SetBCActivateAppRequestToHMI(Common_HMILevel::FULL, corr_id);
-  state_ctrl_.SetRegularState<true>(simple_app_, FullNotAudibleState());
+  state_ctrl_->SetRegularState(simple_app_, FullNotAudibleState(), true);
   smart_objects::SmartObject message;
   message[am::strings::params][am::hmi_response::code] = Common_Result::SUCCESS;
   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);
+  state_ctrl_->on_event(event);
 }
 
-TEST_F(StateControllerTest, ApplyTempStatesForSimpleApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForSimpleApp) {
   InsertApplication(simple_app_);
   CheckStateApplyingForApplication(*simple_app_ptr_, valid_state_ids_);
 }
 
-TEST_F(StateControllerTest, ApplyTempStatesForMediaApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForMediaApp) {
   InsertApplication(media_app_);
   CheckStateApplyingForApplication(*media_app_ptr_, valid_state_ids_);
 }
 
-TEST_F(StateControllerTest, ApplyTempStatesForNaviApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForNaviApp) {
   InsertApplication(navi_app_);
   CheckStateApplyingForApplication(*navi_app_ptr_, valid_state_ids_);
 }
 
-TEST_F(StateControllerTest, ApplyTempStatesForVCApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForVCApp) {
   InsertApplication(vc_app_);
   CheckStateApplyingForApplication(*vc_app_ptr_, valid_state_ids_);
 }
 
-TEST_F(StateControllerTest, ApplyTempStatesForMediaNaviApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForMediaNaviApp) {
   InsertApplication(media_navi_app_);
   CheckStateApplyingForApplication(*media_navi_app_ptr_, valid_state_ids_);
 }
 
-TEST_F(StateControllerTest, ApplyTempStatesForMediaVCApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForMediaVCApp) {
   InsertApplication(media_vc_app_);
   CheckStateApplyingForApplication(*media_vc_app_ptr_, valid_state_ids_);
 }
 
-TEST_F(StateControllerTest, ApplyTempStatesForNaviVCApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForNaviVCApp) {
   InsertApplication(navi_vc_app_);
   CheckStateApplyingForApplication(*navi_vc_app_ptr_, valid_state_ids_);
 }
 
-TEST_F(StateControllerTest, ApplyTempStatesForMediaNaviVCApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForMediaNaviVCApp) {
   InsertApplication(media_navi_vc_app_);
   CheckStateApplyingForApplication(*media_navi_vc_app_ptr_, valid_state_ids_);
 }
 
-TEST_F(StateControllerTest, SetStatePhoneCallForNonMediaApplication) {
+TEST_F(StateControllerImplTest, SetStatePhoneCallForNonMediaApplication) {
   am::HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
-      simple_app_id_, &app_manager_mock_);
+      simple_app_id_, app_manager_mock_);
   TestSetState(simple_app_,
                state_phone_call,
                APP_TYPE_NON_MEDIA,
-               &StateControllerTest::PreparePhoneCallHMIStateResults);
+               &StateControllerImplTest::PreparePhoneCallHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetStatePhoneCallForMediaApplication) {
+TEST_F(StateControllerImplTest, SetStatePhoneCallForMediaApplication) {
   am::HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
-      media_app_id_, &app_manager_mock_);
+      media_app_id_, app_manager_mock_);
   TestSetState(media_app_,
                state_phone_call,
                APP_TYPE_MEDIA,
-               &StateControllerTest::PreparePhoneCallHMIStateResults);
+               &StateControllerImplTest::PreparePhoneCallHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetStatePhoneCallForMediaNaviApplication) {
+TEST_F(StateControllerImplTest, SetStatePhoneCallForMediaNaviApplication) {
   am::HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
-      media_navi_app_id_, &app_manager_mock_);
+      media_navi_app_id_, app_manager_mock_);
   TestSetState(media_navi_app_,
                state_phone_call,
                APP_TYPE_NAVI,
-               &StateControllerTest::PreparePhoneCallHMIStateResults);
+               &StateControllerImplTest::PreparePhoneCallHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetVRStateForNonMediaApplication) {
+TEST_F(StateControllerImplTest, SetVRStateForNonMediaApplication) {
   am::HmiStatePtr state_vr =
-      utils::MakeShared<am::VRHmiState>(simple_app_id_, &app_manager_mock_);
+      utils::MakeShared<am::VRHmiState>(simple_app_id_, app_manager_mock_);
   TestSetState(simple_app_,
                state_vr,
                APP_TYPE_NON_MEDIA,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetVRStateForMediaApplication) {
+TEST_F(StateControllerImplTest, SetVRStateForMediaApplication) {
   am::HmiStatePtr state_vr =
-      utils::MakeShared<am::VRHmiState>(media_app_id_, &app_manager_mock_);
+      utils::MakeShared<am::VRHmiState>(media_app_id_, app_manager_mock_);
   TestSetState(media_app_,
                state_vr,
                APP_TYPE_MEDIA,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetVRStateForMediaNaviVoiceApplication) {
+TEST_F(StateControllerImplTest, SetVRStateForMediaNaviVoiceApplication) {
   am::HmiStatePtr state_vr = utils::MakeShared<am::VRHmiState>(
-      media_navi_vc_app_id_, &app_manager_mock_);
+      media_navi_vc_app_id_, app_manager_mock_);
   TestSetState(media_navi_vc_app_,
                state_vr,
                APP_TYPE_MEDIA,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetTTSStateForNonMediaApplicationAttenuatedNotSupported) {
   am::HmiStatePtr state_tts =
-      utils::MakeShared<am::TTSHmiState>(simple_app_id_, &app_manager_mock_);
+      utils::MakeShared<am::TTSHmiState>(simple_app_id_, app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
   TestSetState(simple_app_,
                state_tts,
                APP_TYPE_NON_MEDIA,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetTTSStateForNonMediaApplicationAttenuatedSupported) {
   am::HmiStatePtr state_tts =
-      utils::MakeShared<am::TTSHmiState>(simple_app_id_, &app_manager_mock_);
+      utils::MakeShared<am::TTSHmiState>(simple_app_id_, app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
   TestSetState(simple_app_,
                state_tts,
                APP_TYPE_NON_MEDIA,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetTTSStateForMediaApplicationAttenuatedNotSupported) {
   am::HmiStatePtr state_tts =
-      utils::MakeShared<am::TTSHmiState>(media_app_id_, &app_manager_mock_);
+      utils::MakeShared<am::TTSHmiState>(media_app_id_, app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
   TestSetState(media_app_,
                state_tts,
                APP_TYPE_MEDIA,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetTTSStateForMediaApplicationAttenuatedSupported) {
+TEST_F(StateControllerImplTest, SetTTSStateForMediaApplicationAttenuatedSupported) {
   am::HmiStatePtr state_tts =
-      utils::MakeShared<am::TTSHmiState>(media_app_id_, &app_manager_mock_);
+      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,
                APP_TYPE_ATTENUATED,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetTTSStateForMediaNaviVCApplicationAttenuatedNotSupported) {
   am::HmiStatePtr state_tts = utils::MakeShared<am::TTSHmiState>(
-      media_navi_vc_app_id_, &app_manager_mock_);
+      media_navi_vc_app_id_, app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
   TestSetState(media_navi_vc_app_,
                state_tts,
                APP_TYPE_MEDIA,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetTTSStateForMediaNaviVCApplicationAttenuatedSupported) {
   am::HmiStatePtr state_tts = utils::MakeShared<am::TTSHmiState>(
-      media_navi_vc_app_id_, &app_manager_mock_);
+      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,
                APP_TYPE_ATTENUATED,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetNaviStreamingStateForNonMediaApplication) {
+TEST_F(StateControllerImplTest, SetNaviStreamingStateForNonMediaApplication) {
   am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(simple_app_id_,
-                                                   &app_manager_mock_);
+                                                   app_manager_mock_);
   TestSetState(simple_app_,
                state_navi_streming,
                APP_TYPE_NON_MEDIA,
-               &StateControllerTest::PrepareNaviStreamingHMIStateResults);
+               &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetNaviStreamingStateMediaApplicationAttenuatedNotSupported) {
   am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(media_app_id_,
-                                                   &app_manager_mock_);
+                                                   app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
   TestSetState(media_app_,
                state_navi_streming,
                APP_TYPE_MEDIA,
-               &StateControllerTest::PrepareNaviStreamingHMIStateResults);
+               &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetNaviStreamingStateMediaApplicationAttenuatedSupported) {
   am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(media_app_id_,
-                                                   &app_manager_mock_);
+                                                   app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
   TestSetState(media_app_,
                state_navi_streming,
                APP_TYPE_ATTENUATED,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetNaviStreamingStateVCApplicationAttenuatedNotSupported) {
   am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(vc_app_id_,
-                                                   &app_manager_mock_);
+                                                   app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
   TestSetState(vc_app_,
                state_navi_streming,
                APP_TYPE_MEDIA,
-               &StateControllerTest::PrepareNaviStreamingHMIStateResults);
+               &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetNaviStreamingStateVCApplicationAttenuatedSupported) {
   am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(vc_app_id_,
-                                                   &app_manager_mock_);
+                                                   app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
   TestSetState(vc_app_,
                state_navi_streming,
                APP_TYPE_ATTENUATED,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetNaviStreamingStateNaviApplication) {
+TEST_F(StateControllerImplTest, SetNaviStreamingStateNaviApplication) {
   am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(navi_app_id_,
-                                                   &app_manager_mock_);
+                                                   app_manager_mock_);
   TestSetState(navi_app_,
                state_navi_streming,
                APP_TYPE_NAVI,
-               &StateControllerTest::PrepareNaviStreamingHMIStateResults);
+               &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetNaviStreamingStateMediaNaviApplication) {
+TEST_F(StateControllerImplTest, SetNaviStreamingStateMediaNaviApplication) {
   am::HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(media_navi_app_id_,
-                                                   &app_manager_mock_);
+                                                   app_manager_mock_);
   TestSetState(media_navi_app_,
                state_navi_streming,
                APP_TYPE_NAVI,
-               &StateControllerTest::PrepareNaviStreamingHMIStateResults);
+               &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetSafetyModeStateForNonMediaApplication) {
+TEST_F(StateControllerImplTest, SetSafetyModeStateForNonMediaApplication) {
   am::HmiStatePtr state_safety_mode = utils::MakeShared<am::SafetyModeHmiState>(
-      simple_app_id_, &app_manager_mock_);
+      simple_app_id_, app_manager_mock_);
   TestSetState(simple_app_,
                state_safety_mode,
                APP_TYPE_NON_MEDIA,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetSafetyModeStateForMediaApplication) {
+TEST_F(StateControllerImplTest, SetSafetyModeStateForMediaApplication) {
   am::HmiStatePtr state_safety_mode =
-      utils::MakeShared<am::VRHmiState>(media_app_id_, &app_manager_mock_);
+      utils::MakeShared<am::VRHmiState>(media_app_id_, app_manager_mock_);
   TestSetState(media_app_,
                state_safety_mode,
                APP_TYPE_MEDIA,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetSafetyModeStateForMediaNaviVoiceApplication) {
+TEST_F(StateControllerImplTest, SetSafetyModeStateForMediaNaviVoiceApplication) {
   am::HmiStatePtr state_safety_mode = utils::MakeShared<am::VRHmiState>(
-      media_navi_vc_app_id_, &app_manager_mock_);
+      media_navi_vc_app_id_, app_manager_mock_);
   TestSetState(media_navi_vc_app_,
                state_safety_mode,
                APP_TYPE_MEDIA,
-               &StateControllerTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixVRWithPhoneCall) {
+TEST_F(StateControllerImplTest, MixVRWithPhoneCall) {
   TestMixState<am::PhoneCallHmiState, am::VRHmiState>(
-      &StateControllerTest::PreparePhoneCallHMIStateResults);
+      &StateControllerImplTest::PreparePhoneCallHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixTTSWithPhoneCallAttenuatedNotSupported) {
+TEST_F(StateControllerImplTest, MixTTSWithPhoneCallAttenuatedNotSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
 
   TestMixState<am::PhoneCallHmiState, am::TTSHmiState>(
-      &StateControllerTest::PreparePhoneCallHMIStateResults);
+      &StateControllerImplTest::PreparePhoneCallHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixTTSWithPhoneCallAttenuatedSupported) {
+TEST_F(StateControllerImplTest, MixTTSWithPhoneCallAttenuatedSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
 
   TestMixState<am::PhoneCallHmiState, am::TTSHmiState>(
-      &StateControllerTest::PreparePhoneCallHMIStateResults);
+      &StateControllerImplTest::PreparePhoneCallHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        MixNaviStreamingWithPhoneCallAttenuatedNotSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
 
   TestMixState<am::PhoneCallHmiState, am::NaviStreamingHmiState>(
-      &StateControllerTest::PreparePhoneCallHMIStateResults);
+      &StateControllerImplTest::PreparePhoneCallHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixNaviStreamingWithPhoneCallAttenuatedSupported) {
+TEST_F(StateControllerImplTest, MixNaviStreamingWithPhoneCallAttenuatedSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
 
   TestMixState<am::PhoneCallHmiState, am::NaviStreamingHmiState>(
-      &StateControllerTest::PreparePhoneCallHMIStateResults);
+      &StateControllerImplTest::PreparePhoneCallHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixSafetyModeWithPhoneCall) {
+TEST_F(StateControllerImplTest, MixSafetyModeWithPhoneCall) {
   TestMixState<am::PhoneCallHmiState, am::SafetyModeHmiState>(
-      &StateControllerTest::PreparePhoneCallHMIStateResults);
+      &StateControllerImplTest::PreparePhoneCallHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixTTSWithVRAttenuatedNotSupported) {
+TEST_F(StateControllerImplTest, MixTTSWithVRAttenuatedNotSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
 
   TestMixState<am::VRHmiState, am::TTSHmiState>(
-      &StateControllerTest::PrepareVRTTSHMIStateResults);
+      &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixTTSWithVRAttenuatedSupported) {
+TEST_F(StateControllerImplTest, MixTTSWithVRAttenuatedSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
 
   TestMixState<am::VRHmiState, am::TTSHmiState>(
-      &StateControllerTest::PrepareVRTTSHMIStateResults);
+      &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixNaviStreamingWithVRAttenuatedNotSupported) {
+TEST_F(StateControllerImplTest, MixNaviStreamingWithVRAttenuatedNotSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
 
   TestMixState<am::VRHmiState, am::NaviStreamingHmiState>(
-      &StateControllerTest::PrepareVRTTSHMIStateResults);
+      &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixNaviStreamingWithVRAttenuatedSupported) {
+TEST_F(StateControllerImplTest, MixNaviStreamingWithVRAttenuatedSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
 
   TestMixState<am::VRHmiState, am::NaviStreamingHmiState>(
-      &StateControllerTest::PrepareVRTTSHMIStateResults);
+      &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixSafetyModeStreamingWithVR) {
+TEST_F(StateControllerImplTest, MixSafetyModeStreamingWithVR) {
   TestMixState<am::VRHmiState, am::SafetyModeHmiState>(
-      &StateControllerTest::PrepareVRTTSHMIStateResults);
+      &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixNaviStreamingWithTTSAttenueatedNotSupported) {
+TEST_F(StateControllerImplTest, MixNaviStreamingWithTTSAttenueatedNotSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
 
   TestMixState<am::TTSHmiState, am::NaviStreamingHmiState>(
-      &StateControllerTest::PrepareVRTTSHMIStateResults);
+      &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixNaviStreamingWithTTSAttenueatedSupported) {
+TEST_F(StateControllerImplTest, MixNaviStreamingWithTTSAttenueatedSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
 
   TestMixState<am::TTSHmiState, am::NaviStreamingHmiState>(
-      &StateControllerTest::PrepareNaviStreamTTSStateResult);
+      &StateControllerImplTest::PrepareNaviStreamTTSStateResult);
 }
 
-TEST_F(StateControllerTest, MixSafetyModeWithTTSAttenueatedNotSupported) {
+TEST_F(StateControllerImplTest, MixSafetyModeWithTTSAttenueatedNotSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
 
   TestMixState<am::TTSHmiState, am::SafetyModeHmiState>(
-      &StateControllerTest::PrepareVRTTSHMIStateResults);
+      &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, MixSafetyModeWithTTSAttenueatedSupported) {
+TEST_F(StateControllerImplTest, MixSafetyModeWithTTSAttenueatedSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
 
   TestMixState<am::TTSHmiState, am::SafetyModeHmiState>(
-      &StateControllerTest::PrepareVRTTSHMIStateResults);
+      &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        MixSafetyModeWithNaviStreamingAttenueatedNotSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
 
   TestMixState<am::SafetyModeHmiState, am::NaviStreamingHmiState>(
-      &StateControllerTest::PrepareVRTTSHMIStateResults);
+      &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        MixSafetyModeWithNaviStreamingAttenueatedSupported) {
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
 
   TestMixState<am::SafetyModeHmiState, am::NaviStreamingHmiState>(
-      &StateControllerTest::PrepareVRTTSHMIStateResults);
+      &StateControllerImplTest::PrepareVRTTSHMIStateResults);
 }
 
-TEST_F(StateControllerTest, SetRegularStateWithNewHmiLvl) {
+TEST_F(StateControllerImplTest, SetRegularStateWithNewHmiLvl) {
   using namespace mobile_apis;
 
   HMILevel::eType set_lvl = HMILevel::HMI_NONE;
@@ -2234,7 +2240,7 @@ TEST_F(StateControllerTest, SetRegularStateWithNewHmiLvl) {
       .WillOnce(Return(BackgroundState()))
       .WillOnce(Return(BackgroundState()));
 
-  state_ctrl_.SetRegularState(simple_app_, set_lvl);
+  state_ctrl_->SetRegularState(simple_app_, set_lvl);
 
   set_lvl = HMILevel::HMI_LIMITED;
   EXPECT_CALL(*simple_app_ptr_, RegularHmiState())
@@ -2243,7 +2249,7 @@ TEST_F(StateControllerTest, SetRegularStateWithNewHmiLvl) {
   EXPECT_CALL(*simple_app_ptr_, CurrentHmiState())
       .WillOnce(Return(BackgroundState()))
       .WillOnce(Return(BackgroundState()));
-  state_ctrl_.SetRegularState(simple_app_, set_lvl);
+  state_ctrl_->SetRegularState(simple_app_, set_lvl);
 
   set_lvl = HMILevel::HMI_FULL;
   EXPECT_CALL(*simple_app_ptr_, RegularHmiState())
@@ -2252,7 +2258,7 @@ TEST_F(StateControllerTest, SetRegularStateWithNewHmiLvl) {
   const uint32_t corr_id = 314;
   SetBCActivateAppRequestToHMI(static_cast<hmi_apis::Common_HMILevel::eType>(set_lvl), corr_id);
 
-  state_ctrl_.SetRegularState(simple_app_, set_lvl);
+  state_ctrl_->SetRegularState(simple_app_, set_lvl);
 
   set_lvl = HMILevel::HMI_BACKGROUND;
   EXPECT_CALL(*simple_app_ptr_, RegularHmiState())
@@ -2262,10 +2268,10 @@ TEST_F(StateControllerTest, SetRegularStateWithNewHmiLvl) {
       .WillOnce(Return(BackgroundState()))
       .WillOnce(Return(BackgroundState()));
 
-  state_ctrl_.SetRegularState(simple_app_, set_lvl);
+  state_ctrl_->SetRegularState(simple_app_, set_lvl);
 }
 
-TEST_F(StateControllerTest, SetRegularStateWithAudioStateAudible) {
+TEST_F(StateControllerImplTest, SetRegularStateWithAudioStateAudible) {
   using namespace mobile_apis;
 
   HmiStatePtr check_state = createHmiState(HMILevel::HMI_BACKGROUND,
@@ -2280,16 +2286,16 @@ TEST_F(StateControllerTest, SetRegularStateWithAudioStateAudible) {
   EXPECT_CALL(*simple_app_ptr_,
               SetRegularState(Truly(HmiStatesComparator(check_state))));
 
-  state_ctrl_.SetRegularState(simple_app_, AudioStreamingState::AUDIBLE);
+  state_ctrl_->SetRegularState(simple_app_, AudioStreamingState::AUDIBLE);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetRegularStateToMediaAndNonMediaApps_VRStarted_SetPostponedState) {
   using namespace mobile_apis;
 
   // Precondition
   am::event_engine::Event event(hmi_apis::FunctionID::VR_Started);
-  state_ctrl_.on_event(event);
+  state_ctrl_->on_event(event);
 
   HmiStatePtr check_state = FullNotAudibleState();
 
@@ -2303,7 +2309,7 @@ TEST_F(StateControllerTest,
       .WillRepeatedly(Return(am::ApplicationSharedPtr()));
   EXPECT_CALL(*simple_app_ptr_,
               SetPostponedState(Truly(HmiStatesComparator(check_state))));
-  state_ctrl_.SetRegularState<false>(simple_app_, check_state);
+  state_ctrl_->SetRegularState(simple_app_, check_state, false);
 
   check_state = LimitedState();
   EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
@@ -2311,18 +2317,18 @@ TEST_F(StateControllerTest,
   EXPECT_CALL(*media_app_ptr_, SetRegularState(_)).Times(0);
   EXPECT_CALL(*media_app_ptr_,
               SetPostponedState(Truly(HmiStatesComparator(check_state))));
-  state_ctrl_.SetRegularState<false>(media_app_, check_state);
+  state_ctrl_->SetRegularState(media_app_, check_state, false);
 }
 
-TEST_F(StateControllerTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) {
+TEST_F(StateControllerImplTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) {
   using namespace mobile_apis;
 
   // Precondition
   am::event_engine::Event prev_event(hmi_apis::FunctionID::VR_Started);
-  state_ctrl_.on_event(prev_event);
+  state_ctrl_->on_event(prev_event);
 
   am::event_engine::Event next_event(hmi_apis::FunctionID::VR_Stopped);
-  state_ctrl_.on_event(next_event);
+  state_ctrl_->on_event(next_event);
 
   // Set state of non-media app after vr has stopped
   HmiStatePtr check_state = FullNotAudibleState();
@@ -2335,13 +2341,13 @@ TEST_F(StateControllerTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) {
   EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(false));
 
   EXPECT_CALL(*message_helper_mock_,
-              SendOnResumeAudioSourceToHMI(simple_app_id_)).Times(0);
+              SendOnResumeAudioSourceToHMI(simple_app_id_, _)).Times(0);
   EXPECT_CALL(*simple_app_ptr_,
               SetPostponedState(Truly(HmiStatesComparator(check_state))))
       .Times(0);
   EXPECT_CALL(*simple_app_ptr_,
               SetRegularState(Truly(HmiStatesComparator(check_state))));
-  state_ctrl_.SetRegularState<false>(simple_app_, check_state);
+  state_ctrl_->SetRegularState(simple_app_, check_state, false);
 
   // Set state of media app after vr has stopped
   check_state = LimitedState();
@@ -2353,16 +2359,16 @@ TEST_F(StateControllerTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) {
   EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
 
   EXPECT_CALL(*message_helper_mock_,
-              SendOnResumeAudioSourceToHMI(media_app_id_));
+              SendOnResumeAudioSourceToHMI(media_app_id_, _));
   EXPECT_CALL(*media_app_ptr_,
               SetPostponedState(Truly(HmiStatesComparator(check_state))))
       .Times(0);
   EXPECT_CALL(*media_app_ptr_,
               SetRegularState(Truly(HmiStatesComparator(check_state))));
-  state_ctrl_.SetRegularState<false>(media_app_, check_state);
+  state_ctrl_->SetRegularState(media_app_, check_state, false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetRegStateForMediaAndNonMediaApps_OnEmergencyEvent_SetPostponedState) {
   using namespace hmi_apis;
   using namespace smart_objects;
@@ -2376,7 +2382,7 @@ TEST_F(StateControllerTest,
       Common_EventTypes::EMERGENCY_EVENT;
 
   event.set_smart_object(message);
-  state_ctrl_.on_event(event);
+  state_ctrl_->on_event(event);
 
   // Non-media app can't have LIMITED-AUDIO state
   HmiStatePtr check_state = FullNotAudibleState();
@@ -2391,7 +2397,7 @@ TEST_F(StateControllerTest,
       .WillRepeatedly(Return(am::ApplicationSharedPtr()));
   EXPECT_CALL(*simple_app_ptr_,
               SetPostponedState(Truly(HmiStatesComparator(check_state))));
-  state_ctrl_.SetRegularState<false>(simple_app_, check_state);
+  state_ctrl_->SetRegularState(simple_app_, check_state, false);
 
   // Set media app
   check_state = LimitedState();
@@ -2403,10 +2409,10 @@ TEST_F(StateControllerTest,
 
   EXPECT_CALL(*media_app_ptr_,
               SetPostponedState(Truly(HmiStatesComparator(check_state))));
-  state_ctrl_.SetRegularState<false>(media_app_, check_state);
+  state_ctrl_->SetRegularState(media_app_, check_state, false);
 }
 
-TEST_F(StateControllerTest,
+TEST_F(StateControllerImplTest,
        SetStateForMediaApp_BCOnPhoneCall_SetPostponedState) {
   using namespace hmi_apis;
   using namespace smart_objects;
@@ -2420,7 +2426,7 @@ TEST_F(StateControllerTest,
       hmi_apis::Common_EventTypes::PHONE_CALL;
 
   event.set_smart_object(message);
-  state_ctrl_.on_event(event);
+  state_ctrl_->on_event(event);
 
   am::HmiStatePtr check_state = FullAudibleState();
 
@@ -2437,7 +2443,7 @@ TEST_F(StateControllerTest,
 
   EXPECT_CALL(*media_app_ptr_,
               SetPostponedState(Truly(HmiStatesComparator(check_state))));
-  state_ctrl_.SetRegularState<false>(media_app_, check_state);
+  state_ctrl_->SetRegularState(media_app_, check_state, false);
 }
 
 }  // namespace state_controller_test
diff --git a/src/components/application_manager/test/usage_statistics_test.cc b/src/components/application_manager/test/usage_statistics_test.cc
index dc72890769..88406e02e9 100644
--- a/src/components/application_manager/test/usage_statistics_test.cc
+++ b/src/components/application_manager/test/usage_statistics_test.cc
@@ -34,7 +34,7 @@
 #include <memory>
 #include "gmock/gmock.h"
 #include "smart_objects/enum_schema_item.h"
-#include "mock_statistics_manager.h"
+#include "policy/mock_statistics_manager.h"
 #include "mock_app_stopwatch.h"
 #include "utils/make_shared.h"
 #include "utils/shared_ptr.h"
diff --git a/src/components/application_manager/test/zero_request_amount_test.cc b/src/components/application_manager/test/zero_request_amount_test.cc
index 11c9abc03c..2cc85314be 100644
--- a/src/components/application_manager/test/zero_request_amount_test.cc
+++ b/src/components/application_manager/test/zero_request_amount_test.cc
@@ -33,7 +33,7 @@
 #include <string>
 #include <algorithm>
 #include "gtest/gtest.h"
-#include "config_profile/profile.h"
+
 #include "application_manager/request_controller.h"
 #include "application_manager/commands/command_request_impl.h"
 #include "application_manager/application_manager_impl.h"
@@ -89,10 +89,6 @@ commands::Command* PutFileCommand(uint32_t &correlation_id,
 
 TEST(RequestControlTest, ZeroValuePendingRequestsAmount) {
   // Default value
-  uint32_t pending_requests_amount = 0;
-  EXPECT_EQ(pending_requests_amount,
-            Profile::instance()->pending_requests_amount());
-
   const uint32_t big_count_of_requests_for_test_ = 10;  //bigger than pending_requests_amount
   uint32_t correlation_id = 0;
   uint32_t connection_key = 0;
@@ -117,9 +113,6 @@ TEST(RequestControlTest, ZeroValuePendingRequestsAmount) {
 
 TEST(RequestControlTest, ZeroValueAppRequestsTimeScale) {
   // Default value
-  uint32_t app_requests_time_scale = 0;
-  EXPECT_EQ(app_requests_time_scale, Profile::instance()->app_time_scale());
-
   const uint32_t big_count_of_requests_for_test_ = 10;  //bigger than pending_requests_amount
   uint32_t correlation_id = 0;
   uint32_t connection_key = 0;
@@ -145,10 +138,6 @@ TEST(RequestControlTest, ZeroValueAppRequestsTimeScale) {
 
 TEST(RequestControlTest, ZeroValueAppTimeScaleMaxRequests) {
   // Default value
-  uint32_t app_time_scale_max_requests = 0;
-  EXPECT_EQ(app_time_scale_max_requests,
-            Profile::instance()->app_time_scale_max_requests());
-
   const uint32_t big_count_of_requests_for_test_ = 10;  //bigger than pending_requests_amount
   uint32_t correlation_id = 0;
   uint32_t connection_key = 0;