ApplicationManager tests correctives

	After singletones removing

14 files changed, 1273 insertions, 74 deletions

diff --git a/src/components/application_manager/test/CMakeLists.txt b/src/components/application_manager/test/CMakeLists.txt
index db5fd25660..423b908408 100644
--- a/src/components/application_manager/test/CMakeLists.txt
+++ b/src/components/application_manager/test/CMakeLists.txt
@@ -68,6 +68,7 @@ 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/
diff --git a/src/components/application_manager/test/hmi_capabilities_test.cc b/src/components/application_manager/test/hmi_capabilities_test.cc
new file mode 100644
index 0000000000..19dc0c8caf
--- /dev/null
+++ b/src/components/application_manager/test/hmi_capabilities_test.cc
@@ -0,0 +1,511 @@
+/*
+ * 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/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"
+#include "interfaces/HMI_API.h"
+#include "utils/make_shared.h"
+#include "application_manager/hmi_capabilities_for_testing.h"
+#include "utils/file_system.h"
+
+namespace test {
+namespace components {
+namespace application_manager_test {
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::AtLeast;
+using ::testing::Invoke;
+using ::testing::InSequence;
+
+namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
+using namespace application_manager;
+
+class HMICapabilitiesTest : public ::testing::Test {
+ protected:
+  HMICapabilitiesTest():
+     last_state_("app_storage_folder", "app_info_data")  {}
+  virtual void SetUp() OVERRIDE {
+    app_mngr_ = ApplicationManagerImpl::instance();
+    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() {
+    if (file_system::FileExists("./app_info_data")) {
+      EXPECT_TRUE(::file_system::DeleteFile("./app_info_data"));
+    }
+  }
+
+  void SetCooperating();
+  ApplicationManagerImpl* app_mngr_;
+  utils::SharedPtr<HMICapabilitiesForTesting> hmi_capabilities_test;
+  resumption::LastState last_state_;
+
+};
+
+const char* const cstring_values_[] = {
+    "EN_US", "ES_MX", "FR_CA", "DE_DE", "ES_ES", "EN_GB", "RU_RU", "TR_TR",
+    "PL_PL", "FR_FR", "IT_IT", "SV_SE", "PT_PT", "NL_NL", "EN_AU", "ZH_CN",
+    "ZH_TW", "JA_JP", "AR_SA", "KO_KR", "PT_BR", "CS_CZ", "DA_DK", "NO_NO",
+    "NL_BE", "EL_GR", "HU_HU", "FI_FI", "SK_SK"};
+
+const hmi_apis::Common_Language::eType enum_values_[] = {
+    hmi_apis::Common_Language::EN_US, hmi_apis::Common_Language::ES_MX,
+    hmi_apis::Common_Language::FR_CA, hmi_apis::Common_Language::DE_DE,
+    hmi_apis::Common_Language::ES_ES, hmi_apis::Common_Language::EN_GB,
+    hmi_apis::Common_Language::RU_RU, hmi_apis::Common_Language::TR_TR,
+    hmi_apis::Common_Language::PL_PL, hmi_apis::Common_Language::FR_FR,
+    hmi_apis::Common_Language::IT_IT, hmi_apis::Common_Language::SV_SE,
+    hmi_apis::Common_Language::PT_PT, hmi_apis::Common_Language::NL_NL,
+    hmi_apis::Common_Language::EN_AU, hmi_apis::Common_Language::ZH_CN,
+    hmi_apis::Common_Language::ZH_TW, hmi_apis::Common_Language::JA_JP,
+    hmi_apis::Common_Language::AR_SA, hmi_apis::Common_Language::KO_KR,
+    hmi_apis::Common_Language::PT_BR, hmi_apis::Common_Language::CS_CZ,
+    hmi_apis::Common_Language::DA_DK, hmi_apis::Common_Language::NO_NO,
+    hmi_apis::Common_Language::NL_BE, hmi_apis::Common_Language::EL_GR,
+    hmi_apis::Common_Language::HU_HU, hmi_apis::Common_Language::FI_FI,
+    hmi_apis::Common_Language::SK_SK};
+
+struct CStringComparator {
+  bool operator()(const char* a, const char* b) {
+    return strcmp(a, b) < 0;
+  }
+};
+
+typedef std::map<const char*,
+                 hmi_apis::Common_Language::eType,
+                 CStringComparator> CStringToEnumMap;
+
+CStringToEnumMap InitCStringToEnumMap() {
+  size_t value = sizeof(cstring_values_) / sizeof(cstring_values_[0]);
+  CStringToEnumMap result;
+  for (size_t i = 0; i < value; ++i) {
+    result[cstring_values_[i]] = enum_values_[i];
+  }
+  return result;
+}
+
+bool StringToEnum(const char* str, hmi_apis::Common_Language::eType& value) {
+  size_t count_value = sizeof(cstring_values_) / sizeof(cstring_values_[0]);
+  CStringToEnumMap result;
+  for (size_t i = 0; i < count_value; ++i) {
+    result[cstring_values_[i]] = enum_values_[i];
+  }
+
+  CStringToEnumMap::const_iterator it = result.find(str);
+  if (it == result.end()) {
+    return false;
+  }
+  value = it->second;
+  return true;
+}
+
+hmi_apis::Common_Language::eType TestCommonLanguageFromString(
+    const std::string& language) {
+  hmi_apis::Common_Language::eType value;
+  if (StringToEnum(language.c_str(), value)) {
+    return value;
+  }
+  return hmi_apis::Common_Language::INVALID_ENUM;
+}
+
+TEST_F(HMICapabilitiesTest, LoadCapabilitiesFromFile) {
+  EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
+              CommonLanguageFromString(_))
+      .WillRepeatedly(Invoke(TestCommonLanguageFromString));
+
+  if (file_system::FileExists("./app_info_data")) {
+     EXPECT_TRUE(::file_system::DeleteFile("./app_info_data"));
+   }
+  EXPECT_TRUE(hmi_capabilities_test->LoadCapabilitiesFromFile());
+
+
+  // Check active languages
+  EXPECT_EQ(hmi_apis::Common_Language::EN_US,
+            hmi_capabilities_test->active_ui_language());
+  EXPECT_EQ(hmi_apis::Common_Language::ES_MX,
+            hmi_capabilities_test->active_vr_language());
+  EXPECT_EQ(hmi_apis::Common_Language::DE_DE,
+            hmi_capabilities_test->active_tts_language());
+
+  // Check UI languages
+  const smart_objects::SmartObject ui_supported_languages =
+      *(hmi_capabilities_test->ui_supported_languages());
+
+  EXPECT_EQ(hmi_apis::Common_Language::EN_US,
+            static_cast<hmi_apis::Common_Language::eType>(
+                ui_supported_languages[0].asInt()));
+  EXPECT_EQ(hmi_apis::Common_Language::ES_MX,
+            static_cast<hmi_apis::Common_Language::eType>(
+                ui_supported_languages[1].asInt()));
+  EXPECT_EQ(hmi_apis::Common_Language::FR_CA,
+            static_cast<hmi_apis::Common_Language::eType>(
+                ui_supported_languages[2].asInt()));
+
+  // Check VR languages
+  const smart_objects::SmartObject vr_supported_languages =
+      *(hmi_capabilities_test->vr_supported_languages());
+
+  EXPECT_EQ(hmi_apis::Common_Language::AR_SA,
+            static_cast<hmi_apis::Common_Language::eType>(
+                vr_supported_languages[0].asInt()));
+  EXPECT_EQ(hmi_apis::Common_Language::EN_US,
+            static_cast<hmi_apis::Common_Language::eType>(
+                vr_supported_languages[1].asInt()));
+  EXPECT_EQ(hmi_apis::Common_Language::ES_MX,
+            static_cast<hmi_apis::Common_Language::eType>(
+                vr_supported_languages[2].asInt()));
+
+  // Check TTS languages
+  const smart_objects::SmartObject tts_supported_languages =
+      *(hmi_capabilities_test->tts_supported_languages());
+
+  EXPECT_EQ(hmi_apis::Common_Language::DA_DK,
+            static_cast<hmi_apis::Common_Language::eType>(
+                tts_supported_languages[0].asInt()));
+  EXPECT_EQ(hmi_apis::Common_Language::CS_CZ,
+            static_cast<hmi_apis::Common_Language::eType>(
+                tts_supported_languages[1].asInt()));
+  EXPECT_EQ(hmi_apis::Common_Language::KO_KR,
+            static_cast<hmi_apis::Common_Language::eType>(
+                tts_supported_languages[2].asInt()));
+
+  // Check button capabilities
+  const smart_objects::SmartObject buttons_capabilities_so =
+      *(hmi_capabilities_test->button_capabilities());
+
+  // Count of buttons in json file
+  const uint32_t btn_length = buttons_capabilities_so.length();
+  EXPECT_EQ(15u, btn_length);
+  for (uint32_t i = 0; i < btn_length; ++i) {
+    EXPECT_TRUE((buttons_capabilities_so[i]).keyExists(strings::name));
+    EXPECT_TRUE((buttons_capabilities_so[i]).keyExists("shortPressAvailable"));
+    EXPECT_TRUE((buttons_capabilities_so[i]).keyExists("longPressAvailable"));
+    EXPECT_TRUE((buttons_capabilities_so[i]).keyExists("upDownAvailable"));
+    EXPECT_TRUE(buttons_capabilities_so[i]["shortPressAvailable"].asBool());
+    EXPECT_TRUE(buttons_capabilities_so[i]["longPressAvailable"].asBool());
+    EXPECT_TRUE(buttons_capabilities_so[i]["upDownAvailable"].asBool());
+  }
+  const smart_objects::SmartObject display_capabilities_so =
+      *(hmi_capabilities_test->display_capabilities());
+
+  // Check display type
+  EXPECT_EQ(hmi_apis::Common_DisplayType::GEN2_8_DMA,
+            static_cast<hmi_apis::Common_DisplayType::eType>(
+                display_capabilities_so[hmi_response::display_type].asInt()));
+
+  EXPECT_TRUE(display_capabilities_so["graphicSupported"].asBool());
+
+  // Check text fields
+  const uint32_t text_len =
+      display_capabilities_so[hmi_response::text_fields].length();
+  EXPECT_NE(0u, text_len);
+  for (uint32_t i = 0; i < text_len; ++i) {
+    EXPECT_TRUE((display_capabilities_so[hmi_response::text_fields][i])
+                    .keyExists(strings::name));
+    EXPECT_TRUE((display_capabilities_so[hmi_response::text_fields][i])
+                    .keyExists(strings::character_set));
+  }
+
+  // Check image fields
+  EXPECT_TRUE((display_capabilities_so).keyExists(hmi_response::image_fields));
+  const uint32_t img_len =
+      display_capabilities_so[hmi_response::image_fields].length();
+  EXPECT_NE(0u, img_len);
+  for (uint32_t i = 0; i < img_len; ++i) {
+    EXPECT_TRUE((display_capabilities_so[hmi_response::image_fields][i])
+                    .keyExists(strings::name));
+    EXPECT_TRUE((display_capabilities_so[hmi_response::image_fields][i])
+                    .keyExists(strings::image_type_supported));
+    if (display_capabilities_so[hmi_response::image_fields][i][strings::name] ==
+        hmi_apis::Common_ImageFieldName::locationImage) {
+      EXPECT_EQ(hmi_apis::Common_FileType::GRAPHIC_PNG,
+                static_cast<hmi_apis::Common_FileType::eType>(
+                    display_capabilities_so[hmi_response::image_fields][i]
+                                           [strings::image_type_supported][0]
+                                               .asInt()));
+    }
+  }
+
+  // Check media clock formats
+  EXPECT_TRUE(
+      (display_capabilities_so).keyExists(hmi_response::media_clock_formats));
+  const uint32_t media_length =
+      display_capabilities_so[hmi_response::media_clock_formats].length();
+  EXPECT_NE(0u, media_length);
+  for (uint32_t i = 0; i < media_length; ++i) {
+    EXPECT_EQ(
+        i,
+        display_capabilities_so[hmi_response::media_clock_formats][i].asUInt());
+  }
+
+  EXPECT_TRUE(
+      (display_capabilities_so).keyExists(hmi_response::image_capabilities));
+  EXPECT_EQ(hmi_apis::Common_ImageType::DYNAMIC,
+            static_cast<hmi_apis::Common_ImageType::eType>(
+                display_capabilities_so[hmi_response::image_capabilities][0]
+                    .asInt()));
+  EXPECT_EQ(hmi_apis::Common_ImageType::STATIC,
+            static_cast<hmi_apis::Common_ImageType::eType>(
+                display_capabilities_so[hmi_response::image_capabilities][1]
+                    .asInt()));
+
+  // Check audio pass thru
+  const smart_objects::SmartObject audio_pass_thru_capabilities_so =
+      *(hmi_capabilities_test->audio_pass_thru_capabilities());
+  EXPECT_EQ(hmi_apis::Common_SamplingRate::RATE_44KHZ,
+            static_cast<hmi_apis::Common_SamplingRate::eType>(
+                audio_pass_thru_capabilities_so["samplingRate"].asInt()));
+  EXPECT_EQ(hmi_apis::Common_BitsPerSample::RATE_8_BIT,
+            static_cast<hmi_apis::Common_BitsPerSample::eType>(
+                audio_pass_thru_capabilities_so["bitsPerSample"].asInt()));
+  EXPECT_EQ(hmi_apis::Common_AudioType::PCM,
+            static_cast<hmi_apis::Common_AudioType::eType>(
+                audio_pass_thru_capabilities_so["audioType"].asInt()));
+
+  // Check hmi zone capabilities
+  const smart_objects::SmartObject hmi_zone_capabilities_so =
+      *(hmi_capabilities_test->hmi_zone_capabilities());
+  EXPECT_EQ(hmi_apis::Common_HmiZoneCapabilities::FRONT,
+            static_cast<hmi_apis::Common_HmiZoneCapabilities::eType>(
+                hmi_zone_capabilities_so.asInt()));
+
+  const smart_objects::SmartObject soft_button_capabilities_so =
+      *(hmi_capabilities_test->soft_button_capabilities());
+
+  EXPECT_TRUE(soft_button_capabilities_so[0]["shortPressAvailable"].asBool());
+  EXPECT_TRUE(soft_button_capabilities_so[0]["longPressAvailable"].asBool());
+  EXPECT_TRUE(soft_button_capabilities_so[0]["upDownAvailable"].asBool());
+  EXPECT_TRUE(soft_button_capabilities_so[0]["imageSupported"].asBool());
+
+  const smart_objects::SmartObject preset_bank_so =
+      *(hmi_capabilities_test->preset_bank_capabilities());
+  EXPECT_TRUE(preset_bank_so["onScreenPresetsAvailable"].asBool());
+
+  // Check vehicle type
+  const smart_objects::SmartObject vehicle_type_so =
+      *(hmi_capabilities_test->vehicle_type());
+  EXPECT_TRUE(preset_bank_so["onScreenPresetsAvailable"].asBool());
+
+  EXPECT_EQ("Ford", vehicle_type_so["make"].asString());
+  EXPECT_EQ("Fiesta", vehicle_type_so["model"].asString());
+  EXPECT_EQ("2013", vehicle_type_so["modelYear"].asString());
+  EXPECT_EQ("SE", vehicle_type_so["trim"].asString());
+}
+
+TEST_F(HMICapabilitiesTest, ConvertJsonLanguagesToObj) {
+  Json::Value json_languages(Json::arrayValue);
+  json_languages[0] = "EN_US";
+  json_languages[1] = "ES_MX";
+  smart_objects::SmartObject sm_obj =
+      smart_objects::SmartObject(smart_objects::SmartType_Array);
+
+  EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
+              CommonLanguageFromString(json_languages[0].asString()))
+      .WillOnce(Return(hmi_apis::Common_Language::EN_US));
+
+  EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
+              CommonLanguageFromString(json_languages[1].asString()))
+      .WillOnce(Return(hmi_apis::Common_Language::ES_MX));
+
+  hmi_capabilities_test->ConvertJsonLanguagesToObj(json_languages, sm_obj);
+
+  EXPECT_EQ(hmi_apis::Common_Language::EN_US,
+            static_cast<hmi_apis::Common_Language::eType>(sm_obj[0].asInt()));
+  EXPECT_EQ(hmi_apis::Common_Language::ES_MX,
+            static_cast<hmi_apis::Common_Language::eType>(sm_obj[1].asInt()));
+}
+
+TEST_F(HMICapabilitiesTest,
+       HmiCapabilitiesInitialized_UiVrTtsIviNotCooperating) {
+  // Precondition
+  hmi_capabilities_test->set_is_vr_cooperating(false);
+  hmi_capabilities_test->set_is_tts_cooperating(false);
+
+  hmi_capabilities_test->set_is_ui_cooperating(false);
+  hmi_capabilities_test->set_is_navi_cooperating(false);
+  hmi_capabilities_test->set_is_ivi_cooperating(false);
+  EXPECT_TRUE(hmi_capabilities_test->is_hmi_capabilities_initialized());
+}
+
+TEST_F(HMICapabilitiesTest, HmiCapabilitiesInitialized) {
+  // Precondition
+  SetCooperating();
+  smart_objects::SmartObjectSPtr language(
+      new smart_objects::SmartObject(smart_objects::SmartType_Map));
+
+  EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
+              CreateModuleInfoSO(_)).WillRepeatedly(Return(language));
+
+  hmi_capabilities_test->set_is_vr_cooperating(true);
+  smart_objects::SmartObject supported_languages;
+  supported_languages[0] = "EN_US";
+  hmi_capabilities_test->set_vr_supported_languages(supported_languages);
+  hmi_capabilities_test->set_tts_supported_languages(supported_languages);
+  hmi_capabilities_test->set_ui_supported_languages(supported_languages);
+  hmi_capabilities_test->set_vehicle_type(supported_languages);
+
+  hmi_capabilities_test->set_is_tts_cooperating(true);
+  hmi_capabilities_test->set_is_ui_cooperating(true);
+  hmi_capabilities_test->set_is_navi_cooperating(true);
+  hmi_capabilities_test->set_is_ivi_cooperating(true);
+
+  hmi_capabilities_test->set_active_vr_language(
+      hmi_apis::Common_Language::EN_US);
+  SetCooperating();
+  hmi_capabilities_test->set_active_tts_language(
+      hmi_apis::Common_Language::EN_US);
+  SetCooperating();
+  hmi_capabilities_test->set_active_ui_language(
+      hmi_apis::Common_Language::EN_US);
+
+  EXPECT_TRUE(hmi_capabilities_test->is_hmi_capabilities_initialized());
+}
+
+TEST_F(HMICapabilitiesTest, VerifyImageType) {
+  const int32_t image_type = 1;
+  smart_objects::SmartObject sm_obj;
+  sm_obj[hmi_response::image_capabilities][0] = image_type;
+  hmi_capabilities_test->set_display_capabilities(sm_obj);
+
+  EXPECT_TRUE(hmi_capabilities_test->VerifyImageType(image_type));
+
+  const int32_t new_image_type = 2;
+  EXPECT_FALSE(hmi_capabilities_test->VerifyImageType(new_image_type));
+}
+
+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));
+}
+
+TEST_F(HMICapabilitiesTest, SetVRCooperating) {
+  // Without sequence it is impossible to check correct call of ManageHMICommand
+  InSequence dummy;
+  smart_objects::SmartObjectSPtr language(
+      new smart_objects::SmartObject(smart_objects::SmartType_Map));
+  EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
+              CreateModuleInfoSO(hmi_apis::FunctionID::VR_GetLanguage))
+      .WillOnce(Return(language));
+  EXPECT_CALL(*app_mngr_, ManageHMICommand(language));
+
+  smart_objects::SmartObjectSPtr support_language;
+  EXPECT_CALL(
+      *(MockMessageHelper::message_helper_mock()),
+      CreateModuleInfoSO(hmi_apis::FunctionID::VR_GetSupportedLanguages))
+      .WillOnce(Return(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))
+      .WillOnce(Return(capabilities));
+  EXPECT_CALL(*app_mngr_, ManageHMICommand(capabilities));
+
+  hmi_capabilities_test->set_is_vr_cooperating(true);
+}
+
+TEST_F(HMICapabilitiesTest, SetTTSCooperating) {
+  smart_objects::SmartObjectSPtr language(
+      new smart_objects::SmartObject(smart_objects::SmartType_Map));
+  InSequence dummy;
+  EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
+              CreateModuleInfoSO(hmi_apis::FunctionID::TTS_GetLanguage))
+      .WillOnce(Return(language));
+  EXPECT_CALL(*app_mngr_, ManageHMICommand(language));
+
+  smart_objects::SmartObjectSPtr support_language;
+  EXPECT_CALL(
+      *(MockMessageHelper::message_helper_mock()),
+      CreateModuleInfoSO(hmi_apis::FunctionID::TTS_GetSupportedLanguages))
+      .WillOnce(Return(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))
+      .WillOnce(Return(capabilities));
+  EXPECT_CALL(*app_mngr_, ManageHMICommand(capabilities));
+
+  hmi_capabilities_test->set_is_tts_cooperating(true);
+}
+
+TEST_F(HMICapabilitiesTest, SetUICooperating) {
+  InSequence dummy;
+  smart_objects::SmartObjectSPtr language(
+      new smart_objects::SmartObject(smart_objects::SmartType_Map));
+  EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
+              CreateModuleInfoSO(hmi_apis::FunctionID::UI_GetLanguage))
+      .WillOnce(Return(language));
+  EXPECT_CALL(*app_mngr_, ManageHMICommand(language));
+
+  smart_objects::SmartObjectSPtr support_language;
+  EXPECT_CALL(
+      *(MockMessageHelper::message_helper_mock()),
+      CreateModuleInfoSO(hmi_apis::FunctionID::UI_GetSupportedLanguages))
+      .WillOnce(Return(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))
+      .WillOnce(Return(capabilities));
+  EXPECT_CALL(*app_mngr_, ManageHMICommand(capabilities));
+
+  hmi_capabilities_test->set_is_ui_cooperating(true);
+}
+
+TEST_F(HMICapabilitiesTest, SetIviCooperating) {
+  smart_objects::SmartObjectSPtr ivi_type;
+  EXPECT_CALL(
+      *(MockMessageHelper::message_helper_mock()),
+      CreateModuleInfoSO(hmi_apis::FunctionID::VehicleInfo_GetVehicleType))
+      .WillOnce(Return(ivi_type));
+  EXPECT_CALL(*app_mngr_, ManageHMICommand(ivi_type));
+
+  hmi_capabilities_test->set_is_ivi_cooperating(true);
+}
+
+}  // namespace application_manager_test
+}  // namespace components
+}  // namespace test
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
new file mode 100644
index 0000000000..0f2d02eed1
--- /dev/null
+++ b/src/components/application_manager/test/include/application_manager/mock_application_manager.h
@@ -0,0 +1,118 @@
+/*
+ * 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_MANAGER_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_APPLICATION_MANAGER_H_
+
+#include <string>
+#include <vector>
+#include "gmock/gmock.h"
+#include "application_manager/application_manager.h"
+#include "application_manager/usage_statistics.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"
+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_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&());
+};
+}  // namespace application_manager_test
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_APPLICATION_MANAGER_H_
diff --git a/src/components/application_manager/test/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h
index 967653721f..7904006a04 100644
--- a/src/components/application_manager/test/mock_message_helper.h
+++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h
@@ -36,6 +36,7 @@
 #include "application_manager/application.h"
 #include "interfaces/HMI_API.h"
 #include "policy/policy_types.h"
+#include "application_manager/policies/policy_handler.h"
 
 namespace application_manager {
 
@@ -73,7 +74,6 @@ class MockMessageHelper {
   MOCK_METHOD1(SendAudioStopStream, void(int32_t connection_key));
   MOCK_METHOD2(SendOnDataStreaming,
                void(protocol_handler::ServiceType service, bool available));
-  MOCK_METHOD1(GetAppCommandLimit, uint32_t(const std::string& policy_app_id));
   MOCK_METHOD2(CreateGetVehicleDataRequest,
                void(uint32_t correlation_id,
                     const std::vector<std::string>& params));
@@ -114,8 +114,6 @@ class MockMessageHelper {
           const std::string& language)) ;
   MOCK_METHOD1(CommonLanguageToString, std::string(
           hmi_apis::Common_Language::eType));
-  MOCK_METHOD1(MobileLanguageToString,
-               std::string(const mobile_apis::Language::eType language));
   MOCK_METHOD1(MobileLanguageFromString,
                mobile_apis::Language::eType(const std::string& lanugage));
   MOCK_METHOD1(MobileToCommonLanguage,
@@ -143,9 +141,13 @@ class MockMessageHelper {
   MOCK_METHOD2(CheckWithPolicy,
                bool(mobile_apis::SystemAction::eType, const std::string&));
 
-  MOCK_METHOD3(GetBCActivateAppRequestToHMI, smart_objects::SmartObjectSPtr (ApplicationConstSharedPtr app,
-                                                   hmi_apis::Common_HMILevel::eType level,
-                                                   bool send_policy_priority));
+  MOCK_METHOD5(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));
 
   static MockMessageHelper* message_helper_mock();
 };
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 b6ed63b101..48aaef1f9d 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
@@ -39,6 +39,8 @@
 #include "application_manager/policies/policy_handler.h"
 #include "application_manager/test/resumption/include/application_mock.h"
 #include "utils/custom_string.h"
+#include "policy/mock_policy_settings.h"
+#include "application_manager/policies/policy_handler.h"
 
 namespace application_manager {
 namespace test {
@@ -680,9 +682,11 @@ TEST_F(MessageHelperTest,
   MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   // Creating input data for method
   smart_objects::SmartObject object;
+  policy_handler_test::MockPolicySettings policy_settings_;
+  const policy::PolicyHandler policy_handler (policy_settings_);
   // Method call
   mobile_apis::Result::eType result =
-      MessageHelper::ProcessSoftButtons(object, appSharedMock);
+      MessageHelper::ProcessSoftButtons(object, appSharedMock, policy_handler);
   // Expect
   EXPECT_EQ(mobile_apis::Result::SUCCESS, result);
 }
@@ -696,9 +700,11 @@ TEST_F(MessageHelperTest,
   smart_objects::SmartObject& buttons = object[strings::soft_buttons];
   // 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_);
   // Method call
   mobile_apis::Result::eType result =
-      MessageHelper::ProcessSoftButtons(object, appSharedMock);
+      MessageHelper::ProcessSoftButtons(object, appSharedMock, policy_handler);
   // Expect
   EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result);
 }
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 ae8f195c71..6640fbebca 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
@@ -81,6 +81,7 @@
 #include "utils/lock.h"
 #include "utils/singleton.h"
 #include "utils/data_accessor.h"
+#include "resumption/last_state.h"
 
 namespace application_manager {
 enum VRTTSSessionChanging { kVRSessionChanging = 0, kTTSSessionChanging };
@@ -165,7 +166,8 @@ class ApplicationManagerImpl
     std::cout << "ApplicationManagerImpl Mock created \n";
   }
 
-  MOCK_METHOD0(Init, bool());
+  MOCK_METHOD2(Init, bool(resumption::LastState& last_state,
+                          media_manager::MediaManager* media_manager));
   MOCK_METHOD0(Stop, bool());
 
   // ApplicationManager methods
@@ -214,6 +216,17 @@ class ApplicationManagerImpl
   MOCK_METHOD1(Handle, void(const impl::MessageToHmi));
   MOCK_METHOD1(Handle, void(const impl::AudioData));
 
+//  // ApplicationManager methods
+//  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(connection_handler,
+//                     connection_handler::ConnectionHandler&());
+//  MOCK_METHOD0(GetPolicyHandler,
+//                     policy::PolicyHandlerInterface&());
+
 // ApplicationManagerImpl methods:
 #ifdef TELEMETRY_MONITOR
   MOCK_METHOD1(SetTelemetryObserver, void(AMTelemetryObserver*));
@@ -302,9 +315,9 @@ class ApplicationManagerImpl
 
   MOCK_METHOD2(HMILevelAllowsStreaming,
                bool(uint32_t, protocol_handler::ServiceType));
-  MOCK_METHOD2(CanAppStream, bool(uint32_t, protocol_handler::ServiceType));
+  MOCK_CONST_METHOD2(CanAppStream, bool(uint32_t, protocol_handler::ServiceType));
   MOCK_METHOD1(EndNaviServices, void(int32_t));
-  MOCK_METHOD1(ForbidStreaming, void(int32_t));
+  MOCK_METHOD1(ForbidStreaming, void(uint32_t));
   MOCK_METHOD3(OnAppStreaming,
                void(int32_t, protocol_handler::ServiceType, bool));
 
diff --git a/src/components/application_manager/test/mock/include/application_manager/mock_statistics_manager.h b/src/components/application_manager/test/mock/include/application_manager/mock_statistics_manager.h
index 20f7c83034..db974129bf 100644
--- a/src/components/application_manager/test/mock/include/application_manager/mock_statistics_manager.h
+++ b/src/components/application_manager/test/mock/include/application_manager/mock_statistics_manager.h
@@ -35,7 +35,7 @@
 
 #include "gmock/gmock.h"
 
-#include "usage_statistics/statistics_manager.h"
+#include "policy/usage_statistics/statistics_manager.h"
 #include "application_manager/usage_statistics.h"
 
 namespace test {
diff --git a/src/components/application_manager/test/mock/policy_handler_interface_mock.h b/src/components/application_manager/test/mock/policy_handler_interface_mock.h
index e92950823a..94997f00bc 100644
--- a/src/components/application_manager/test/mock/policy_handler_interface_mock.h
+++ b/src/components/application_manager/test/mock/policy_handler_interface_mock.h
@@ -41,10 +41,148 @@
 
 namespace policy {
 
-class MockPolicyHandlerInterface : public PolicyHandlerInterface {
+namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
+class MockPolicyHandlerInterface : public policy::PolicyHandlerInterface {
  public:
+  MOCK_METHOD0(LoadPolicyLibrary, bool());
+  MOCK_CONST_METHOD0(PolicyEnabled, bool());
+  MOCK_METHOD0(InitPolicyTable, bool());
+  MOCK_METHOD0(ResetPolicyTable, bool());
+  MOCK_METHOD0(ClearUserConsent, bool());
+  MOCK_METHOD2(SendMessageToSDK, bool(const policy::BinaryMessage& pt_string,
+                                      const std::string& url));
+  MOCK_METHOD2(ReceiveMessageFromSDK,
+               bool(const std::string& file,
+                    const policy::BinaryMessage& pt_string));
+  MOCK_METHOD0(UnloadPolicyLibrary, bool());
+  MOCK_METHOD3(OnPermissionsUpdated,
+               void(const std::string& policy_app_id,
+                    const policy::Permissions& permissions,
+                    const policy::HMILevel& default_hmi));
+  MOCK_METHOD2(OnPermissionsUpdated,
+               void(const std::string& policy_app_id,
+                    const policy::Permissions& permissions));
+  MOCK_METHOD3(OnSnapshotCreated,
+               void(const policy::BinaryMessage& pt_string,
+                    const std::vector<int>& retry_delay_seconds,
+                    int timeout_exchange));
+  MOCK_CONST_METHOD2(GetPriority, bool(const std::string& policy_app_id,
+                                       std::string* priority));
+  MOCK_METHOD5(CheckPermissions,
+               void(const policy::PTString& app_id,
+                    const policy::PTString& hmi_level,
+                    const policy::PTString& rpc, const policy::RPCParams& rpc_params,
+                    policy::CheckPermissionResult& result));
+  MOCK_CONST_METHOD1(GetNotificationsNumber,
+                     uint32_t(const std::string& priority));
+  MOCK_CONST_METHOD1(GetUserConsentForDevice,
+                     policy::DeviceConsent(const std::string& device_id));
+  MOCK_CONST_METHOD2(GetDefaultHmi, bool(const std::string& policy_app_id,
+                                         std::string* default_hmi));
+
+  MOCK_METHOD3(GetInitialAppData,
+               bool(const std::string& application_id, policy::StringArray* nicknames,
+                    policy::StringArray* app_hmi_types));
+  MOCK_METHOD2(GetInitialAppData,
+               bool(const std::string& application_id, policy::StringArray* nicknames));
+  MOCK_METHOD1(GetInitialAppData,
+               bool(const std::string& application_id));
+  MOCK_METHOD2(GetUpdateUrls,
+               void(int service_type, policy::EndpointUrls& end_points));
+  MOCK_METHOD0(ResetRetrySequence, void());
+  MOCK_METHOD0(NextRetryTimeout, int());
+  MOCK_METHOD0(TimeoutExchange, int());
+  MOCK_METHOD0(OnExceededTimeout, void());
   MOCK_METHOD0(OnSystemReady, void());
-  MOCK_METHOD2(PTUpdatedAt, void(Counters counter, int value));
+  MOCK_METHOD2(PTUpdatedAt, void(policy::Counters counter, int value));
+  MOCK_METHOD1(add_listener, void(policy::PolicyHandlerObserver* listener));
+  MOCK_METHOD1(remove_listener, void(policy::PolicyHandlerObserver* listener));
+  MOCK_CONST_METHOD0(GetStatisticManager,
+                     utils::SharedPtr<usage_statistics::StatisticsManager>());
+  MOCK_CONST_METHOD2(CheckSystemAction,
+                     bool(mobile_apis::SystemAction::eType system_action,
+                          const std::string& policy_app_id));
+  MOCK_METHOD1(KmsChanged, void(int kms));
+  MOCK_METHOD2(OnActivateApp,
+               void(uint32_t connection_key, uint32_t correlation_id));
+  MOCK_METHOD2(OnAllowSDLFunctionalityNotification,
+               void(bool is_allowed, const std::string& device_id));
+  MOCK_METHOD0(OnIgnitionCycleOver, void());
+  MOCK_METHOD1(OnPendingPermissionChange,
+               void(const std::string& policy_app_id));
+  MOCK_METHOD1(PTExchangeAtUserRequest, void(uint32_t correlation_id));
+  MOCK_METHOD2(AddDevice, void(const std::string& device_id,
+                               const std::string& connection_type));
+  MOCK_METHOD2(SetDeviceInfo, void(const std::string& device_id,
+                                   const policy::DeviceInfo& device_info));
+  MOCK_METHOD2(OnAppPermissionConsent,
+               void(const uint32_t connection_key,
+                    const policy::PermissionConsent& permissions));
+  MOCK_METHOD3(OnGetUserFriendlyMessage,
+               void(const std::vector<std::string>& message_codes,
+                    const std::string& language, uint32_t correlation_id));
+  MOCK_METHOD2(OnGetListOfPermissions, void(const uint32_t connection_key,
+                                            const uint32_t correlation_id));
+  MOCK_METHOD1(OnGetStatusUpdate, void(const uint32_t correlation_id));
+  MOCK_METHOD1(OnUpdateStatusChanged, void(const std::string& status));
+  MOCK_METHOD1(OnCurrentDeviceIdUpdateRequired,
+               std::string(const std::string& policy_app_id));
+  MOCK_METHOD1(OnSystemInfoChanged, void(const std::string& language));
+  MOCK_METHOD3(OnGetSystemInfo, void(const std::string& ccpu_version,
+                                     const std::string& wers_country_code,
+                                     const std::string& language));
+  MOCK_METHOD0(OnSystemInfoUpdateRequired, void());
+  MOCK_METHOD0(OnVIIsReady, void());
+  MOCK_METHOD1(OnVehicleDataUpdated,
+               void(const smart_objects::SmartObject& message));
+  MOCK_METHOD1(RemoveDevice, void(const std::string& device_id));
+  MOCK_METHOD1(AddStatisticsInfo, void(int type));
+  MOCK_METHOD1(OnSystemError, void(int code));
+  MOCK_CONST_METHOD0(GetAppIdForSending, uint32_t());
+  MOCK_METHOD1(GetAppName,
+               utils::custom_string::CustomString(const std::string& policy_app_id));
+  MOCK_METHOD1(OnUpdateHMIAppType,
+               void(std::map<std::string, policy::StringArray> app_hmi_types));
+  MOCK_METHOD1(OnCertificateUpdated, void(const std::string& certificate_data));
+  MOCK_METHOD1(OnCertificateDecrypted, void(bool is_succeeded));
+  MOCK_METHOD0(CanUpdate, bool());
+  MOCK_METHOD2(OnDeviceConsentChanged,
+               void(const std::string& device_id, bool is_allowed));
+  MOCK_CONST_METHOD2(SendOnAppPermissionsChanged,
+                     void(const policy::AppPermissions& permissions,
+                          const std::string& policy_app_id));
+  MOCK_METHOD0(OnPTExchangeNeeded, void());
+  MOCK_METHOD1(GetAvailableApps, void(std::queue<std::string>& apps));
+  MOCK_METHOD1(AddApplication, void(const std::string& application_id));
+  MOCK_METHOD1(IsApplicationRevoked, bool(const std::string& app_id));
+  MOCK_METHOD0(OnUpdateRequestSentToMobile, void());
+  MOCK_CONST_METHOD1(HeartBeatTimeout, uint32_t(const std::string& app_id));
+  MOCK_METHOD0(OnAppsSearchStarted, void());
+  MOCK_METHOD0(OnAppsSearchCompleted, void());
+  MOCK_METHOD1(OnAppRegisteredOnMobile,
+               void(const std::string& application_id));
+  MOCK_CONST_METHOD2(IsRequestTypeAllowed,
+                     bool(const std::string& policy_app_id,
+                          mobile_apis::RequestType::eType type));
+  MOCK_CONST_METHOD1(GetAppRequestTypes, const std::vector<std::string>(
+                                             const std::string& policy_app_id));
+  MOCK_CONST_METHOD0(GetVehicleInfo, const policy::VehicleInfo());
+  MOCK_METHOD1(Increment, void(usage_statistics::GlobalCounterId type));
+  MOCK_METHOD2(Increment, void(const std::string& app_id,
+                               usage_statistics::AppCounterId type));
+  MOCK_METHOD3(Set,
+               void(const std::string& app_id, usage_statistics::AppInfoId type,
+                    const std::string& value));
+  MOCK_METHOD3(Add, void(const std::string& app_id,
+                         usage_statistics::AppStopwatchId type,
+                         int32_t timespan_seconds));
+  MOCK_CONST_METHOD0(RetrieveCertificate, std::string());
+  MOCK_CONST_METHOD0(get_settings, const policy::PolicySettings&());
+
+ private:
+  MOCK_METHOD2(OnAppPermissionConsentInternal,
+               void(const uint32_t connection_key,
+                    policy::PermissionConsent& permissions));
 };
 
 }  // namespace policy
diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc
index deec54e61f..e460928123 100644
--- a/src/components/application_manager/test/mock_message_helper.cc
+++ b/src/components/application_manager/test/mock_message_helper.cc
@@ -31,13 +31,15 @@
  */
 
 #include "application_manager/message_helper.h"
-#include "mock_message_helper.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/policies/policy_handler.h"
 
 namespace application_manager {
 
 void MessageHelper::SendHashUpdateNotification(uint32_t const app_id) {
   MockMessageHelper::message_helper_mock()->SendHashUpdateNotification(app_id);
 }
+
 void MessageHelper::SendNaviStartStream(int32_t connection_key) {
   MockMessageHelper::message_helper_mock()->SendNaviStartStream(connection_key);
 }
@@ -57,11 +59,6 @@ void MessageHelper::SendOnDataStreaming(protocol_handler::ServiceType service,
                                                                 available);
 }
 
-uint32_t MessageHelper::GetAppCommandLimit(const std::string& policy_app_id) {
-  return MockMessageHelper::message_helper_mock()->GetAppCommandLimit(
-      policy_app_id);
-}
-
 smart_objects::SmartObjectSPtr GetHashUpdateNotification(
     const uint32_t app_id) {
   return MockMessageHelper::message_helper_mock()->GetHashUpdateNotification(
@@ -208,10 +205,6 @@ hmi_apis::Common_Language::eType MessageHelper::CommonLanguageFromString(const s
         language);
 }
 
-std::string MessageHelper::MobileLanguageToString(const mobile_apis::Language::eType language) {
-  return  MockMessageHelper::message_helper_mock()->MobileLanguageToString(language);
-}
-
 mobile_apis::Language::eType MessageHelper::MobileLanguageFromString(const std::string& language) {
   return  MockMessageHelper::message_helper_mock()->MobileLanguageFromString(language);
 }
@@ -284,19 +277,13 @@ std::string MessageHelper::CommonLanguageToString(
   return MockMessageHelper::message_helper_mock()->CommonLanguageToString(lang);
 }
 
-bool MessageHelper::CheckWithPolicy(
-    mobile_apis::SystemAction::eType system_action,
-    const std::string& app_mobile_id) {
-  return MockMessageHelper::message_helper_mock()->CheckWithPolicy(
-        system_action, app_mobile_id);
-}
-
-smart_objects::SmartObjectSPtr MessageHelper::GetBCActivateAppRequestToHMI(
-    ApplicationConstSharedPtr app,
-    hmi_apis::Common_HMILevel::eType hmi_level,
+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) {
-  return MockMessageHelper::message_helper_mock()->
-      GetBCActivateAppRequestToHMI(app, hmi_level, send_policy_priority);
+  return MockMessageHelper::message_helper_mock()->GetBCActivateAppRequestToHMI(
+      app, session_observer, policy_handler, level, send_policy_priority);
 }
 
 }  // namespace application_manager
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 e3b0a07078..793f306490 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
@@ -77,8 +77,9 @@ class ResumptionDataMock : public ::resumption::ResumptionData {
                                     const std::string& device_id,
                                     mobile_apis::HMILevel::eType hmi_level));
   MOCK_METHOD0(Init, bool());
-  MOCK_METHOD2(DropAppDataResumption, bool(const std::string& device_id,
-                                           const std::string& app_id));
+  MOCK_METHOD2(DropAppDataResumption,
+               bool(const std::string& device_id, const std::string& app_id));
+  MOCK_METHOD0(Persist, void());
 };
 
 }  // namespace resumption_test
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
new file mode 100644
index 0000000000..92f27da92e
--- /dev/null
+++ b/src/components/application_manager/test/resumption/resumption_data_json_test.cc
@@ -0,0 +1,389 @@
+/*
+ * 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_manager/mock_application.h"
+#include "application_manager/mock_resumption_data.h"
+#include "interfaces/MOBILE_API.h"
+#include "resumption/last_state.h"
+
+#include "application_manager/resumption_data_test.h"
+#include "formatters/CFormatterJsonBase.h"
+#include "config_profile/profile.h"
+#include "utils/file_system.h"
+
+#include "application_manager/resumption/resumption_data_json.h"
+namespace test {
+namespace components {
+namespace resumption_test {
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::NiceMock;
+
+namespace am = application_manager;
+using namespace Json;
+using namespace file_system;
+
+using namespace resumption;
+using namespace mobile_apis;
+namespace Formatters = NsSmartDeviceLink::NsJSONHandler::Formatters;
+
+class ResumptionDataJsonTest : public ResumptionDataTest {
+ protected:
+  ResumptionDataJsonTest() : last_state_("app_storage_folder",
+                                         "app_info_storage"), res_json(last_state_) {}
+  virtual void SetUp() {
+    app_mock = new NiceMock<application_manager_test::MockApplication>();
+
+    policy_app_id_ = "test_policy_app_id";
+    app_id_ = 10;
+    is_audio_ = true;
+    grammar_id_ = 20;
+    hash_ = "saved_hash";
+    hmi_level_ = HMILevel::eType::HMI_FULL;
+    hmi_app_id_ = 8;
+    ign_off_count_ = 0;
+  }
+
+  void CheckSavedJson() {
+    Value& dictionary = last_state_.dictionary;
+    ASSERT_TRUE(dictionary[am::strings::resumption].isObject());
+    ASSERT_TRUE(
+        dictionary[am::strings::resumption][am::strings::resume_app_list]
+            .isArray());
+    Value& resume_app_list =
+        dictionary[am::strings::resumption][am::strings::resume_app_list];
+    sm::SmartObject res_app_list;
+    for (uint32_t i = 0; i < resume_app_list.size(); i++) {
+      Formatters::CFormatterJsonBase::jsonValueToObj(resume_app_list[i],
+                                                     res_app_list);
+      CheckSavedApp(res_app_list);
+    }
+  }
+
+  void SetZeroIgnOff() {
+    Value& dictionary = last_state_.dictionary;
+    Value& res = dictionary[am::strings::resumption];
+    res[am::strings::last_ign_off_time] = 0;
+    last_state_.SaveToFileSystem();
+  }
+
+  resumption::LastState last_state_;
+  ResumptionDataJson res_json;
+
+};
+
+TEST_F(ResumptionDataJsonTest, SaveApplication) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+}
+
+TEST_F(ResumptionDataJsonTest, SavedApplicationTwice) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+}
+
+TEST_F(ResumptionDataJsonTest, SavedApplicationTwice_UpdateApp) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+  (*vr_help_)[0][am::strings::position] = 2;
+
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+}
+
+TEST_F(ResumptionDataJsonTest, RemoveApplicationFromSaved) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  EXPECT_TRUE(
+      res_json.RemoveApplicationFromSaved(policy_app_id_, mac_address_));
+
+  // Check that application was deleted
+  smart_objects::SmartObject remove_app;
+  EXPECT_FALSE(
+      res_json.GetSavedApplication(policy_app_id_, mac_address_, remove_app));
+  EXPECT_TRUE(remove_app.empty());
+}
+
+TEST_F(ResumptionDataJsonTest, RemoveApplicationFromSaved_AppNotSaved) {
+  EXPECT_FALSE(res_json.RemoveApplicationFromSaved(policy_app_id_, "54321"));
+}
+
+TEST_F(ResumptionDataJsonTest, IsApplicationSaved_ApplicationSaved) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+  ssize_t result = res_json.IsApplicationSaved(policy_app_id_, mac_address_);
+  EXPECT_EQ(0, result);
+}
+
+TEST_F(ResumptionDataJsonTest, IsApplicationSaved_ApplicationRemoved) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+  EXPECT_TRUE(
+      res_json.RemoveApplicationFromSaved(policy_app_id_, mac_address_));
+  ssize_t result = res_json.IsApplicationSaved(policy_app_id_, mac_address_);
+  EXPECT_EQ(-1, result);
+}
+
+TEST_F(ResumptionDataJsonTest, GetSavedApplication) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  smart_objects::SmartObject saved_app;
+  EXPECT_TRUE(
+      res_json.GetSavedApplication(policy_app_id_, mac_address_, saved_app));
+  CheckSavedApp(saved_app);
+}
+
+TEST_F(ResumptionDataJsonTest, GetSavedApplication_AppNotSaved) {
+  smart_objects::SmartObject saved_app;
+  EXPECT_FALSE(
+      res_json.GetSavedApplication(policy_app_id_, "54321", saved_app));
+  EXPECT_TRUE(saved_app.empty());
+}
+
+TEST_F(ResumptionDataJsonTest, GetDataForLoadResumeData) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+  smart_objects::SmartObject saved_app;
+  res_json.GetDataForLoadResumeData(saved_app);
+
+  EXPECT_EQ(policy_app_id_, saved_app[0][am::strings::app_id].asString());
+  EXPECT_EQ(mac_address_, saved_app[0][am::strings::device_id].asString());
+  EXPECT_EQ(hmi_level_,
+            static_cast<HMILevel::eType>(
+                saved_app[0][am::strings::hmi_level].asInt()));
+  EXPECT_EQ(ign_off_count_, saved_app[0][am::strings::ign_off_count].asUInt());
+}
+
+TEST_F(ResumptionDataJsonTest, GetDataForLoadResumeData_AppRemove) {
+  smart_objects::SmartObject saved_app;
+
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+  EXPECT_TRUE(
+      res_json.RemoveApplicationFromSaved(policy_app_id_, mac_address_));
+  res_json.GetDataForLoadResumeData(saved_app);
+  EXPECT_TRUE(saved_app.empty());
+}
+
+TEST_F(ResumptionDataJsonTest, UpdateHmiLevel) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+  HMILevel::eType new_hmi_level = HMILevel::HMI_LIMITED;
+  res_json.UpdateHmiLevel(policy_app_id_, mac_address_, new_hmi_level);
+  hmi_level_ = new_hmi_level;
+
+  CheckSavedJson();
+}
+
+TEST_F(ResumptionDataJsonTest, IsHMIApplicationIdExist_AppIsSaved) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+  EXPECT_TRUE(res_json.IsHMIApplicationIdExist(hmi_app_id_));
+}
+
+TEST_F(ResumptionDataJsonTest, IsHMIApplicationIdExist_AppNotSaved) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+
+  CheckSavedJson();
+  uint32_t new_hmi_app_id_ = hmi_app_id_ + 10;
+  EXPECT_FALSE(res_json.IsHMIApplicationIdExist(new_hmi_app_id_));
+}
+
+TEST_F(ResumptionDataJsonTest, GetHMIApplicationID) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+  EXPECT_EQ(hmi_app_id_,
+            res_json.GetHMIApplicationID(policy_app_id_, mac_address_));
+}
+
+TEST_F(ResumptionDataJsonTest, GetHMIApplicationID_AppNotSaved) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  EXPECT_EQ(0u, res_json.GetHMIApplicationID(policy_app_id_, "other_dev_id"));
+}
+
+TEST_F(ResumptionDataJsonTest, OnSuspend) {
+  SetZeroIgnOff();
+  PrepareData();
+
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+
+  res_json.OnSuspend();
+  ign_off_count_++;
+  CheckSavedJson();
+}
+
+TEST_F(ResumptionDataJsonTest, OnSuspendFourTimes) {
+  PrepareData();
+  SetZeroIgnOff();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+
+  res_json.OnSuspend();
+  ign_off_count_++;
+  CheckSavedJson();
+
+  res_json.OnSuspend();
+  res_json.OnSuspend();
+  res_json.OnSuspend();
+
+  EXPECT_TRUE(-1 != res_json.IsApplicationSaved(policy_app_id_, mac_address_));
+}
+
+TEST_F(ResumptionDataJsonTest, OnSuspendOnAwake) {
+  PrepareData();
+  SetZeroIgnOff();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+
+  res_json.OnSuspend();
+  ign_off_count_++;
+  CheckSavedJson();
+
+  res_json.OnAwake();
+  ign_off_count_ = 0;
+  CheckSavedJson();
+}
+
+TEST_F(ResumptionDataJsonTest, Awake_AppNotSuspended) {
+  SetZeroIgnOff();
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+
+  res_json.OnAwake();
+  ign_off_count_ = 0;
+  CheckSavedJson();
+}
+
+TEST_F(ResumptionDataJsonTest, TwiceAwake_AppNotSuspended) {
+  SetZeroIgnOff();
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+
+  res_json.OnSuspend();
+  res_json.OnAwake();
+  ign_off_count_ = 0;
+  CheckSavedJson();
+
+  res_json.OnAwake();
+  CheckSavedJson();
+}
+
+TEST_F(ResumptionDataJsonTest, GetHashId) {
+  PrepareData();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+
+  std::string test_hash;
+  EXPECT_TRUE(res_json.GetHashId(policy_app_id_, mac_address_, test_hash));
+  EXPECT_EQ(hash_, test_hash);
+}
+
+TEST_F(ResumptionDataJsonTest, GetIgnOffTime_AfterSuspendAndAwake) {
+  uint32_t last_ign_off_time;
+  PrepareData();
+  SetZeroIgnOff();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+  last_ign_off_time = res_json.GetIgnOffTime();
+  EXPECT_EQ(0u, last_ign_off_time);
+
+  res_json.OnSuspend();
+
+  uint32_t after_suspend;
+  after_suspend = res_json.GetIgnOffTime();
+  EXPECT_LE(last_ign_off_time, after_suspend);
+
+  uint32_t after_awake;
+  res_json.OnAwake();
+
+  after_awake = res_json.GetIgnOffTime();
+  EXPECT_LE(after_suspend, after_awake);
+}
+
+TEST_F(ResumptionDataJsonTest, DropAppDataResumption) {
+  PrepareData();
+  SetZeroIgnOff();
+  res_json.SaveApplication(app_mock);
+  CheckSavedJson();
+
+  EXPECT_TRUE(res_json.DropAppDataResumption(mac_address_, policy_app_id_));
+
+  smart_objects::SmartObject app;
+  EXPECT_TRUE(res_json.GetSavedApplication(policy_app_id_, mac_address_, app));
+
+  EXPECT_TRUE(app.keyExists(am::strings::application_commands) &&
+              app[am::strings::application_commands].empty());
+
+  EXPECT_TRUE(app.keyExists(am::strings::application_submenus) &&
+              app[am::strings::application_submenus].empty());
+
+  EXPECT_TRUE(app.keyExists(am::strings::application_choice_sets) &&
+              app[am::strings::application_choice_sets].empty());
+
+  EXPECT_TRUE(app.keyExists(am::strings::application_global_properties) &&
+              app[am::strings::application_global_properties].empty());
+
+  EXPECT_TRUE(app.keyExists(am::strings::application_subscribtions) &&
+              app[am::strings::application_subscribtions].empty());
+
+  EXPECT_TRUE(app.keyExists(am::strings::application_files) &&
+              app[am::strings::application_files].empty());
+
+  EXPECT_FALSE(app.keyExists(am::strings::grammar_id));
+}
+
+}  // namespace resumption_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/application_manager/test/state_controller/include/application_manager_mock.h b/src/components/application_manager/test/state_controller/include/application_manager_mock.h
index 4adcb99b4d..5a8e82a4b8 100644
--- a/src/components/application_manager/test/state_controller/include/application_manager_mock.h
+++ b/src/components/application_manager/test/state_controller/include/application_manager_mock.h
@@ -37,7 +37,10 @@
 #include "gmock/gmock.h"
 #include "application_manager/application_manager.h"
 #include "application_manager/usage_statistics.h"
-
+#include "application_manager/commands/command.h"
+#include "media_manager/media_manager.h"
+#include "resumption/last_state.h"
+#include "application_manager/policies/policy_handler.h"
 namespace test {
 namespace components {
 namespace state_controller_test {
@@ -45,7 +48,7 @@ namespace am = application_manager;
 
 class ApplicationManagerMock : public application_manager::ApplicationManager {
  public:
-  MOCK_METHOD0(Init, bool());
+  MOCK_METHOD1(Init, bool(resumption::LastState& last_state));
   MOCK_METHOD0(Stop, bool());
 
   MOCK_METHOD1(set_hmi_message_handler,
@@ -81,6 +84,25 @@ class ApplicationManagerMock : public application_manager::ApplicationManager {
   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&());
 };
 }  // namespace state_controller_test
 }  // namespace components
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 aabe583fa9..c9120bee98 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
@@ -35,7 +35,7 @@
 
 #include <string>
 #include "gmock/gmock.h"
-#include "usage_statistics/statistics_manager.h"
+#include "policy/usage_statistics/statistics_manager.h"
 
 namespace test {
 namespace components {
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 a7eee581ad..46a626617c 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
@@ -36,7 +36,6 @@
 #include "application_manager/usage_statistics.h"
 #include "application_manager/application_manager_impl.h"
 #include "application_mock.h"
-#include "application_manager/test/mock_message_helper.h"
 #include "connection_handler/mock_connection_handler_settings.h"
 #include "connection_handler/connection_handler_impl.h"
 #include "transport_manager/transport_manager_mock.h"
@@ -47,6 +46,12 @@
 #include "application_manager/message_helper.h"
 #include "application_manager/event_engine/event.h"
 #include "application_manager/smart_object_keys.h"
+#include "application_manager/mock_message_helper.h"
+#include "policy/mock_policy_settings.h"
+#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_application_manager.h"
 
 namespace am = application_manager;
 using am::HmiState;
@@ -126,7 +131,10 @@ class StateControllerTest : public ::testing::Test {
                        new state_controller_test::StatisticsManagerMock))
       , applications_(application_set_, applications_lock_)
       , state_ctrl_(&app_manager_mock_) {}
-  NiceMock<application_manager::ApplicationManagerImpl> app_manager_mock_;
+  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;
 
@@ -176,7 +184,7 @@ class StateControllerTest : public ::testing::Test {
   std::vector<am::ApplicationSharedPtr> applications_list_;
 
   connection_handler_test::MockConnectionHandlerSettings
-      mock_connection_handler_settings;
+      mock_connection_handler__settings;
   transport_manager_test::MockTransportManager mock_transport_manager;
   connection_handler::ConnectionHandlerImpl* conn_handler;
 
@@ -832,22 +840,26 @@ class StateControllerTest : public ::testing::Test {
 
   void SetConnection() {
     conn_handler = new connection_handler::ConnectionHandlerImpl(
-        mock_connection_handler_settings, mock_transport_manager);
+        mock_connection_handler__settings, mock_transport_manager);
     ON_CALL(app_manager_mock_, connection_handler())
-        .WillByDefault(Return(conn_handler));
+        .WillByDefault(ReturnRef(*conn_handler));
   }
 
-  void SetBCActivateAppRequestToHMI(mobile_apis::HMILevel::eType set_lvl,
+  void SetBCActivateAppRequestToHMI(const hmi_apis::Common_HMILevel::eType hmi_lvl,
                                     uint32_t corr_id) {
+      ON_CALL(mock_connection_handler_,get_session_observer()).WillByDefault(ReturnRef(mock_session_observer_));
+      ON_CALL(app_manager_mock_,connection_handler()).WillByDefault(ReturnRef(mock_connection_handler_));
+      ON_CALL(app_manager_mock_,GetPolicyHandler()).WillByDefault(ReturnRef(policy_interface_));
     smart_objects::SmartObjectSPtr bc_activate_app_request =
         new smart_objects::SmartObject();
-    const hmi_apis::Common_HMILevel::eType hmi_lvl =
-        static_cast<hmi_apis::Common_HMILevel::eType>(set_lvl);
     (*bc_activate_app_request)[am::strings::params]
                               [am::strings::correlation_id] = corr_id;
-    EXPECT_CALL(*message_helper_mock_,
-                GetBCActivateAppRequestToHMI(_, hmi_lvl, _))
-        .WillOnce(Return(bc_activate_app_request));
+    ON_CALL(*message_helper_mock_,
+                GetBCActivateAppRequestToHMI(_, _, _,hmi_lvl, _))
+        .WillByDefault(Return(bc_activate_app_request));
+
+    ON_CALL(app_manager_mock_, ManageHMICommand(bc_activate_app_request))
+        .WillByDefault(Return(true));
   }
 
   void ExpectSuccesfullSetHmiState(am::ApplicationSharedPtr app,
@@ -1694,31 +1706,30 @@ 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;
     Common_HMILevel::eType hmi_level = it->second;
 
-    EXPECT_CALL(*message_helper_mock_,
-                GetBCActivateAppRequestToHMI(_, hmi_level, _))
-        .WillOnce(Return(bc_activate_app_request));
-
-    EXPECT_CALL(app_manager_mock_, application_id(corr_id))
-        .WillOnce(Return(hmi_app_id));
-    EXPECT_CALL(app_manager_mock_, application_by_hmi_app(hmi_app_id))
-        .WillOnce(Return(media_app_));
-    ExpectSuccesfullSetHmiState(
-        media_app_, media_app_ptr_, initial_hmi_state, hmi_state);
-    state_ctrl_.SetRegularState<true>(media_app_, hmi_state);
-    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(
-        hmi_apis::FunctionID::BasicCommunication_ActivateApp);
-    event.set_smart_object(message);
-    state_ctrl_.on_event(event);
+      SetBCActivateAppRequestToHMI(hmi_level, corr_id);
+      ON_CALL(app_manager_mock_, ManageHMICommand(bc_activate_app_request))
+          .WillByDefault(Return(true));
+
+      EXPECT_CALL(app_manager_mock_, application_id(corr_id))
+          .WillOnce(Return(hmi_app_id));
+      EXPECT_CALL(app_manager_mock_, application_by_hmi_app(hmi_app_id))
+          .WillOnce(Return(media_app_));
+      ExpectSuccesfullSetHmiState(
+          media_app_, media_app_ptr_, initial_hmi_state, hmi_state);
+      state_ctrl_.SetRegularState<true>(media_app_, hmi_state);
+      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(
+          hmi_apis::FunctionID::BasicCommunication_ActivateApp);
+      event.set_smart_object(message);
+      state_ctrl_.on_event(event);
   }
 }
 
@@ -1798,7 +1809,7 @@ TEST_F(StateControllerTest, ActivateAppInvalidCorrelationId) {
       .Times(0);
   EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(simple_app_->app_id(), _, _))
       .Times(0);
-  SetBCActivateAppRequestToHMI(mobile_apis::HMILevel::HMI_FULL, corr_id);
+  SetBCActivateAppRequestToHMI(Common_HMILevel::FULL, corr_id);
   state_ctrl_.SetRegularState<true>(simple_app_, FullNotAudibleState());
   smart_objects::SmartObject message;
   message[am::strings::params][am::hmi_response::code] = Common_Result::SUCCESS;
@@ -2239,7 +2250,7 @@ TEST_F(StateControllerTest, SetRegularStateWithNewHmiLvl) {
       .WillOnce(Return(BackgroundState()));
 
   const uint32_t corr_id = 314;
-  SetBCActivateAppRequestToHMI(set_lvl, corr_id);
+  SetBCActivateAppRequestToHMI(static_cast<hmi_apis::Common_HMILevel::eType>(set_lvl), corr_id);
 
   state_ctrl_.SetRegularState(simple_app_, set_lvl);