Create unit tests for commands UI (#882)

* Create unit test for mobile commands

  - created UT for mobile commands for UI interface for checking
    SDL behavior in case HMI does not respond to IsReady_request
    or respond with "available" = false.
    Command list:
	1. Alert
	2. Show
	3. AddCommand
	4. DeleteCommand
	5. AddSubMenu
    	6. DeleteSubMenu
	7. PerformInteraction
	8. SetMediaClockTimer
	9. SetGlobalProperties
	10. ChangeRegistration
	11. SetAppIcon
	12. SetDisplayLayout
	13. Slider
	14. ScrollableMessage
	15. PerformAudioPassThru
	16. EndAudioPassThru

Related to APPLINK-25091

23 files changed, 2687 insertions, 726 deletions

diff --git a/src/components/application_manager/include/application_manager/commands/mobile/delete_sub_menu_request.h b/src/components/application_manager/include/application_manager/commands/mobile/delete_sub_menu_request.h
index 7c48de5d8e..20342ba5c1 100644
--- a/src/components/application_manager/include/application_manager/commands/mobile/delete_sub_menu_request.h
+++ b/src/components/application_manager/include/application_manager/commands/mobile/delete_sub_menu_request.h
@@ -65,6 +65,13 @@ class DeleteSubMenuRequest : public CommandRequestImpl {
    **/
   virtual void Run();
 
+  /**
+   * @brief Interface method that is called whenever new event received
+   *
+   * @param event The received event
+   */
+  void on_event(const event_engine::Event& event);
+
  private:
   /*
    * @brief Deletes VR commands from SDL for corresponding submenu ID
@@ -84,13 +91,6 @@ class DeleteSubMenuRequest : public CommandRequestImpl {
    */
   void DeleteSubMenuUICommands(ApplicationSharedPtr const app);
 
-  /**
-   * @brief Interface method that is called whenever new event received
-   *
-   * @param event The received event
-   */
-  void on_event(const event_engine::Event& event);
-
   DISALLOW_COPY_AND_ASSIGN(DeleteSubMenuRequest);
 };
 
diff --git a/src/components/application_manager/test/commands/hmi/CMakeLists.txt b/src/components/application_manager/test/commands/hmi/CMakeLists.txt
index ead1b8075e..d99e211bdc 100644
--- a/src/components/application_manager/test/commands/hmi/CMakeLists.txt
+++ b/src/components/application_manager/test/commands/hmi/CMakeLists.txt
@@ -40,7 +40,10 @@ file(GLOB SOURCES
   ${AM_SOURCE_DIR}/src/smart_object_keys.cc
   ${AM_SOURCE_DIR}/test/mock_message_helper.cc
   ${COMMANDS_TEST_SOURCE_DIR}/hmi/*
-)
+  ${COMMANDS_TEST_SOURCE_DIR}/hmi/vi_is_ready_request_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/hmi/vr_is_ready_request_test.cc 
+  ${COMMANDS_TEST_SOURCE_DIR}/hmi/ui_is_ready_request_test.cc
+  )
 
 set(LIBRARIES
   gmock
diff --git a/src/components/application_manager/test/commands/hmi/ui_is_ready_request_test.cc b/src/components/application_manager/test/commands/hmi/ui_is_ready_request_test.cc
new file mode 100644
index 0000000000..0a1ad28c79
--- /dev/null
+++ b/src/components/application_manager/test/commands/hmi/ui_is_ready_request_test.cc
@@ -0,0 +1,209 @@
+/*
+ * 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/commands/hmi/ui_is_ready_request.h"
+
+#include "gtest/gtest.h"
+#include "utils/shared_ptr.h"
+#include "smart_objects/smart_object.h"
+#include "application_manager/smart_object_keys.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/hmi_interfaces.h"
+#include "application_manager/mock_hmi_interface.h"
+#include "application_manager/mock_hmi_capabilities.h"
+#include "application_manager/policies/mock_policy_handler_interface.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/event_engine/event.h"
+
+namespace test {
+namespace components {
+namespace commands_test {
+namespace hmi_commands_test {
+
+namespace am = ::application_manager;
+
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using am::commands::MessageSharedPtr;
+using am::commands::UIIsReadyRequest;
+using am::MockMessageHelper;
+using am::event_engine::Event;
+
+typedef SharedPtr<UIIsReadyRequest> UIIsReadyRequestPtr;
+
+class UIIsReadyRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  UIIsReadyRequestTest()
+      : command_(CreateCommand<UIIsReadyRequest>())
+      , mock_message_helper_(*MockMessageHelper::message_helper_mock()) {}
+
+  void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, hmi_capabilities())
+        .WillByDefault(ReturnRef(mock_hmi_capabilities_));
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
+  void SetUpExpectations(bool is_ui_cooperating_available,
+                         bool is_send_message_to_hmi,
+                         bool is_message_contain_param,
+                         am::HmiInterfaces::InterfaceState state) {
+    EXPECT_CALL(mock_hmi_capabilities_,
+                set_is_ui_cooperating(is_ui_cooperating_available));
+
+    if (is_message_contain_param) {
+      EXPECT_CALL(app_mngr_, hmi_interfaces())
+          .WillRepeatedly(ReturnRef(mock_hmi_interfaces_));
+      EXPECT_CALL(
+          mock_hmi_interfaces_,
+          SetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI, state));
+    } else {
+      EXPECT_CALL(app_mngr_, hmi_interfaces())
+          .WillOnce(ReturnRef(mock_hmi_interfaces_));
+      EXPECT_CALL(mock_hmi_interfaces_, SetInterfaceState(_, _)).Times(0);
+    }
+
+    EXPECT_CALL(mock_hmi_interfaces_,
+                GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+        .WillOnce(Return(state));
+
+    if (is_send_message_to_hmi) {
+      ExpectSendMessagesToHMI();
+    }
+  }
+
+  void ExpectSendMessagesToHMI() {
+    smart_objects::SmartObjectSPtr get_language(CreateMessage());
+    (*get_language)[am::strings::params][am::strings::message_type] =
+        static_cast<int>(am::MessageType::kRequest);
+    (*get_language)[am::strings::msg_params] =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    EXPECT_CALL(mock_message_helper_,
+                CreateModuleInfoSO(hmi_apis::FunctionID::UI_GetLanguage, _))
+        .WillOnce(Return(get_language));
+
+    smart_objects::SmartObjectSPtr get_all_language(CreateMessage());
+    (*get_all_language)[am::strings::params][am::strings::message_type] =
+        static_cast<int>(am::MessageType::kRequest);
+    (*get_all_language)[am::strings::msg_params] =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    EXPECT_CALL(
+        mock_message_helper_,
+        CreateModuleInfoSO(hmi_apis::FunctionID::UI_GetSupportedLanguages, _))
+        .WillOnce(Return(get_all_language));
+
+    smart_objects::SmartObjectSPtr get_capabilities(CreateMessage());
+    (*get_capabilities)[am::strings::params][am::strings::message_type] =
+        static_cast<int>(am::MessageType::kRequest);
+    (*get_capabilities)[am::strings::msg_params] =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    EXPECT_CALL(mock_message_helper_,
+                CreateModuleInfoSO(hmi_apis::FunctionID::UI_GetCapabilities, _))
+        .WillOnce(Return(get_capabilities));
+
+    EXPECT_CALL(mock_hmi_capabilities_, set_handle_response_for(*get_language));
+    EXPECT_CALL(app_mngr_, ManageHMICommand(get_language));
+    EXPECT_CALL(app_mngr_, ManageHMICommand(get_all_language));
+    EXPECT_CALL(app_mngr_, ManageHMICommand(get_capabilities));
+  }
+
+  void PrepareEvent(bool is_message_contain_param,
+                    Event& event,
+                    bool is_ui_cooperating_available = false) {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    if (is_message_contain_param) {
+      (*msg)[am::strings::msg_params][am::strings::available] =
+          is_ui_cooperating_available;
+    }
+    event.set_smart_object(*msg);
+  }
+
+  UIIsReadyRequestPtr command_;
+  am::MockHmiInterfaces mock_hmi_interfaces_;
+  MockMessageHelper& mock_message_helper_;
+  application_manager_test::MockHMICapabilities mock_hmi_capabilities_;
+  policy_test::MockPolicyHandlerInterface mock_policy_handler_interface_;
+};
+
+TEST_F(UIIsReadyRequestTest,
+       OnEvent_NoKeyAvailableInMessage_HmiInterfacesIgnored) {
+  const bool is_ui_cooperating_available = false;
+  const bool is_send_message_to_hmi = true;
+  const bool is_message_contain_param = false;
+  Event event(hmi_apis::FunctionID::UI_IsReady);
+  PrepareEvent(is_message_contain_param, event);
+  SetUpExpectations(is_ui_cooperating_available,
+                    is_send_message_to_hmi,
+                    is_message_contain_param,
+                    am::HmiInterfaces::STATE_NOT_RESPONSE);
+
+  command_->on_event(event);
+}
+
+TEST_F(UIIsReadyRequestTest,
+       OnEvent_KeyAvailableEqualToFalse_StateNotAvailable) {
+  const bool is_ui_cooperating_available = false;
+  const bool is_send_message_to_hmi = false;
+  const bool is_message_contain_param = true;
+  Event event(hmi_apis::FunctionID::UI_IsReady);
+  PrepareEvent(is_message_contain_param, event);
+  SetUpExpectations(is_ui_cooperating_available,
+                    is_send_message_to_hmi,
+                    is_message_contain_param,
+                    am::HmiInterfaces::STATE_NOT_AVAILABLE);
+  command_->on_event(event);
+}
+
+TEST_F(UIIsReadyRequestTest, OnEvent_KeyAvailableEqualToTrue_StateAvailable) {
+  const bool is_ui_cooperating_available = true;
+  const bool is_send_message_to_hmi = true;
+  const bool is_message_contain_param = true;
+  Event event(hmi_apis::FunctionID::UI_IsReady);
+  PrepareEvent(is_message_contain_param, event, is_ui_cooperating_available);
+  SetUpExpectations(is_ui_cooperating_available,
+                    is_send_message_to_hmi,
+                    is_message_contain_param,
+                    am::HmiInterfaces::STATE_AVAILABLE);
+  command_->on_event(event);
+}
+
+TEST_F(UIIsReadyRequestTest, OnTimeout_SUCCESS) {
+  ExpectSendMessagesToHMI();
+  command_->onTimeOut();
+}
+
+}  // namespace mobile_commands_test
+}  // namespace commands_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/application_manager/test/commands/mobile/CMakeLists.txt b/src/components/application_manager/test/commands/mobile/CMakeLists.txt
index 01fe4ac4dd..31c8503573 100644
--- a/src/components/application_manager/test/commands/mobile/CMakeLists.txt
+++ b/src/components/application_manager/test/commands/mobile/CMakeLists.txt
@@ -46,8 +46,19 @@ set (SOURCES
   ${COMMANDS_TEST_SOURCE_DIR}/mobile/create_interaction_choice_set_test.cc
   ${COMMANDS_TEST_SOURCE_DIR}/mobile/register_app_interface_request_test.cc
   ${COMMANDS_TEST_SOURCE_DIR}/mobile/speak_request_test.cc
-  ${COMMANDS_TEST_SOURCE_DIR}/mobile/set_global_properties_request_test.cc
   ${COMMANDS_TEST_SOURCE_DIR}/mobile/alert_maneuver_request_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/show_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/alert_request_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/add_sub_menu_request_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/delete_sub_menu_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/set_media_clock_timer_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/set_global_properties_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/set_app_icon_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/set_display_layout_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/slider_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/scrollable_message_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/perform_audio_pass_thru_test.cc
+  ${COMMANDS_TEST_SOURCE_DIR}/mobile/end_audio_pass_thru_request_test.cc
 )
 
 set(LIBRARIES
diff --git a/src/components/application_manager/test/commands/mobile/add_command_request_test.cc b/src/components/application_manager/test/commands/mobile/add_command_request_test.cc
index ffba47f12d..b337acd52f 100644
--- a/src/components/application_manager/test/commands/mobile/add_command_request_test.cc
+++ b/src/components/application_manager/test/commands/mobile/add_command_request_test.cc
@@ -53,19 +53,23 @@
 namespace test {
 namespace components {
 namespace commands_test {
+namespace add_command_request {
 
 namespace am = application_manager;
+
+using am::commands::AddCommandRequest;
 using am::commands::CommandImpl;
 using am::ApplicationManager;
 using am::commands::MessageSharedPtr;
 using am::ApplicationSharedPtr;
 using am::MockMessageHelper;
 using am::MockHmiInterfaces;
+
 using ::testing::_;
-using ::utils::SharedPtr;
+using ::testing::Mock;
 using ::testing::Return;
 using ::testing::ReturnRef;
-using am::commands::AddCommandRequest;
+using ::utils::SharedPtr;
 using ::test::components::application_manager_test::MockApplication;
 
 namespace custom_str = utils::custom_string;
@@ -73,8 +77,6 @@ namespace strings = ::application_manager::strings;
 namespace hmi_response = ::application_manager::hmi_response;
 
 namespace {
-const hmi_apis::FunctionID::eType kInvalidFunctionId =
-    hmi_apis::FunctionID::INVALID_ENUM;
 const int32_t kCommandId = 1;
 const uint32_t kAppId = 1u;
 const uint32_t kCmdId = 1u;
@@ -84,8 +86,11 @@ const uint32_t kConnectionKey = 2u;
 class AddCommandRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
  public:
-  sync_primitives::Lock lock_;
+  AddCommandRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock())
+      , mock_app_(CreateMockApp()) {}
 
+ protected:
   MessageSharedPtr CreateFullParamsVRSO() {
     MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
     (*msg)[strings::params][strings::connection_key] = kConnectionKey;
@@ -102,111 +107,156 @@ class AddCommandRequestTest
 
     return msg;
   }
+
+  MessageSharedPtr CreateFullParamsUISO() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    msg_params[am::strings::cmd_icon] = 1;
+    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
+
+  MessageSharedPtr CreateParamsUISOWithOutCmdIcon() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
+
+  void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, application(kConnectionKey))
+        .WillByDefault(Return(mock_app_));
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kConnectionKey));
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(hmi_interfaces_));
+  }
+
+  void TearDown() OVERRIDE {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
+
+  void ResultCommandExpectations(MessageSharedPtr msg,
+                                 const std::string& info) {
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::success].asBool(),
+              true);
+    EXPECT_EQ(
+        (*msg)[am::strings::msg_params][am::strings::result_code].asInt(),
+        static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::info].asString(),
+              info);
+  }
+
+  sync_primitives::Lock lock_;
+  NiceMock<MockHmiInterfaces> hmi_interfaces_;
+  MockMessageHelper& mock_message_helper_;
+  MockAppPtr mock_app_;
 };
 
 TEST_F(AddCommandRequestTest, OnTimeout_GENERIC_ERROR) {
-  MessageSharedPtr msg_vr = CreateMessage(smart_objects::SmartType_Map);
-  (*msg_vr)[strings::msg_params][strings::result_code] =
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[strings::msg_params][strings::result_code] =
       am::mobile_api::Result::GENERIC_ERROR;
-  (*msg_vr)[strings::msg_params][strings::success] = false;
+  (*msg)[strings::msg_params][strings::success] = false;
+  (*msg)[strings::params][strings::connection_key] = kConnectionKey;
 
-  utils::SharedPtr<AddCommandRequest> req_vr =
-      CreateCommand<AddCommandRequest>();
+  utils::SharedPtr<AddCommandRequest> command =
+      CreateCommand<AddCommandRequest>(msg);
 
-  MockAppPtr mock_app = CreateMockApp();
-  EXPECT_CALL(app_mngr_, application(_)).WillOnce(Return(mock_app));
-  ON_CALL(*mock_app, app_id()).WillByDefault(Return(kConnectionKey));
-  ON_CALL(*mock_app, get_grammar_id()).WillByDefault(Return(kConnectionKey));
-  ON_CALL(*mock_app, RemoveCommand(_)).WillByDefault(Return());
+  ON_CALL(*mock_app_, get_grammar_id()).WillByDefault(Return(kConnectionKey));
+  ON_CALL(*mock_app_, RemoveCommand(_)).WillByDefault(Return());
 
-  MockMessageHelper* mock_message_helper =
-      MockMessageHelper::message_helper_mock();
   EXPECT_CALL(
-      *mock_message_helper,
+      mock_message_helper_,
       CreateNegativeResponse(_, _, _, am::mobile_api::Result::GENERIC_ERROR))
-      .WillOnce(Return(msg_vr));
+      .WillOnce(Return(msg));
 
-  MessageSharedPtr vr_command_result;
+  MessageSharedPtr command_result;
   EXPECT_CALL(
       app_mngr_,
       ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
-      .WillOnce(DoAll(SaveArg<0>(&vr_command_result), Return(true)));
+      .WillOnce(DoAll(SaveArg<0>(&command_result), Return(true)));
 
-  req_vr->onTimeOut();
-  EXPECT_EQ(
-      (*vr_command_result)[strings::msg_params][strings::success].asBool(),
-      false);
+  command->onTimeOut();
+  EXPECT_EQ((*command_result)[strings::msg_params][strings::success].asBool(),
+            false);
   EXPECT_EQ(
-      (*vr_command_result)[strings::msg_params][strings::result_code].asInt(),
+      (*command_result)[strings::msg_params][strings::result_code].asInt(),
       static_cast<int32_t>(am::mobile_api::Result::GENERIC_ERROR));
 }
 
-TEST_F(AddCommandRequestTest, OnEvent_VR_UNSUPPORTED_RESOURCE) {
+TEST_F(AddCommandRequestTest, OnEvent_VR_HmiSendSuccess_UNSUPPORTED_RESOURCE) {
   MessageSharedPtr msg_vr = CreateFullParamsVRSO();
   (*msg_vr)[strings::msg_params][strings::menu_params]
            [am::hmi_request::parent_id] = 10u;
   (*msg_vr)[strings::msg_params][strings::menu_params][strings::menu_name] =
       "menu_name";
 
-  utils::SharedPtr<AddCommandRequest> req_vr =
+  utils::SharedPtr<AddCommandRequest> command =
       CreateCommand<AddCommandRequest>(msg_vr);
 
-  MockAppPtr mock_app = CreateMockApp();
-  ON_CALL(app_mngr_, application(kConnectionKey))
-      .WillByDefault(Return(mock_app));
-  ON_CALL(*mock_app, app_id()).WillByDefault(Return(1));
-  ON_CALL(*mock_app, FindSubMenu(_)).WillByDefault(Return(&(*msg_vr)));
-  MockHmiInterfaces hmi_interfaces;
-  ON_CALL(app_mngr_, hmi_interfaces()).WillByDefault(ReturnRef(hmi_interfaces));
-  ON_CALL(hmi_interfaces, GetInterfaceFromFunction(_))
-      .WillByDefault(
-          Return(am::HmiInterfaces::HMI_INTERFACE_BasicCommunication));
-  ON_CALL(hmi_interfaces, GetInterfaceState(_))
-      .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));
+  ON_CALL(*mock_app_, FindSubMenu(_)).WillByDefault(Return(&(*msg_vr)));
+  ON_CALL(hmi_interfaces_, GetInterfaceFromFunction(_))
+      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_VR));
+  ON_CALL(hmi_interfaces_, GetInterfaceState(_))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
 
   MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
   (*msg)[strings::params][hmi_response::code] =
       hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
-  (*msg)[strings::msg_params][strings::info] = "info";
+  (*msg)[am::strings::msg_params][am::strings::info] =
+      "VR is not supported by system";
   (*msg)[strings::msg_params][strings::cmd_id] = kCommandId;
 
   Event event(hmi_apis::FunctionID::VR_AddCommand);
   event.set_smart_object(*msg);
 
   smart_objects::SmartObject* ptr = NULL;
-  ON_CALL(*mock_app, FindCommand(kCmdId)).WillByDefault(Return(ptr));
-  EXPECT_EQ(NULL, ptr);
+  ON_CALL(*mock_app_, FindCommand(kCmdId)).WillByDefault(Return(ptr));
 
-  MockMessageHelper* mock_message_helper =
-      MockMessageHelper::message_helper_mock();
-  ON_CALL(*mock_message_helper, HMIToMobileResult(_))
+  ON_CALL(mock_message_helper_, HMIToMobileResult(_))
       .WillByDefault(Return(mobile_apis::Result::SUCCESS));
 
-  EXPECT_CALL(*mock_app, AddCommand(kCmdId, (*msg_vr)[strings::msg_params]));
+  EXPECT_CALL(*mock_app_, AddCommand(kCmdId, (*msg_vr)[strings::msg_params]));
 
   am::CommandsMap commands_map;
-  ON_CALL(*mock_app, commands_map())
+  ON_CALL(*mock_app_, commands_map())
       .WillByDefault(
           Return(DataAccessor<am::CommandsMap>(commands_map, lock_)));
 
-  EXPECT_CALL(
-      app_mngr_,
-      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
-      .WillOnce(Return(true))
-      .WillOnce(Return(true));
-
-  EXPECT_CALL(*mock_app, UpdateHash());
+  EXPECT_CALL(*mock_app_, UpdateHash());
 
   MessageSharedPtr msg_ui(CreateMessage(smart_objects::SmartType_Map));
   (*msg_ui)[am::strings::params][am::hmi_response::code] =
       hmi_apis::Common_Result::SUCCESS;
-  (*msg_ui)[am::strings::params][am::strings::info] = "info";
 
   Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
   event_ui.set_smart_object(*msg_ui);
 
-  req_vr->Run();
-  req_vr->on_event(event_ui);
+  command->Run();
+  command->on_event(event_ui);
 
   MessageSharedPtr vr_command_result;
   EXPECT_CALL(
@@ -214,21 +264,80 @@ TEST_F(AddCommandRequestTest, OnEvent_VR_UNSUPPORTED_RESOURCE) {
       ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
       .WillOnce(DoAll(SaveArg<0>(&vr_command_result), Return(true)));
 
-  req_vr->on_event(event);
+  command->on_event(event);
 
-  EXPECT_EQ(
-      (*vr_command_result)[strings::msg_params][strings::success].asBool(),
-      true);
-  EXPECT_EQ(
-      (*vr_command_result)[strings::msg_params][strings::result_code].asInt(),
-      static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
-  if ((*vr_command_result)[strings::msg_params].keyExists(strings::info)) {
-    EXPECT_EQ(
-        (*vr_command_result)[strings::msg_params][strings::info].asString(),
-        (*msg)[strings::msg_params][strings::info].asString());
-  }
+  ResultCommandExpectations(vr_command_result, "VR is not supported by system");
+}
+
+TEST_F(AddCommandRequestTest, OnEvent_UI_HmiSendSuccess_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr msg_vr = CreateFullParamsUISO();
+  (*msg_vr)[am::strings::msg_params][am::strings::vr_commands][0] =
+      "vr_command";
+
+  utils::SharedPtr<AddCommandRequest> command =
+      CreateCommand<AddCommandRequest>(msg_vr);
+
+  ON_CALL(*mock_app_, FindSubMenu(_)).WillByDefault(Return(&(*msg_vr)));
+
+  ON_CALL(hmi_interfaces_, GetInterfaceFromFunction(_))
+      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_UI));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*msg)[am::strings::msg_params][am::strings::info] =
+      "UI is not supported by system";
+  (*msg)[am::strings::msg_params][am::strings::cmd_id] = kCommandId;
+
+  Event event(hmi_apis::FunctionID::UI_AddCommand);
+  event.set_smart_object(*msg);
+
+  smart_objects::SmartObject* ptr = NULL;
+  ON_CALL(*mock_app_, FindCommand(kCmdId)).WillByDefault(Return(ptr));
+  EXPECT_EQ(NULL, ptr);
+
+  ON_CALL(mock_message_helper_, HMIToMobileResult(_))
+      .WillByDefault(Return(mobile_apis::Result::SUCCESS));
+
+  ON_CALL(mock_message_helper_, VerifyImage(_, _, _))
+      .WillByDefault(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_,
+              AddCommand(kCmdId, (*msg_vr)[am::strings::msg_params]));
+
+  am::CommandsMap commands_map;
+  ON_CALL(*mock_app_, commands_map())
+      .WillByDefault(
+          Return(DataAccessor<am::CommandsMap>(commands_map, lock_)));
+
+  EXPECT_CALL(*mock_app_, UpdateHash());
+
+  MessageSharedPtr msg_ui(CreateMessage(smart_objects::SmartType_Map));
+  (*msg_ui)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::SUCCESS;
+
+  Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
+  event_vr.set_smart_object(*msg_vr);
+
+  command->Run();
+  command->on_event(event_vr);
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
+
+  command->on_event(event);
+
+  ResultCommandExpectations(ui_command_result, "UI is not supported by system");
 }
 
+}  // namespace add_command_test
 }  // namespace commands_test
 }  // namespace components
 }  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/add_sub_menu_request_test.cc b/src/components/application_manager/test/commands/mobile/add_sub_menu_request_test.cc
index 81631b24ab..7eae10d10b 100644
--- a/src/components/application_manager/test/commands/mobile/add_sub_menu_request_test.cc
+++ b/src/components/application_manager/test/commands/mobile/add_sub_menu_request_test.cc
@@ -33,184 +33,103 @@
 #include <stdint.h>
 #include <string>
 
+#include "application_manager/commands/mobile/add_sub_menu_request.h"
+
 #include "gtest/gtest.h"
-#include "utils/shared_ptr.h"
-#include "smart_objects/smart_object.h"
-#include "application_manager/smart_object_keys.h"
 #include "application_manager/commands/commands_test.h"
 #include "application_manager/commands/command_request_test.h"
-#include "application_manager/application.h"
 #include "application_manager/mock_application_manager.h"
 #include "application_manager/mock_application.h"
 #include "application_manager/mock_message_helper.h"
 #include "application_manager/event_engine/event.h"
-#include "application_manager/commands/mobile/add_sub_menu_request.h"
-#include "interfaces/MOBILE_API.h"
-#include "application_manager/policies/policy_handler_interface.h"
+#include "application_manager/mock_hmi_interface.h"
 
 namespace test {
 namespace components {
 namespace commands_test {
 namespace mobile_commands_test {
 
-using ::testing::_;
-using ::testing::Return;
-using ::testing::ReturnRef;
 namespace am = ::application_manager;
 using am::commands::AddSubMenuRequest;
 using am::commands::MessageSharedPtr;
 using am::event_engine::Event;
+using am::MockHmiInterfaces;
+using am::MockMessageHelper;
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
 
 typedef SharedPtr<AddSubMenuRequest> AddSubMenuPtr;
 
 namespace {
 const uint32_t kConnectionKey = 2u;
-const int32_t kMenuId = 5;
 }  // namespace
 
 class AddSubMenuRequestTest
-    : public CommandRequestTest<CommandsTestMocks::kIsNice> {};
-
-TEST_F(AddSubMenuRequestTest, OnEvent_UnknownEvent_UNSUCCESS) {
-  Event event(hmi_apis::FunctionID::INVALID_ENUM);
-  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>());
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  AddSubMenuRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock()) {}
+  MockMessageHelper& mock_message_helper_;
+};
+
+TEST_F(AddSubMenuRequestTest, OnEvent_UI_UNSUPPORTED_RESOURCE) {
+  const uint32_t menu_id = 10u;
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+  (*msg)[am::strings::msg_params][am::strings::menu_id] = menu_id;
+
+  utils::SharedPtr<AddSubMenuRequest> command =
+      CreateCommand<AddSubMenuRequest>(msg);
+
+  MockAppPtr mock_app = CreateMockApp();
+  ON_CALL(app_mngr_, application(kConnectionKey))
+      .WillByDefault(Return(mock_app));
+  ON_CALL(*mock_app, app_id()).WillByDefault(Return(kConnectionKey));
+  EXPECT_CALL(*mock_app, AddSubMenu(menu_id, _));
+  EXPECT_CALL(*mock_app, UpdateHash());
+
+  MessageSharedPtr ev_msg = CreateMessage(smart_objects::SmartType_Map);
+  (*ev_msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*ev_msg)[am::strings::msg_params][am::strings::info] = "info";
 
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
-
-  command->on_event(event);
-}
-
-TEST_F(AddSubMenuRequestTest, OnEvent_SUCCESS) {
   Event event(hmi_apis::FunctionID::UI_AddSubMenu);
-  MessageSharedPtr event_msg(CreateMessage(smart_objects::SmartType_Map));
-  (*event_msg)[am::strings::params][am::hmi_response::code] =
-      mobile_apis::Result::SUCCESS;
-  (*event_msg)[am::strings::msg_params] = 0;
+  event.set_smart_object(*ev_msg);
 
-  event.set_smart_object(*event_msg);
+  MockHmiInterfaces hmi_interfaces;
+  ON_CALL(app_mngr_, hmi_interfaces()).WillByDefault(ReturnRef(hmi_interfaces));
+  EXPECT_CALL(hmi_interfaces,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillOnce(Return(am::HmiInterfaces::STATE_AVAILABLE));
 
-  MessageSharedPtr command_msg(CreateMessage(smart_objects::SmartType_Map));
-  (*command_msg)[am::strings::params][am::strings::connection_key] =
-      kConnectionKey;
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE))
+      .WillOnce(Return(mobile_apis::Result::UNSUPPORTED_RESOURCE));
 
-  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg));
-
-  MockAppPtr app(CreateMockApp());
-  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
-
-  MessageSharedPtr result_msg(
-      CatchMobileCommandResult(CallOnEvent(*command, event)));
-  const mobile_apis::Result::eType kReceivedResult =
-      static_cast<mobile_apis::Result::eType>(
-          (*result_msg)[am::strings::msg_params][am::strings::result_code]
-              .asInt());
-  EXPECT_EQ(mobile_apis::Result::SUCCESS, kReceivedResult);
-}
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
 
-TEST_F(AddSubMenuRequestTest, Run_ApplicationIsNotRegistered_UNSUCCESS) {
-  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>());
-
-  EXPECT_CALL(app_mngr_, application(_))
-      .WillOnce(Return(ApplicationSharedPtr()));
-
-  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
-  const mobile_apis::Result::eType kReceivedResult =
-      static_cast<mobile_apis::Result::eType>(
-          (*result_msg)[am::strings::msg_params][am::strings::result_code]
-              .asInt());
-  EXPECT_EQ(mobile_apis::Result::APPLICATION_NOT_REGISTERED, kReceivedResult);
-}
-
-TEST_F(AddSubMenuRequestTest, Run_InvalidSubMenuId_UNSUCCESS) {
-  MessageSharedPtr command_msg(CreateMessage(smart_objects::SmartType_Map));
-  (*command_msg)[am::strings::msg_params][am::strings::menu_id] = kMenuId;
-  (*command_msg)[am::strings::params][am::strings::connection_key] =
-      kConnectionKey;
-
-  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg));
-
-  MockAppPtr app(CreateMockApp());
-  MessageSharedPtr dummy_sub_menu(CreateMessage(smart_objects::SmartType_Null));
-  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
-  EXPECT_CALL(*app, FindSubMenu(kMenuId))
-      .WillOnce(Return(dummy_sub_menu.get()));
-
-  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
-  const mobile_apis::Result::eType kReceivedResult =
-      static_cast<mobile_apis::Result::eType>(
-          (*result_msg)[am::strings::msg_params][am::strings::result_code]
-              .asInt());
-  EXPECT_EQ(mobile_apis::Result::INVALID_ID, kReceivedResult);
-}
-
-TEST_F(AddSubMenuRequestTest, Run_DuplicatedSubMenuName_UNSUCCESS) {
-  MessageSharedPtr command_msg(CreateMessage(smart_objects::SmartType_Map));
-  (*command_msg)[am::strings::msg_params][am::strings::menu_id] = kMenuId;
-  (*command_msg)[am::strings::params][am::strings::connection_key] =
-      kConnectionKey;
-
-  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg));
-
-  MockAppPtr app(CreateMockApp());
-
-  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
-  EXPECT_CALL(*app, FindSubMenu(kMenuId))
-      .WillOnce(Return(static_cast<SmartObject*>(NULL)));
-  EXPECT_CALL(*app, IsSubMenuNameAlreadyExist(_)).WillOnce(Return(true));
-
-  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
-  const mobile_apis::Result::eType kReceivedResult =
-      static_cast<mobile_apis::Result::eType>(
-          (*result_msg)[am::strings::msg_params][am::strings::result_code]
-              .asInt());
-  EXPECT_EQ(mobile_apis::Result::DUPLICATE_NAME, kReceivedResult);
-}
-
-TEST_F(AddSubMenuRequestTest, Run_NotValidSubMenuName_UNSUCCESS) {
-  MessageSharedPtr command_msg(CreateMessage(smart_objects::SmartType_Map));
-  (*command_msg)[am::strings::msg_params][am::strings::menu_id] = kMenuId;
-  (*command_msg)[am::strings::params][am::strings::connection_key] =
-      kConnectionKey;
-  // Not valid sub-menu name.
-  (*command_msg)[am::strings::msg_params][am::strings::menu_name] = "\t\n";
-
-  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg));
-
-  MockAppPtr app(CreateMockApp());
-  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
-  EXPECT_CALL(*app, FindSubMenu(kMenuId))
-      .WillOnce(Return(static_cast<SmartObject*>(NULL)));
-
-  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
-  const mobile_apis::Result::eType kReceivedResult =
-      static_cast<mobile_apis::Result::eType>(
-          (*result_msg)[am::strings::msg_params][am::strings::result_code]
-              .asInt());
-  EXPECT_EQ(mobile_apis::Result::INVALID_DATA, kReceivedResult);
-}
+  command->on_event(event);
 
-TEST_F(AddSubMenuRequestTest, Run_SUCCESS) {
-  MessageSharedPtr command_msg(CreateMessage(smart_objects::SmartType_Map));
-  (*command_msg)[am::strings::msg_params][am::strings::menu_id] = kMenuId;
-  (*command_msg)[am::strings::params][am::strings::connection_key] =
-      kConnectionKey;
-  (*command_msg)[am::strings::msg_params][am::strings::menu_name] =
-      "valid_sub_menu_name";
-  (*command_msg)[am::strings::msg_params][am::strings::position] =
-      "test_position";
-
-  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg));
-
-  MockAppPtr app(CreateMockApp());
-  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
-  EXPECT_CALL(*app, FindSubMenu(kMenuId))
-      .WillOnce(Return(static_cast<SmartObject*>(NULL)));
-
-  MessageSharedPtr result_msg(CatchHMICommandResult(CallRun(*command)));
-  const hmi_apis::FunctionID::eType kReceivedResult =
-      static_cast<hmi_apis::FunctionID::eType>(
-          (*result_msg)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(hmi_apis::FunctionID::UI_AddSubMenu, kReceivedResult);
+  EXPECT_EQ((*ui_command_result)[am::strings::msg_params][am::strings::success]
+                .asBool(),
+            true);
+  EXPECT_EQ(
+      (*ui_command_result)[am::strings::msg_params][am::strings::result_code]
+          .asInt(),
+      static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+  if ((*ui_command_result)[am::strings::msg_params].keyExists(
+          am::strings::info)) {
+    EXPECT_FALSE(
+        (*ui_command_result)[am::strings::msg_params][am::strings::info]
+            .asString()
+            .empty());
+  }
+  Mock::VerifyAndClearExpectations(&mock_message_helper_);
 }
 
 }  // namespace mobile_commands_test
diff --git a/src/components/application_manager/test/commands/mobile/alert_request_test.cc b/src/components/application_manager/test/commands/mobile/alert_request_test.cc
index 2843008820..2c80f6e5e2 100644
--- a/src/components/application_manager/test/commands/mobile/alert_request_test.cc
+++ b/src/components/application_manager/test/commands/mobile/alert_request_test.cc
@@ -32,206 +32,180 @@
 
 #include <stdint.h>
 #include <string>
+#include <set>
+
+#include "application_manager/commands/mobile/alert_request.h"
 
 #include "gtest/gtest.h"
-#include "utils/shared_ptr.h"
-#include "smart_objects/smart_object.h"
-#include "application_manager/smart_object_keys.h"
-#include "application_manager/commands/commands_test.h"
 #include "application_manager/commands/command_request_test.h"
-#include "application_manager/application.h"
-#include "application_manager/mock_application_manager.h"
 #include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
 #include "application_manager/mock_message_helper.h"
-#include "event_engine/event.h"
-#include "application_manager/commands/mobile/alert_request.h"
-#include "interfaces/MOBILE_API.h"
-#include "application_manager/policies/policy_handler_interface.h"
-#include "application_manager/policies/mock_policy_handler_interface.h"
+#include "application_manager/event_engine/event.h"
+#include "application_manager/mock_hmi_interface.h"
 
 namespace test {
 namespace components {
 namespace commands_test {
-namespace mobile_commands_test {
+namespace alert_request {
 
-using ::testing::_;
-using ::testing::Return;
-using ::testing::ReturnRef;
-using ::testing::AtLeast;
-namespace am = ::application_manager;
+namespace am = application_manager;
 using am::commands::AlertRequest;
+using am::commands::CommandImpl;
 using am::commands::MessageSharedPtr;
-using am::event_engine::Event;
 using am::MockMessageHelper;
+using am::MockHmiInterfaces;
+using ::utils::SharedPtr;
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
 
-typedef SharedPtr<AlertRequest> CommandPtr;
+namespace {
+const int32_t kCommandId = 1;
+const uint32_t kAppId = 1u;
+const uint32_t kCmdId = 1u;
+const uint32_t kConnectionKey = 2u;
+}  // namespace
 
 class AlertRequestTest : public CommandRequestTest<CommandsTestMocks::kIsNice> {
- protected:
-  NiceMock<policy_test::MockPolicyHandlerInterface> policy_interface_;
-};
-
-class CallOnTimeOut {
  public:
-  CallOnTimeOut(CommandRequestImpl& command) : command_(command) {}
+  AlertRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock())
+      , mock_app_(CreateMockApp()) {}
+
+ protected:
+  MessageSharedPtr CreateFullParamsUISO() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    msg_params[am::strings::cmd_icon] = 1;
+    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
 
-  void operator()() {
-    command_.onTimeOut();
+  void ResultCommandExpectations(MessageSharedPtr msg,
+                                 const std::string& info) {
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::success].asBool(),
+              true);
+    EXPECT_EQ(
+        (*msg)[am::strings::msg_params][am::strings::result_code].asInt(),
+        static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::info].asString(),
+              info);
   }
 
-  CommandRequestImpl& command_;
+  void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, application(kConnectionKey))
+        .WillByDefault(Return(mock_app_));
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kConnectionKey));
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(hmi_interfaces_));
+
+    ON_CALL(hmi_interfaces_,
+            GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+        .WillByDefault(
+            Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
+
+    ON_CALL(hmi_interfaces_,
+            GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_TTS))
+        .WillByDefault(
+            Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
+  }
+  void TearDown() OVERRIDE {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
+  sync_primitives::Lock lock_;
+  NiceMock<MockHmiInterfaces> hmi_interfaces_;
+  MockMessageHelper& mock_message_helper_;
+  MockAppPtr mock_app_;
 };
 
-TEST_F(AlertRequestTest, OnTimeOut_UNSUCCESS) {
-  MessageSharedPtr msg(CreateMessage(smart_objects::SmartType_Map));
-  (*msg)[am::strings::msg_params][am::strings::soft_buttons] = 0;
-  CommandPtr command(CreateCommand<AlertRequest>(msg));
+TEST_F(AlertRequestTest, OnTimeout_GENERIC_ERROR) {
+  MessageSharedPtr command_msg = CreateMessage(smart_objects::SmartType_Map);
+  (*command_msg)[am::strings::msg_params][am::strings::result_code] =
+      am::mobile_api::Result::GENERIC_ERROR;
+  (*command_msg)[am::strings::msg_params][am::strings::success] = false;
+  (*command_msg)[am::strings::params][am::strings::connection_key] =
+      kConnectionKey;
 
-  command->onTimeOut();
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
-}
-
-TEST_F(AlertRequestTest, OnTimeOut_SUCCESS) {
-  CommandPtr command(CreateCommand<AlertRequest>());
+  utils::SharedPtr<AlertRequest> command = CreateCommand<AlertRequest>();
 
-  MessageSharedPtr sended_result_msg(
-      CreateMessage(smart_objects::SmartType_Null));
   EXPECT_CALL(
-      *MockMessageHelper::message_helper_mock(),
-      CreateNegativeResponse(_, _, _, mobile_apis::Result::GENERIC_ERROR))
-      .WillOnce(Return(sended_result_msg));
-
-  MessageSharedPtr received_result_msg(
-      CatchMobileCommandResult(CallOnTimeOut(*command)));
-  EXPECT_EQ(sended_result_msg, received_result_msg);
-}
-
-TEST_F(AlertRequestTest, Run_ApplicationIsNotRegistered_UNSUCCESS) {
-  CommandPtr command(CreateCommand<AlertRequest>());
-
-  ON_CALL(app_mngr_, application(_))
-      .WillByDefault(Return(ApplicationSharedPtr()));
-
-  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
-  EXPECT_EQ(mobile_apis::Result::APPLICATION_NOT_REGISTERED,
-            static_cast<mobile_apis::Result::eType>(
-                (*result_msg)[am::strings::msg_params][am::strings::result_code]
-                    .asInt()));
-}
-
-TEST_F(AlertRequestTest, Run_AlertFrequencyIsTooHigh_UNSUCCESS) {
-  CommandPtr command(CreateCommand<AlertRequest>());
-
-  MockAppPtr app(CreateMockApp());
-  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(app));
+      mock_message_helper_,
+      CreateNegativeResponse(_, _, _, am::mobile_api::Result::GENERIC_ERROR))
+      .WillOnce(Return(command_msg));
 
-  ON_CALL(*app, hmi_level())
-      .WillByDefault(Return(mobile_apis::HMILevel::HMI_BACKGROUND));
-  ON_CALL(*app, AreCommandLimitsExceeded(_, _)).WillByDefault(Return(true));
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
 
-  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
-  EXPECT_EQ(mobile_apis::Result::REJECTED,
-            static_cast<mobile_apis::Result::eType>(
-                (*result_msg)[am::strings::msg_params][am::strings::result_code]
-                    .asInt()));
+  command->onTimeOut();
+  EXPECT_EQ((*ui_command_result)[am::strings::msg_params][am::strings::success]
+                .asBool(),
+            false);
+  EXPECT_EQ(
+      (*ui_command_result)[am::strings::msg_params][am::strings::result_code]
+          .asInt(),
+      static_cast<int32_t>(am::mobile_api::Result::GENERIC_ERROR));
 }
 
-TEST_F(AlertRequestTest, Run_FailToProcessSoftButtons_UNSUCCESS) {
-  const mobile_apis::Result::eType kResultCode =
-      mobile_apis::Result::INVALID_ENUM;
+TEST_F(AlertRequestTest, OnEvent_UI_HmiSendSuccess_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr command_msg = CreateFullParamsUISO();
+  (*command_msg)[am::strings::msg_params][am::strings::menu_params]
+                [am::hmi_request::parent_id] = 10u;
+  (*command_msg)[am::strings::msg_params][am::strings::menu_params]
+                [am::strings::menu_name] = "menu_name";
 
-  CommandPtr command(CreateCommand<AlertRequest>());
+  utils::SharedPtr<AlertRequest> command =
+      CreateCommand<AlertRequest>(command_msg);
 
-  MockAppPtr app(CreateMockApp());
-  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(app));
-  ON_CALL(*app, hmi_level())
-      .WillByDefault(Return(mobile_apis::HMILevel::HMI_BACKGROUND));
-  ON_CALL(*app, AreCommandLimitsExceeded(_, _)).WillByDefault(Return(false));
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*msg)[am::strings::msg_params][am::strings::cmd_id] = kCommandId;
+  (*msg)[am::strings::msg_params][am::strings::info] =
+      "UI is not supported by system";
 
-  ON_CALL(app_mngr_, GetPolicyHandler())
-      .WillByDefault(ReturnRef(policy_interface_));
-  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
-              ProcessSoftButtons(_, _, _, _)).WillOnce(Return(kResultCode));
+  ON_CALL(mock_message_helper_, HMIToMobileResult(_))
+      .WillByDefault(Return(mobile_apis::Result::SUCCESS));
 
-  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
-  EXPECT_EQ(kResultCode,
-            static_cast<mobile_apis::Result::eType>(
-                (*result_msg)[am::strings::msg_params][am::strings::result_code]
-                    .asInt()));
-}
+  MessageSharedPtr msg_tts = CreateMessage();
+  (*msg_tts)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::SUCCESS;
+  Event event_vr(hmi_apis::FunctionID::TTS_Speak);
+  event_vr.set_smart_object(*msg_tts);
 
-TEST_F(AlertRequestTest, Run_MandatoryParametersAreMissed_UNSUCCESS) {
-  CommandPtr command(CreateCommand<AlertRequest>());
-
-  MockAppPtr app(CreateMockApp());
-  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(app));
-  ON_CALL(*app, hmi_level())
-      .WillByDefault(Return(mobile_apis::HMILevel::HMI_BACKGROUND));
-  ON_CALL(*app, AreCommandLimitsExceeded(_, _)).WillByDefault(Return(false));
-
-  ON_CALL(app_mngr_, GetPolicyHandler())
-      .WillByDefault(ReturnRef(policy_interface_));
-  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
-              ProcessSoftButtons(_, _, _, _))
-      .WillOnce(Return(mobile_apis::Result::SUCCESS));
-
-  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
-  EXPECT_EQ(mobile_apis::Result::INVALID_DATA,
-            static_cast<mobile_apis::Result::eType>(
-                (*result_msg)[am::strings::msg_params][am::strings::result_code]
-                    .asInt()));
-}
+  command->on_event(event_vr);
 
-TEST_F(AlertRequestTest, Run_MandatoryParametersAreInvalid_UNSUCCESS) {
-  MessageSharedPtr msg(CreateMessage(smart_objects::SmartType_Map));
-  (*msg)[am::strings::msg_params][am::strings::alert_text1] = 0;
-  (*msg)[am::strings::msg_params][am::strings::alert_text2] =
-      "invalid\t\nParam";
-
-  CommandPtr command(CreateCommand<AlertRequest>(msg));
-
-  MockAppPtr app(CreateMockApp());
-  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(app));
-  ON_CALL(*app, hmi_level())
-      .WillByDefault(Return(mobile_apis::HMILevel::HMI_BACKGROUND));
-  ON_CALL(*app, AreCommandLimitsExceeded(_, _)).WillByDefault(Return(false));
-
-  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
-  EXPECT_EQ(mobile_apis::Result::INVALID_DATA,
-            static_cast<mobile_apis::Result::eType>(
-                (*result_msg)[am::strings::msg_params][am::strings::result_code]
-                    .asInt()));
-}
+  Event event(hmi_apis::FunctionID::UI_Alert);
+  event.set_smart_object(*msg);
 
-TEST_F(AlertRequestTest, Run_SUCCESS) {
-  MessageSharedPtr msg(CreateMessage(smart_objects::SmartType_Map));
-  (*msg)[am::strings::msg_params][am::strings::alert_text1] = "alert_text1";
-  (*msg)[am::strings::msg_params][am::strings::alert_text2] = "alert_text2";
-  (*msg)[am::strings::msg_params][am::strings::tts_chunks][0]
-        [am::strings::text] = "alert_text2";
-
-  CommandPtr command(CreateCommand<AlertRequest>(msg));
-
-  MockAppPtr app(CreateMockApp());
-  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(app));
-  ON_CALL(*app, hmi_level())
-      .WillByDefault(Return(mobile_apis::HMILevel::HMI_BACKGROUND));
-  ON_CALL(*app, AreCommandLimitsExceeded(_, _)).WillByDefault(Return(false));
-
-  ON_CALL(app_mngr_, GetPolicyHandler())
-      .WillByDefault(ReturnRef(policy_interface_));
-  EXPECT_CALL(*MockMessageHelper::message_helper_mock(),
-              ProcessSoftButtons(_, _, _, _))
-      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
 
-  EXPECT_CALL(this->app_mngr_, ManageHMICommand(_))
-      .Times(AtLeast(1))
-      .WillRepeatedly(Return(true));
+  command->on_event(event);
 
-  command->Run();
+  ResultCommandExpectations(ui_command_result, "UI is not supported by system");
 }
 
-}  // namespace mobile_commands_test
+}  // namespace alert_request
 }  // namespace commands_test
 }  // namespace components
-}  // namespace test
+}  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/change_registration_test.cc b/src/components/application_manager/test/commands/mobile/change_registration_test.cc
index c0f1901dd5..a2a137d0f4 100644
--- a/src/components/application_manager/test/commands/mobile/change_registration_test.cc
+++ b/src/components/application_manager/test/commands/mobile/change_registration_test.cc
@@ -55,6 +55,7 @@
 namespace test {
 namespace components {
 namespace commands_test {
+namespace change_registration_request {
 
 namespace am = application_manager;
 using am::commands::CommandImpl;
@@ -64,6 +65,7 @@ using am::ApplicationSharedPtr;
 using am::MockMessageHelper;
 using am::MockHmiInterfaces;
 using ::testing::_;
+using ::testing::Mock;
 using ::utils::SharedPtr;
 using ::testing::Return;
 using ::testing::ReturnRef;
@@ -84,8 +86,9 @@ const uint32_t kConnectionKey = 2u;
 class ChangeRegistrationRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
  public:
-  sync_primitives::Lock app_set_lock_;
-  sync_primitives::Lock lock_;
+  ChangeRegistrationRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock())
+      , mock_app_(CreateMockApp()) {}
 
   MessageSharedPtr CreateMsgFromMobile() {
     MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
@@ -147,6 +150,9 @@ class ChangeRegistrationRequestTest
                              hmi_apis::Common_Result::UNSUPPORTED_RESOURCE) {
     MessageSharedPtr msg_from_mobile = CreateMsgFromMobile();
 
+    ON_CALL(mock_message_helper_, HMIToMobileResult(_))
+        .WillByDefault(Return(mobile_response));
+
     utils::SharedPtr<ChangeRegistrationRequest> command =
         CreateCommand<ChangeRegistrationRequest>(msg_from_mobile);
     MockAppPtr mock_app = CreateMockApp();
@@ -217,24 +223,80 @@ class ChangeRegistrationRequestTest
     (*msg)[strings::msg_params][strings::info] = info;
   }
 
+  MessageSharedPtr CreateFullParamsUISO() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    msg_params[am::strings::cmd_icon] = 1;
+    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
+
+  void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, application(kConnectionKey))
+        .WillByDefault(Return(mock_app_));
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kConnectionKey));
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(hmi_interfaces_));
+    ON_CALL(app_mngr_, hmi_capabilities())
+        .WillByDefault(ReturnRef(hmi_capabilities_));
+  }
+
+  void TearDown() OVERRIDE {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
+
+  void ExpectationsHmiCapabilities(
+      smart_objects::SmartObjectSPtr supported_languages) {
+    EXPECT_CALL(hmi_capabilities_, ui_supported_languages())
+        .WillOnce(Return(supported_languages.get()));
+    EXPECT_CALL(hmi_capabilities_, vr_supported_languages())
+        .WillOnce(Return(supported_languages.get()));
+    EXPECT_CALL(hmi_capabilities_, tts_supported_languages())
+        .WillOnce(Return(supported_languages.get()));
+  }
+
+  void ResultCommandExpectations(MessageSharedPtr msg,
+                                 const std::string& info) {
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::success].asBool(),
+              true);
+    EXPECT_EQ(
+        (*msg)[am::strings::msg_params][am::strings::result_code].asInt(),
+        static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::info].asString(),
+              info);
+  }
+
   typedef TypeIf<kMocksAreNice,
                  NiceMock<application_manager_test::MockHMICapabilities>,
                  application_manager_test::MockHMICapabilities>::Result
       MockHMICapabilities;
+  sync_primitives::Lock app_set_lock_;
   MockHMICapabilities hmi_capabilities_;
-  MockHmiInterfaces hmi_interfaces_;
+  NiceMock<MockHmiInterfaces> hmi_interfaces_;
+  MockMessageHelper& mock_message_helper_;
+  MockAppPtr mock_app_;
 };
 
 typedef ChangeRegistrationRequestTest::MockHMICapabilities MockHMICapabilities;
 
-TEST_F(ChangeRegistrationRequestTest, OnEvent_VR_UNSUPPORTED_RESOURCE) {
+TEST_F(ChangeRegistrationRequestTest,
+       OnEvent_VRHmiSendSuccess_UNSUPPORTED_RESOURCE) {
   MessageSharedPtr msg_from_mobile = CreateMsgFromMobile();
 
   utils::SharedPtr<ChangeRegistrationRequest> command =
       CreateCommand<ChangeRegistrationRequest>(msg_from_mobile);
-  MockAppPtr mock_app = CreateMockApp();
-  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(mock_app));
-  ON_CALL(*mock_app, app_id()).WillByDefault(Return(1));
   am::ApplicationSet application_set;
   const utils::custom_string::CustomString name("name");
   MockAppPtr app = CreateMockApp();
@@ -246,7 +308,35 @@ TEST_F(ChangeRegistrationRequestTest, OnEvent_VR_UNSUPPORTED_RESOURCE) {
 
   EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
   EXPECT_CALL(*app, name()).WillOnce(ReturnRef(name));
-  PrepareExpectationBeforeRun();
+
+  smart_objects::SmartObjectSPtr supported_languages(
+      CreateMessage(smart_objects::SmartType_Array));
+  (*supported_languages)[0] =
+      static_cast<int32_t>(mobile_apis::Language::EN_US);
+
+  ExpectationsHmiCapabilities(supported_languages);
+
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceFromFunction(hmi_apis::FunctionID::UI_ChangeRegistration))
+      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_UI));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));
+
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceFromFunction(hmi_apis::FunctionID::VR_ChangeRegistration))
+      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_VR));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_RESPONSE));
+
+  ON_CALL(
+      hmi_interfaces_,
+      GetInterfaceFromFunction(hmi_apis::FunctionID::TTS_ChangeRegistration))
+      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_TTS));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_TTS))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));
   command->Run();
 
   MessageSharedPtr ui_response = CreateMessage(smart_objects::SmartType_Map);
@@ -256,10 +346,13 @@ TEST_F(ChangeRegistrationRequestTest, OnEvent_VR_UNSUPPORTED_RESOURCE) {
       ui_response, hmi_apis::Common_Result::WARNINGS, "ui_info");
   CreateResponseFromHMI(vr_response,
                         hmi_apis::Common_Result::UNSUPPORTED_RESOURCE,
-                        "unsupported_resource");
+                        "VR is not supported by system");
   CreateResponseFromHMI(
       tts_response, hmi_apis::Common_Result::SUCCESS, "tts_info");
-
+  (*ui_response)[am::strings::msg_params][am::strings::app_id] = kConnectionKey;
+  (*vr_response)[am::strings::msg_params][am::strings::app_id] = kConnectionKey;
+  (*tts_response)[am::strings::msg_params][am::strings::app_id] =
+      kConnectionKey;
   am::event_engine::Event event_ui(hmi_apis::FunctionID::UI_ChangeRegistration);
   event_ui.set_smart_object(*ui_response);
   am::event_engine::Event event_vr(hmi_apis::FunctionID::VR_ChangeRegistration);
@@ -282,15 +375,11 @@ TEST_F(ChangeRegistrationRequestTest, OnEvent_VR_UNSUPPORTED_RESOURCE) {
       .WillOnce(DoAll(SaveArg<0>(&response_to_mobile), Return(true)));
 
   command->on_event(event_ui);
-  command->on_event(event_vr);
   command->on_event(event_tts);
+  command->on_event(event_vr);
 
-  EXPECT_EQ(
-      (*response_to_mobile)[strings::msg_params][strings::success].asBool(),
-      true);
-  EXPECT_EQ(
-      (*response_to_mobile)[strings::msg_params][strings::result_code].asInt(),
-      static_cast<int32_t>(mobile_apis::Result::UNSUPPORTED_RESOURCE));
+  ResultCommandExpectations(response_to_mobile,
+                            "ui_info, VR is not supported by system, tts_info");
 }
 
 TEST_F(ChangeRegistrationRequestTest,
@@ -357,6 +446,94 @@ TEST_F(ChangeRegistrationRequestTest,
                     hmi_apis::Common_Result::SUCCESS);
 }
 
+TEST_F(ChangeRegistrationRequestTest,
+       OnEvent_UIHmiSendSuccess_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr msg_from_mobile = CreateMsgFromMobile();
+
+  utils::SharedPtr<ChangeRegistrationRequest> command =
+      CreateCommand<ChangeRegistrationRequest>(msg_from_mobile);
+
+  am::ApplicationSet application_set;
+  const utils::custom_string::CustomString name("name");
+  MockAppPtr app = CreateMockApp();
+  app->set_name(name);
+
+  DataAccessor<am::ApplicationSet> accessor(application_set, app_set_lock_);
+
+  application_set.insert(app);
+
+  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
+  EXPECT_CALL(*app, name()).WillOnce(ReturnRef(name));
+
+  smart_objects::SmartObjectSPtr supported_languages(
+      CreateMessage(smart_objects::SmartType_Array));
+  (*supported_languages)[0] =
+      static_cast<int32_t>(mobile_apis::Language::EN_US);
+
+  ExpectationsHmiCapabilities(supported_languages);
+
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceFromFunction(hmi_apis::FunctionID::UI_ChangeRegistration))
+      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_UI));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceFromFunction(hmi_apis::FunctionID::VR_ChangeRegistration))
+      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_VR));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+
+  ON_CALL(
+      hmi_interfaces_,
+      GetInterfaceFromFunction(hmi_apis::FunctionID::TTS_ChangeRegistration))
+      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_TTS));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_TTS))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+
+  command->Run();
+
+  MessageSharedPtr ui_response = CreateMessage(smart_objects::SmartType_Map);
+  MessageSharedPtr vr_response = CreateMessage(smart_objects::SmartType_Map);
+  MessageSharedPtr tts_response = CreateMessage(smart_objects::SmartType_Map);
+  CreateResponseFromHMI(ui_response,
+                        hmi_apis::Common_Result::UNSUPPORTED_RESOURCE,
+                        "unsupported_resource");
+  CreateResponseFromHMI(
+      vr_response, hmi_apis::Common_Result::WARNINGS, "vr_info");
+  CreateResponseFromHMI(
+      tts_response, hmi_apis::Common_Result::SUCCESS, "tts_info");
+  (*ui_response)[am::strings::msg_params][am::strings::app_id] = kConnectionKey;
+  (*vr_response)[am::strings::msg_params][am::strings::app_id] = kConnectionKey;
+  (*tts_response)[am::strings::msg_params][am::strings::app_id] =
+      kConnectionKey;
+  am::event_engine::Event event_ui(hmi_apis::FunctionID::UI_ChangeRegistration);
+  event_ui.set_smart_object(*ui_response);
+  am::event_engine::Event event_vr(hmi_apis::FunctionID::VR_ChangeRegistration);
+  event_vr.set_smart_object(*vr_response);
+  am::event_engine::Event event_tts(
+      hmi_apis::FunctionID::TTS_ChangeRegistration);
+  event_tts.set_smart_object(*tts_response);
+
+  MessageSharedPtr response_to_mobile;
+
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&response_to_mobile), Return(true)));
+
+  command->on_event(event_vr);
+  command->on_event(event_tts);
+  command->on_event(event_ui);
+
+  ResultCommandExpectations(response_to_mobile,
+                            "unsupported_resource, vr_info, tts_info");
+}
+
+}  // namespace change_registration_request
 }  // namespace commands_test
 }  // namespace components
 }  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/create_interaction_choice_set_test.cc b/src/components/application_manager/test/commands/mobile/create_interaction_choice_set_test.cc
index 6000f0982b..138723b0c3 100644
--- a/src/components/application_manager/test/commands/mobile/create_interaction_choice_set_test.cc
+++ b/src/components/application_manager/test/commands/mobile/create_interaction_choice_set_test.cc
@@ -53,6 +53,7 @@
 namespace test {
 namespace components {
 namespace commands_test {
+namespace create_interaction_choice_set_request {
 
 namespace am = application_manager;
 using am::commands::CommandImpl;
@@ -62,6 +63,7 @@ using am::ApplicationSharedPtr;
 using am::MockMessageHelper;
 using am::MockHmiInterfaces;
 using ::testing::_;
+using ::testing::Mock;
 using ::utils::SharedPtr;
 using ::testing::Return;
 using ::testing::ReturnRef;
@@ -203,6 +205,7 @@ TEST_F(CreateInteractionChoiceSetRequestTest, OnEvent_VR_UNSUPPORTED_RESOURCE) {
   }
 }
 
+}  // namespace create_interaction_choice_set_request
 }  // namespace commands_test
 }  // namespace components
 }  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/delete_command_request_test.cc b/src/components/application_manager/test/commands/mobile/delete_command_request_test.cc
index 420e6c839f..1e03dcaaf1 100644
--- a/src/components/application_manager/test/commands/mobile/delete_command_request_test.cc
+++ b/src/components/application_manager/test/commands/mobile/delete_command_request_test.cc
@@ -50,8 +50,10 @@ namespace test {
 namespace components {
 namespace commands_test {
 namespace mobile_commands_test {
+namespace delete_command_request {
 
 using ::testing::_;
+using ::testing::Mock;
 using ::testing::Return;
 using ::testing::ReturnRef;
 namespace am = ::application_manager;
@@ -73,6 +75,29 @@ const uint32_t kConnectionKey = 2u;
 class DeleteCommandRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
  public:
+  DeleteCommandRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock())
+      , mock_app_(CreateMockApp()) {}
+  MessageSharedPtr CreateFullParamsUISO() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    msg_params[am::strings::cmd_icon] = 1;
+    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
+
   MessageSharedPtr CreateFullParamsVRSO() {
     MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
     (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
@@ -89,9 +114,37 @@ class DeleteCommandRequestTest
 
     return msg;
   }
+
+  void ResultCommandExpectations(MessageSharedPtr msg,
+                                 const std::string& info) {
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::success].asBool(),
+              true);
+    EXPECT_EQ(
+        (*msg)[am::strings::msg_params][am::strings::result_code].asInt(),
+        static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::info].asString(),
+              info);
+  }
+
+  void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, application(kConnectionKey))
+        .WillByDefault(Return(mock_app_));
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kConnectionKey));
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(hmi_interfaces_));
+  }
+
+  void TearDown() OVERRIDE {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
+
+  NiceMock<MockHmiInterfaces> hmi_interfaces_;
+  MockMessageHelper& mock_message_helper_;
+  MockAppPtr mock_app_;
 };
 
-TEST_F(DeleteCommandRequestTest, OnEvent_VrDeleteCommand_UNSUPPORTED_RESOURCE) {
+TEST_F(DeleteCommandRequestTest,
+       OnEvent_VrHmiSendUnsupportedResource_UNSUPPORTED_RESOURCE) {
   MessageSharedPtr command_msg = CreateFullParamsVRSO();
   (*command_msg)[am::strings::msg_params][am::strings::cmd_id] = kCommandId;
   (*command_msg)[am::strings::params][am::strings::connection_key] =
@@ -99,28 +152,27 @@ TEST_F(DeleteCommandRequestTest, OnEvent_VrDeleteCommand_UNSUPPORTED_RESOURCE) {
 
   DeleteCommandPtr command(CreateCommand<DeleteCommandRequest>(command_msg));
 
-  MockAppPtr app = CreateMockApp();
-  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(app));
+  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(mock_app_));
 
   MessageSharedPtr test_msg(CreateMessage(smart_objects::SmartType_Map));
   (*test_msg)[am::strings::vr_commands] = 0;
   (*test_msg)[am::strings::menu_params] = 0;
 
-  MockHmiInterfaces hmi_interfaces;
-  ON_CALL(app_mngr_, hmi_interfaces()).WillByDefault(ReturnRef(hmi_interfaces));
-  ON_CALL(hmi_interfaces, GetInterfaceFromFunction(_))
-      .WillByDefault(
-          Return(am::HmiInterfaces::HMI_INTERFACE_BasicCommunication));
-  ON_CALL(hmi_interfaces, GetInterfaceState(_))
-      .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));
-  ON_CALL(*app, FindCommand(kCommandId)).WillByDefault(Return(test_msg.get()));
-  ON_CALL(*app, app_id()).WillByDefault(Return(kConnectionKey));
-  ON_CALL(*app, get_grammar_id()).WillByDefault(Return(kConnectionKey));
+  ON_CALL(hmi_interfaces_, GetInterfaceFromFunction(_))
+      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_VR));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+  ON_CALL(*mock_app_, FindCommand(kCommandId))
+      .WillByDefault(Return(test_msg.get()));
+  ON_CALL(*mock_app_, get_grammar_id()).WillByDefault(Return(kConnectionKey));
 
   MessageSharedPtr msg(CreateMessage(smart_objects::SmartType_Map));
   (*msg)[am::strings::params][am::hmi_response::code] =
       hmi_apis::Common_Result::SUCCESS;
-  (*msg)[am::strings::params][am::strings::info] = "info";
   Event event_ui(hmi_apis::FunctionID::UI_DeleteCommand);
   event_ui.set_smart_object(*msg);
 
@@ -130,29 +182,83 @@ TEST_F(DeleteCommandRequestTest, OnEvent_VrDeleteCommand_UNSUPPORTED_RESOURCE) {
   MessageSharedPtr event_msg(CreateMessage(smart_objects::SmartType_Map));
   (*event_msg)[am::strings::params][am::hmi_response::code] =
       hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
-  (*event_msg)[am::strings::params][am::strings::info] = "info";
+  (*event_msg)[am::strings::msg_params][am::strings::info] =
+      "VR is not supported by system";
   Event event_vr(hmi_apis::FunctionID::VR_DeleteCommand);
   event_vr.set_smart_object(*event_msg);
 
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCommandId));
+
+  EXPECT_CALL(*mock_app_, UpdateHash());
+
+  MessageSharedPtr vr_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&vr_command_result), Return(true)));
+
+  command->on_event(event_vr);
+
+  ResultCommandExpectations(vr_command_result, "VR is not supported by system");
+}
+
+TEST_F(DeleteCommandRequestTest,
+       OnEvent_UIHmiSendUnsupportedResource_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr command_msg = CreateFullParamsUISO();
+  (*command_msg)[am::strings::msg_params][am::strings::cmd_id] = kCommandId;
+  (*command_msg)[am::strings::params][am::strings::connection_key] =
+      kConnectionKey;
+
+  DeleteCommandPtr command(CreateCommand<DeleteCommandRequest>(command_msg));
+
+  MockAppPtr app = CreateMockApp();
+  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(app));
+
+  MessageSharedPtr test_msg(CreateMessage(smart_objects::SmartType_Map));
+  (*test_msg)[am::strings::vr_commands] = 0;
+  (*test_msg)[am::strings::menu_params] = 0;
+
+  ON_CALL(hmi_interfaces_, GetInterfaceFromFunction(_))
+      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_UI));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+  ON_CALL(*app, FindCommand(kCommandId)).WillByDefault(Return(test_msg.get()));
+  ON_CALL(*app, get_grammar_id()).WillByDefault(Return(kConnectionKey));
+
+  MessageSharedPtr msg(CreateMessage(smart_objects::SmartType_Map));
+  (*msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::SUCCESS;
+  Event event_vr(hmi_apis::FunctionID::VR_DeleteCommand);
+  event_vr.set_smart_object(*msg);
+
+  command->Run();
+  command->on_event(event_vr);
+
+  MessageSharedPtr event_msg(CreateMessage(smart_objects::SmartType_Map));
+  (*event_msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*event_msg)[am::strings::msg_params][am::strings::info] =
+      "UI is not supported by system";
+  Event event_ui(hmi_apis::FunctionID::UI_DeleteCommand);
+  event_ui.set_smart_object(*event_msg);
+
+  EXPECT_CALL(*app, RemoveCommand(kCommandId));
+
+  EXPECT_CALL(*app, UpdateHash());
+
   MessageSharedPtr result_msg(
-      CatchMobileCommandResult(CallOnEvent(*command, event_vr)));
+      CatchMobileCommandResult(CallOnEvent(*command, event_ui)));
 
   ASSERT_TRUE(result_msg);
 
-  EXPECT_EQ(
-      (*result_msg)[am::strings::msg_params][am::strings::success].asBool(),
-      false);
-  EXPECT_EQ(
-      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE,
-      (*result_msg)[am::strings::msg_params][am::strings::result_code].asInt());
-
-  if ((*result_msg)[am::strings::msg_params].keyExists(am::strings::info)) {
-    EXPECT_EQ(
-        (*event_msg)[am::strings::params][am::strings::info].asString(),
-        (*result_msg)[am::strings::msg_params][am::strings::info].asString());
-  }
+  ResultCommandExpectations(result_msg, "UI is not supported by system");
 }
 
+}  // namespace delete_command_request
 }  // namespace mobile_commands_test
 }  // namespace commands_test
 }  // namespace components
diff --git a/src/components/application_manager/test/commands/mobile/delete_sub_menu_test.cc b/src/components/application_manager/test/commands/mobile/delete_sub_menu_test.cc
new file mode 100644
index 0000000000..36c4614343
--- /dev/null
+++ b/src/components/application_manager/test/commands/mobile/delete_sub_menu_test.cc
@@ -0,0 +1,145 @@
+/*
+ * 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 <stdint.h>
+#include <string>
+
+#include "application_manager/commands/mobile/delete_sub_menu_request.h"
+
+#include "gtest/gtest.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/event_engine/event.h"
+#include "application_manager/mock_hmi_interface.h"
+
+namespace test {
+namespace components {
+namespace commands_test {
+namespace mobile_commands_test {
+
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+namespace am = ::application_manager;
+using am::commands::DeleteSubMenuRequest;
+using am::commands::MessageSharedPtr;
+using am::event_engine::Event;
+using am::MockHmiInterfaces;
+using am::MockMessageHelper;
+
+typedef SharedPtr<DeleteSubMenuRequest> AddSubMenuPtr;
+
+namespace {
+const uint32_t kConnectionKey = 2u;
+}  // namespace
+
+class DeleteSubMenuRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  DeleteSubMenuRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock()) {}
+  MockMessageHelper& mock_message_helper_;
+  sync_primitives::Lock lock_;
+};
+
+TEST_F(DeleteSubMenuRequestTest, OnEvent_UI_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+  (*msg)[am::strings::msg_params][am::strings::menu_id] = 10u;
+
+  utils::SharedPtr<DeleteSubMenuRequest> command =
+      CreateCommand<DeleteSubMenuRequest>(msg);
+
+  MockAppPtr mock_app = CreateMockApp();
+  ON_CALL(app_mngr_, application(kConnectionKey))
+      .WillByDefault(Return(mock_app));
+  ON_CALL(*mock_app, app_id()).WillByDefault(Return(kConnectionKey));
+  EXPECT_CALL(*mock_app, RemoveSubMenu(_));
+
+  MessageSharedPtr ev_msg = CreateMessage(smart_objects::SmartType_Map);
+  (*ev_msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*ev_msg)[am::strings::msg_params][am::strings::info] = "info";
+
+  Event event(hmi_apis::FunctionID::UI_DeleteSubMenu);
+  event.set_smart_object(*ev_msg);
+
+  MockHmiInterfaces hmi_interfaces;
+  ON_CALL(app_mngr_, hmi_interfaces()).WillByDefault(ReturnRef(hmi_interfaces));
+  EXPECT_CALL(hmi_interfaces,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillOnce(Return(am::HmiInterfaces::STATE_AVAILABLE));
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE))
+      .WillOnce(Return(mobile_apis::Result::UNSUPPORTED_RESOURCE));
+
+  am::CommandsMap commands_map;
+  smart_objects::SmartObject commands_msg(smart_objects::SmartType_Map);
+  commands_map.insert(std::pair<uint32_t, SmartObject*>(1u, &commands_msg));
+  DataAccessor<am::CommandsMap> accessor(commands_map, lock_);
+  EXPECT_CALL(*mock_app, commands_map())
+      .WillOnce(Return(accessor))
+      .WillOnce(Return(accessor));
+
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
+
+  command->on_event(event);
+
+  EXPECT_EQ((*ui_command_result)[am::strings::msg_params][am::strings::success]
+                .asBool(),
+            true);
+  EXPECT_EQ(
+      (*ui_command_result)[am::strings::msg_params][am::strings::result_code]
+          .asInt(),
+      static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+  if ((*ui_command_result)[am::strings::msg_params].keyExists(
+          am::strings::info)) {
+    EXPECT_FALSE(
+        (*ui_command_result)[am::strings::msg_params][am::strings::info]
+            .asString()
+            .empty());
+  }
+  Mock::VerifyAndClearExpectations(&mock_message_helper_);
+}
+
+}  // namespace mobile_commands_test
+}  // namespace commands_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/application_manager/test/commands/mobile/end_audio_pass_thru_request_test.cc b/src/components/application_manager/test/commands/mobile/end_audio_pass_thru_request_test.cc
index 6b8bee3d84..79a09c004e 100644
--- a/src/components/application_manager/test/commands/mobile/end_audio_pass_thru_request_test.cc
+++ b/src/components/application_manager/test/commands/mobile/end_audio_pass_thru_request_test.cc
@@ -34,57 +34,44 @@
 #include <string>
 #include <vector>
 
+#include "application_manager/commands/mobile/end_audio_pass_thru_request.h"
+
 #include "gtest/gtest.h"
-#include "utils/shared_ptr.h"
-#include "smart_objects/smart_object.h"
 #include "application_manager/smart_object_keys.h"
 #include "application_manager/test/include/application_manager/commands/commands_test.h"
 #include "application_manager/test/include/application_manager/commands/command_request_test.h"
-#include "application_manager/application.h"
 #include "application_manager/mock_application_manager.h"
 #include "application_manager/event_engine/event.h"
-#include "application_manager/commands/mobile/end_audio_pass_thru_request.h"
-#include "interfaces/MOBILE_API.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/mock_hmi_interface.h"
 
 namespace test {
 namespace components {
 namespace commands_test {
 namespace mobile_commands_test {
 
+namespace am = ::application_manager;
 using ::testing::_;
+using ::testing::Mock;
 using ::testing::Return;
-namespace am = ::application_manager;
+using ::testing::ReturnRef;
 using am::commands::MessageSharedPtr;
 using am::commands::EndAudioPassThruRequest;
 using am::event_engine::Event;
-namespace mobile_result = mobile_apis::Result;
+using am::MockHmiInterfaces;
+using am::MockMessageHelper;
 
 typedef SharedPtr<EndAudioPassThruRequest> EndAudioPassThruRequestPtr;
 
 class EndAudioPassThruRequestTest
-    : public CommandRequestTest<CommandsTestMocks::kIsNice> {};
-
-TEST_F(EndAudioPassThruRequestTest, Run_SUCCESS) {
-  EndAudioPassThruRequestPtr command(CreateCommand<EndAudioPassThruRequest>());
-
-  EXPECT_CALL(app_mngr_,
-              ManageHMICommand(
-                  HMIResultCodeIs(hmi_apis::FunctionID::UI_EndAudioPassThru)));
-
-  command->Run();
-}
-
-TEST_F(EndAudioPassThruRequestTest, OnEvent_UnknownEvent_UNSUCCESS) {
-  EndAudioPassThruRequestPtr command(CreateCommand<EndAudioPassThruRequest>());
-
-  Event event(hmi_apis::FunctionID::INVALID_ENUM);
-
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
-
-  command->on_event(event);
-}
-
-TEST_F(EndAudioPassThruRequestTest, OnEvent_SUCCESS) {
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  EndAudioPassThruRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock()) {}
+  MockMessageHelper& mock_message_helper_;
+};
+
+TEST_F(EndAudioPassThruRequestTest, OnEvent_UI_UNSUPPORTED_RESOUCRE) {
   const uint32_t kConnectionKey = 2u;
 
   MessageSharedPtr command_msg(CreateMessage(smart_objects::SmartType_Map));
@@ -97,19 +84,46 @@ TEST_F(EndAudioPassThruRequestTest, OnEvent_SUCCESS) {
   MessageSharedPtr event_msg(CreateMessage(smart_objects::SmartType_Map));
   (*event_msg)[am::strings::msg_params] = 0;
   (*event_msg)[am::strings::params][am::hmi_response::code] =
-      mobile_apis::Result::SUCCESS;
+      mobile_apis::Result::UNSUPPORTED_RESOURCE;
 
   Event event(hmi_apis::FunctionID::UI_EndAudioPassThru);
   event.set_smart_object(*event_msg);
 
-  EXPECT_CALL(app_mngr_, EndAudioPassThrough()).WillOnce(Return(true));
-  EXPECT_CALL(app_mngr_, StopAudioPassThru(kConnectionKey));
+  MockHmiInterfaces hmi_interfaces;
+  ON_CALL(app_mngr_, hmi_interfaces()).WillByDefault(ReturnRef(hmi_interfaces));
+  ON_CALL(hmi_interfaces,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE))
+      .WillOnce(Return(mobile_apis::Result::UNSUPPORTED_RESOURCE));
 
+  EXPECT_CALL(app_mngr_, EndAudioPassThrough()).WillOnce(Return(false));
+
+  MessageSharedPtr ui_command_result;
   EXPECT_CALL(
       app_mngr_,
-      ManageMobileCommand(MobileResultCodeIs(mobile_apis::Result::SUCCESS), _));
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
 
   command->on_event(event);
+
+  EXPECT_EQ((*ui_command_result)[am::strings::msg_params][am::strings::success]
+                .asBool(),
+            true);
+  EXPECT_EQ(
+      (*ui_command_result)[am::strings::msg_params][am::strings::result_code]
+          .asInt(),
+      static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+  if ((*ui_command_result)[am::strings::msg_params].keyExists(
+          am::strings::info)) {
+    EXPECT_FALSE(
+        (*ui_command_result)[am::strings::msg_params][am::strings::info]
+            .asString()
+            .empty());
+  }
+  Mock::VerifyAndClearExpectations(&mock_message_helper_);
 }
 
 }  // namespace mobile_commands_test
diff --git a/src/components/application_manager/test/commands/mobile/perform_audio_pass_thru_test.cc b/src/components/application_manager/test/commands/mobile/perform_audio_pass_thru_test.cc
new file mode 100644
index 0000000000..b6a76d51cc
--- /dev/null
+++ b/src/components/application_manager/test/commands/mobile/perform_audio_pass_thru_test.cc
@@ -0,0 +1,210 @@
+/*
+ * 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 <stdint.h>
+#include <string>
+#include <set>
+
+#include "application_manager/commands/mobile/perform_audio_pass_thru_request.h"
+
+#include "gtest/gtest.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/event_engine/event.h"
+#include "application_manager/mock_hmi_interface.h"
+
+namespace test {
+namespace components {
+namespace commands_test {
+namespace perform_audio_pass_thru_request {
+
+namespace am = application_manager;
+using am::commands::PerformAudioPassThruRequest;
+using am::commands::CommandImpl;
+using am::commands::MessageSharedPtr;
+using am::MockMessageHelper;
+using am::MockHmiInterfaces;
+using ::utils::SharedPtr;
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+
+namespace {
+const int32_t kCommandId = 1;
+const uint32_t kAppId = 1u;
+const uint32_t kCmdId = 1u;
+const uint32_t kConnectionKey = 2u;
+}  // namespace
+
+class PerformAudioPassThruRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  PerformAudioPassThruRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock())
+      , mock_app_(CreateMockApp()) {}
+
+  MessageSharedPtr CreateFullParamsUISO() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    msg_params[am::strings::cmd_icon] = 1;
+    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
+
+  void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, application(kConnectionKey))
+        .WillByDefault(Return(mock_app_));
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kConnectionKey));
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(hmi_interfaces_));
+  }
+
+  void TearDown() OVERRIDE {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
+
+  void ResultCommandExpectations(MessageSharedPtr msg,
+                                 const std::string& info) {
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::success].asBool(),
+              true);
+    EXPECT_EQ(
+        (*msg)[am::strings::msg_params][am::strings::result_code].asInt(),
+        static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::info].asString(),
+              info);
+  }
+
+  sync_primitives::Lock lock_;
+  NiceMock<MockHmiInterfaces> hmi_interfaces_;
+  MockMessageHelper& mock_message_helper_;
+  MockAppPtr mock_app_;
+};
+
+TEST_F(PerformAudioPassThruRequestTest, OnTimeout_GENERIC_ERROR) {
+  MessageSharedPtr msg_ui = CreateMessage(smart_objects::SmartType_Map);
+  (*msg_ui)[am::strings::msg_params][am::strings::result_code] =
+      am::mobile_api::Result::GENERIC_ERROR;
+  (*msg_ui)[am::strings::msg_params][am::strings::success] = false;
+
+  utils::SharedPtr<PerformAudioPassThruRequest> command =
+      CreateCommand<PerformAudioPassThruRequest>();
+
+  EXPECT_CALL(app_mngr_, EndAudioPassThrough()).WillOnce(Return(true));
+  EXPECT_CALL(app_mngr_, StopAudioPassThru(_));
+
+  EXPECT_CALL(
+      mock_message_helper_,
+      CreateNegativeResponse(_, _, _, am::mobile_api::Result::GENERIC_ERROR))
+      .WillOnce(Return(msg_ui));
+
+  MessageSharedPtr vr_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&vr_command_result), Return(true)));
+
+  command->onTimeOut();
+  EXPECT_EQ((*vr_command_result)[am::strings::msg_params][am::strings::success]
+                .asBool(),
+            false);
+  EXPECT_EQ(
+      (*vr_command_result)[am::strings::msg_params][am::strings::result_code]
+          .asInt(),
+      static_cast<int32_t>(am::mobile_api::Result::GENERIC_ERROR));
+  Mock::VerifyAndClearExpectations(&mock_message_helper_);
+}
+
+TEST_F(PerformAudioPassThruRequestTest,
+       OnEvent_UIHmiSendUnsupportedResource_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr msg_ui = CreateFullParamsUISO();
+  (*msg_ui)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+
+  utils::SharedPtr<PerformAudioPassThruRequest> command =
+      CreateCommand<PerformAudioPassThruRequest>(msg_ui);
+
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*msg)[am::strings::msg_params][am::strings::cmd_id] = kCommandId;
+  (*msg)[am::strings::msg_params][am::strings::info] =
+      "UI is not supported by system";
+
+  Event event(hmi_apis::FunctionID::UI_PerformAudioPassThru);
+  event.set_smart_object(*msg);
+
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_TTS))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+
+  MessageSharedPtr response_msg_tts =
+      CreateMessage(smart_objects::SmartType_Map);
+  (*response_msg_tts)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::SUCCESS;
+  (*response_msg_tts)[am::strings::msg_params][am::strings::cmd_id] = kCmdId;
+  am::event_engine::Event event_tts(hmi_apis::FunctionID::TTS_Speak);
+  event_tts.set_smart_object(*response_msg_tts);
+  command->on_event(event_tts);
+
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(app_mngr_, EndAudioPassThrough()).WillOnce(Return(false));
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
+
+  command->on_event(event);
+
+  ResultCommandExpectations(ui_command_result, "UI is not supported by system");
+}
+
+}  // namespace perform_audio_pass_thru_request
+}  // namespace commands_test
+}  // namespace components
+}  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/perform_interaction_test.cc b/src/components/application_manager/test/commands/mobile/perform_interaction_test.cc
index 3b6a66f112..d261dee8ec 100644
--- a/src/components/application_manager/test/commands/mobile/perform_interaction_test.cc
+++ b/src/components/application_manager/test/commands/mobile/perform_interaction_test.cc
@@ -53,6 +53,7 @@
 namespace test {
 namespace components {
 namespace commands_test {
+namespace perform_interaction_request {
 
 namespace am = application_manager;
 using am::commands::CommandImpl;
@@ -62,6 +63,7 @@ using am::ApplicationSharedPtr;
 using am::MockMessageHelper;
 using am::MockHmiInterfaces;
 using ::testing::_;
+using ::testing::Mock;
 using ::utils::SharedPtr;
 using ::testing::Return;
 using ::testing::ReturnRef;
@@ -80,7 +82,37 @@ const uint32_t kConnectionKey = 2u;
 class PerformInteractionRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
  public:
+  PerformInteractionRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock())
+      , mock_app_(CreateMockApp()) {}
+
+  void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, application(kConnectionKey))
+        .WillByDefault(Return(mock_app_));
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kConnectionKey));
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(hmi_interfaces_));
+  }
+
+  void TearDown() OVERRIDE {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
+
+  void ResultCommandExpectations(MessageSharedPtr msg,
+                                 const std::string& info) {
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::success].asBool(),
+              true);
+    EXPECT_EQ(
+        (*msg)[am::strings::msg_params][am::strings::result_code].asInt(),
+        static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::info].asString(),
+              info);
+  }
+
   sync_primitives::Lock lock_;
+  NiceMock<MockHmiInterfaces> hmi_interfaces_;
+  MockMessageHelper& mock_message_helper_;
+  MockAppPtr mock_app_;
 };
 
 TEST_F(PerformInteractionRequestTest, OnTimeout_VR_GENERIC_ERROR) {
@@ -107,10 +139,8 @@ TEST_F(PerformInteractionRequestTest, OnTimeout_VR_GENERIC_ERROR) {
       CreateMessage(smart_objects::SmartType_Map);
   (*response_to_mobile)[strings::msg_params][strings::result_code] =
       static_cast<uint64_t>(am::mobile_api::Result::GENERIC_ERROR);
-  MockMessageHelper* mock_message_helper =
-      MockMessageHelper::message_helper_mock();
   EXPECT_CALL(
-      *mock_message_helper,
+      mock_message_helper_,
       CreateNegativeResponse(_, _, _, am::mobile_api::Result::GENERIC_ERROR))
       .WillOnce(Return(response_to_mobile));
 
@@ -129,7 +159,8 @@ TEST_F(PerformInteractionRequestTest, OnTimeout_VR_GENERIC_ERROR) {
       static_cast<int32_t>(am::mobile_api::Result::GENERIC_ERROR));
 }
 
-TEST_F(PerformInteractionRequestTest, OnEvent_VR_UNSUPPORTED_RESOURCE) {
+TEST_F(PerformInteractionRequestTest,
+       OnEvent_VRHmiSendSuccess_UNSUPPORTED_RESOURCE) {
   MessageSharedPtr msg_from_mobile =
       CreateMessage(smart_objects::SmartType_Map);
   (*msg_from_mobile)[strings::params][strings::connection_key] = kConnectionKey;
@@ -150,9 +181,9 @@ TEST_F(PerformInteractionRequestTest, OnEvent_VR_UNSUPPORTED_RESOURCE) {
       CreateMessage(smart_objects::SmartType_Map);
   (*response_msg_vr)[strings::params][hmi_response::code] =
       hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
-  (*response_msg_vr)[strings::params][strings::info] =
-      "VR is not supported by system";
   (*response_msg_vr)[strings::msg_params][strings::cmd_id] = kCommandId;
+  (*response_msg_vr)[am::strings::msg_params][am::strings::info] =
+      "VR is not supported by system";
 
   am::event_engine::Event event_vr(hmi_apis::FunctionID::VR_PerformInteraction);
   event_vr.set_smart_object(*response_msg_vr);
@@ -167,7 +198,7 @@ TEST_F(PerformInteractionRequestTest, OnEvent_VR_UNSUPPORTED_RESOURCE) {
 
   EXPECT_CALL(hmi_interfaces,
               GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
-      .WillRepeatedly(Return(am::HmiInterfaces::STATE_AVAILABLE));
+      .WillRepeatedly(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
   EXPECT_CALL(hmi_interfaces,
               GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
       .WillRepeatedly(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
@@ -182,17 +213,64 @@ TEST_F(PerformInteractionRequestTest, OnEvent_VR_UNSUPPORTED_RESOURCE) {
   command->on_event(event_vr);
   command->on_event(event_ui);
 
-  EXPECT_EQ(
-      (*response_to_mobile)[strings::msg_params][strings::success].asBool(),
-      true);
-  EXPECT_EQ(
-      (*response_to_mobile)[strings::msg_params][strings::result_code].asInt(),
-      static_cast<int32_t>(mobile_apis::Result::UNSUPPORTED_RESOURCE));
-  EXPECT_EQ(
-      (*response_to_mobile)[strings::msg_params][strings::info].asString(),
-      (*response_msg_vr)[strings::msg_params][strings::info].asString());
+  ResultCommandExpectations(response_to_mobile,
+                            "VR is not supported by system");
+}
+
+TEST_F(PerformInteractionRequestTest,
+       OnEvent_UIHmiSendSuccess_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr msg_from_mobile =
+      CreateMessage(smart_objects::SmartType_Map);
+  (*msg_from_mobile)[strings::params][strings::connection_key] = kConnectionKey;
+  (*msg_from_mobile)[strings::msg_params][strings::interaction_mode] =
+      mobile_apis::InteractionMode::VR_ONLY;
+  utils::SharedPtr<PerformInteractionRequest> command =
+      CreateCommand<PerformInteractionRequest>(msg_from_mobile);
+
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+
+  MessageSharedPtr response_msg_vr =
+      CreateMessage(smart_objects::SmartType_Map);
+  (*response_msg_vr)[strings::params][hmi_response::code] =
+      hmi_apis::Common_Result::SUCCESS;
+  am::event_engine::Event event_vr(hmi_apis::FunctionID::VR_PerformInteraction);
+  event_vr.set_smart_object(*response_msg_vr);
+
+  MessageSharedPtr response_msg_ui =
+      CreateMessage(smart_objects::SmartType_Map);
+  (*response_msg_ui)[strings::params][hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*response_msg_ui)[strings::msg_params][strings::cmd_id] = kCommandId;
+  (*response_msg_ui)[am::strings::msg_params][am::strings::info] =
+      "UI is not supported by system";
+
+  am::event_engine::Event event_ui(hmi_apis::FunctionID::UI_PerformInteraction);
+  event_ui.set_smart_object(*response_msg_ui);
+
+  MessageSharedPtr response_to_mobile;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&response_to_mobile), Return(true)));
+
+  command->on_event(event_vr);
+
+  EXPECT_CALL(*mock_app_, is_perform_interaction_active())
+      .WillOnce(Return(false));
+  EXPECT_CALL(*mock_app_, DeletePerformInteractionChoiceSet(_));
+
+  command->on_event(event_ui);
+
+  ResultCommandExpectations(response_to_mobile,
+                            "UI is not supported by system");
 }
 
+}  // namespace perform_interaction_request
 }  // namespace commands_test
 }  // namespace components
 }  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/scrollable_message_test.cc b/src/components/application_manager/test/commands/mobile/scrollable_message_test.cc
new file mode 100644
index 0000000000..02744a66ea
--- /dev/null
+++ b/src/components/application_manager/test/commands/mobile/scrollable_message_test.cc
@@ -0,0 +1,167 @@
+/*
+ * 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 <stdint.h>
+#include <string>
+#include <set>
+
+#include "application_manager/commands/mobile/scrollable_message_request.h"
+
+#include "gtest/gtest.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/event_engine/event.h"
+#include "application_manager/mock_hmi_interface.h"
+#include "application_manager/mock_hmi_capabilities.h"
+
+namespace test {
+namespace components {
+namespace commands_test {
+
+namespace am = application_manager;
+using am::commands::ScrollableMessageRequest;
+using am::commands::CommandImpl;
+using am::commands::MessageSharedPtr;
+using am::MockMessageHelper;
+using am::MockHmiInterfaces;
+using ::utils::SharedPtr;
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+
+namespace {
+const uint32_t kAppId = 1u;
+const uint32_t kCmdId = 1u;
+const uint32_t kConnectionKey = 2u;
+}  // namespace
+
+class ScrollableMessageRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  ScrollableMessageRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock()) {}
+  MockMessageHelper& mock_message_helper_;
+  typedef TypeIf<kMocksAreNice,
+                 NiceMock<application_manager_test::MockHMICapabilities>,
+                 application_manager_test::MockHMICapabilities>::Result
+      MockHMICapabilities;
+  sync_primitives::Lock lock_;
+
+  MessageSharedPtr CreateFullParamsUISO() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    msg_params[am::strings::cmd_icon] = 1;
+    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
+};
+
+typedef ScrollableMessageRequestTest::MockHMICapabilities MockHMICapabilities;
+
+TEST_F(ScrollableMessageRequestTest, OnEvent_UI_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr msg_ui = CreateFullParamsUISO();
+  (*msg_ui)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+
+  utils::SharedPtr<ScrollableMessageRequest> command =
+      CreateCommand<ScrollableMessageRequest>(msg_ui);
+
+  MockAppPtr mock_app = CreateMockApp();
+  ON_CALL(app_mngr_, application(kConnectionKey))
+      .WillByDefault(Return(mock_app));
+
+  ON_CALL(*mock_app, app_id()).WillByDefault(Return(kConnectionKey));
+  MockHmiInterfaces hmi_interfaces;
+  ON_CALL(app_mngr_, hmi_interfaces()).WillByDefault(ReturnRef(hmi_interfaces));
+  EXPECT_CALL(hmi_interfaces,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillOnce(Return(am::HmiInterfaces::STATE_AVAILABLE));
+
+  MockHMICapabilities hmi_capabilities;
+  ON_CALL(app_mngr_, hmi_capabilities())
+      .WillByDefault(ReturnRef(hmi_capabilities));
+  ON_CALL(hmi_capabilities, is_ui_cooperating()).WillByDefault(Return(true));
+
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*msg)[am::strings::msg_params][am::strings::info] = "info1";
+
+  Event event(hmi_apis::FunctionID::UI_ScrollableMessage);
+  event.set_smart_object(*msg);
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE))
+      .WillOnce(Return(mobile_apis::Result::UNSUPPORTED_RESOURCE));
+
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
+
+  command->on_event(event);
+
+  EXPECT_EQ((*ui_command_result)[am::strings::msg_params][am::strings::success]
+                .asBool(),
+            true);
+  EXPECT_EQ(
+      (*ui_command_result)[am::strings::msg_params][am::strings::result_code]
+          .asInt(),
+      static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+  if ((*ui_command_result)[am::strings::msg_params].keyExists(
+          am::strings::info)) {
+    EXPECT_FALSE(
+        (*ui_command_result)[am::strings::msg_params][am::strings::info]
+            .asString()
+            .empty());
+  }
+  Mock::VerifyAndClearExpectations(&mock_message_helper_);
+}
+
+}  // namespace commands_test
+}  // namespace components
+}  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/set_app_icon_test.cc b/src/components/application_manager/test/commands/mobile/set_app_icon_test.cc
new file mode 100644
index 0000000000..9e5e62fc1c
--- /dev/null
+++ b/src/components/application_manager/test/commands/mobile/set_app_icon_test.cc
@@ -0,0 +1,164 @@
+/*
+ * 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 <stdint.h>
+#include <string>
+#include <set>
+
+#include "application_manager/commands/mobile/set_app_icon_request.h"
+
+#include "gtest/gtest.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/event_engine/event.h"
+#include "application_manager/mock_hmi_interface.h"
+
+namespace test {
+namespace components {
+namespace commands_test {
+
+namespace am = application_manager;
+using am::commands::SetAppIconRequest;
+using am::commands::CommandImpl;
+using am::commands::MessageSharedPtr;
+using am::MockMessageHelper;
+using am::MockHmiInterfaces;
+using ::utils::SharedPtr;
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+
+namespace {
+const uint32_t kAppId = 1u;
+const uint32_t kCmdId = 1u;
+const uint32_t kConnectionKey = 2u;
+}  // namespace
+
+class SetAppIconRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  SetAppIconRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock()) {}
+  MockMessageHelper& mock_message_helper_;
+
+  MessageSharedPtr CreateFullParamsUISO() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    msg_params[am::strings::cmd_icon] = 1;
+    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
+};
+
+TEST_F(SetAppIconRequestTest, OnEvent_UI_UNSUPPORTED_RESOURCE) {
+  const std::string file_path = "file_path";
+  MessageSharedPtr msg_vr = CreateFullParamsUISO();
+  (*msg_vr)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+  (*msg_vr)[am::strings::msg_params][am::strings::sync_file_name]
+           [am::strings::value] = file_path;
+
+  const std::string dir_path = "./";
+  ON_CALL(app_mngr_settings_, app_icons_folder())
+      .WillByDefault(ReturnRef(dir_path));
+
+  utils::SharedPtr<SetAppIconRequest> req_vr =
+      CreateCommand<SetAppIconRequest>(msg_vr);
+
+  MockAppPtr mock_app = CreateMockApp();
+  ON_CALL(app_mngr_, application(kConnectionKey))
+      .WillByDefault(Return(mock_app));
+
+  ON_CALL(*mock_app, app_id()).WillByDefault(Return(kConnectionKey));
+  ON_CALL(*mock_app, set_app_icon_path(_)).WillByDefault(Return(true));
+  ON_CALL(*mock_app, app_icon_path()).WillByDefault(ReturnRef(file_path));
+
+  MockHmiInterfaces hmi_interfaces;
+  ON_CALL(app_mngr_, hmi_interfaces()).WillByDefault(ReturnRef(hmi_interfaces));
+  EXPECT_CALL(hmi_interfaces,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillOnce(Return(am::HmiInterfaces::STATE_AVAILABLE));
+
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*msg)[am::strings::msg_params][am::strings::info] = "info1";
+
+  Event event(hmi_apis::FunctionID::UI_SetAppIcon);
+  event.set_smart_object(*msg);
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE))
+      .WillOnce(Return(mobile_apis::Result::UNSUPPORTED_RESOURCE));
+
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
+
+  req_vr->on_event(event);
+
+  EXPECT_EQ((*ui_command_result)[am::strings::msg_params][am::strings::success]
+                .asBool(),
+            true);
+  EXPECT_EQ(
+      (*ui_command_result)[am::strings::msg_params][am::strings::result_code]
+          .asInt(),
+      static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+  if ((*ui_command_result)[am::strings::msg_params].keyExists(
+          am::strings::info)) {
+    EXPECT_FALSE(
+        (*ui_command_result)[am::strings::msg_params][am::strings::info]
+            .asString()
+            .empty());
+  }
+  Mock::VerifyAndClearExpectations(&mock_message_helper_);
+}
+
+}  // namespace commands_test
+}  // namespace components
+}  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/set_display_layout_test.cc b/src/components/application_manager/test/commands/mobile/set_display_layout_test.cc
new file mode 100644
index 0000000000..839d9a452e
--- /dev/null
+++ b/src/components/application_manager/test/commands/mobile/set_display_layout_test.cc
@@ -0,0 +1,178 @@
+/*
+ * 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 <stdint.h>
+#include <string>
+#include <set>
+
+#include "application_manager/commands/mobile/set_display_layout_request.h"
+
+#include "gtest/gtest.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/event_engine/event.h"
+#include "application_manager/mock_hmi_interface.h"
+#include "application_manager/mock_hmi_capabilities.h"
+
+namespace test {
+namespace components {
+namespace commands_test {
+namespace set_display_layout_request {
+
+namespace am = application_manager;
+using am::commands::SetDisplayLayoutRequest;
+using am::commands::CommandImpl;
+using am::commands::MessageSharedPtr;
+using am::MockMessageHelper;
+using am::MockHmiInterfaces;
+using ::utils::SharedPtr;
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+
+namespace {
+const uint32_t kAppId = 1u;
+const uint32_t kCmdId = 1u;
+const uint32_t kConnectionKey = 2u;
+}  // namespace
+
+class SetDisplayLayoutRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  SetDisplayLayoutRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock())
+      , mock_app_(CreateMockApp()) {}
+
+  MessageSharedPtr CreateFullParamsUISO() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    msg_params[am::strings::cmd_icon] = 1;
+    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
+
+  void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, application(kConnectionKey))
+        .WillByDefault(Return(mock_app_));
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kConnectionKey));
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(hmi_interfaces_));
+  }
+
+  void TearDown() OVERRIDE {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
+  typedef TypeIf<kMocksAreNice,
+                 NiceMock<application_manager_test::MockHMICapabilities>,
+                 application_manager_test::MockHMICapabilities>::Result
+      MockHMICapabilities;
+
+  void ResultCommandExpectations(MessageSharedPtr msg,
+                                 const std::string& info) {
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::success].asBool(),
+              false);
+    EXPECT_EQ(
+        (*msg)[am::strings::msg_params][am::strings::result_code].asInt(),
+        static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::info].asString(),
+              info);
+  }
+
+  sync_primitives::Lock lock_;
+  NiceMock<MockHmiInterfaces> hmi_interfaces_;
+  MockMessageHelper& mock_message_helper_;
+  MockAppPtr mock_app_;
+};
+
+typedef SetDisplayLayoutRequestTest::MockHMICapabilities MockHMICapabilities;
+
+TEST_F(SetDisplayLayoutRequestTest,
+       OnEvent_UIHmiUnsupportedResource_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr msg_ui = CreateFullParamsUISO();
+  (*msg_ui)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+
+  utils::SharedPtr<SetDisplayLayoutRequest> command =
+      CreateCommand<SetDisplayLayoutRequest>(msg_ui);
+
+  MockAppPtr mock_app = CreateMockApp();
+  ON_CALL(app_mngr_, application(kConnectionKey))
+      .WillByDefault(Return(mock_app));
+
+  ON_CALL(*mock_app, app_id()).WillByDefault(Return(kConnectionKey));
+
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*msg)[am::strings::msg_params][am::strings::app_id] = kConnectionKey;
+  (*msg)[am::strings::msg_params][am::strings::info] =
+      "UI is not supported by system";
+
+  Event event(hmi_apis::FunctionID::UI_SetDisplayLayout);
+  event.set_smart_object(*msg);
+
+  ON_CALL(hmi_interfaces_,
+          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+
+  ON_CALL(mock_message_helper_,
+          HMIToMobileResult(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE))
+      .WillByDefault(Return(mobile_apis::Result::UNSUPPORTED_RESOURCE));
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
+
+  command->on_event(event);
+
+  ResultCommandExpectations(ui_command_result, "UI is not supported by system");
+}
+
+}  // namespace set_display_layout_request
+}  // namespace commands_test
+}  // namespace components
+}  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/set_global_properties_request_test.cc b/src/components/application_manager/test/commands/mobile/set_global_properties_request_test.cc
deleted file mode 100644
index c4a09a1200..0000000000
--- a/src/components/application_manager/test/commands/mobile/set_global_properties_request_test.cc
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * 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 <stdint.h>
-#include <string>
-#include <set>
-
-#include "application_manager/commands/mobile/set_global_properties_request.h"
-
-#include "gtest/gtest.h"
-#include "utils/shared_ptr.h"
-#include "utils/helpers.h"
-#include "utils/make_shared.h"
-#include "utils/custom_string.h"
-#include "smart_objects/smart_object.h"
-#include "application_manager/commands/command_request_test.h"
-#include "application_manager/smart_object_keys.h"
-#include "policy/usage_statistics/mock_statistics_manager.h"
-#include "application_manager/mock_application.h"
-#include "application_manager/mock_application_manager.h"
-#include "application_manager/mock_message_helper.h"
-#include "application_manager/mock_hmi_capabilities.h"
-#include "application_manager/event_engine/event.h"
-#include "application_manager/mock_hmi_interface.h"
-
-namespace test {
-namespace components {
-namespace commands_test {
-
-namespace am = application_manager;
-namespace hmi_response = ::application_manager::hmi_response;
-namespace strings = ::application_manager::strings;
-using am::commands::CommandImpl;
-using am::ApplicationManager;
-using am::commands::MessageSharedPtr;
-using am::ApplicationSharedPtr;
-using am::MockMessageHelper;
-using am::MockHmiInterfaces;
-using ::testing::_;
-using ::utils::SharedPtr;
-using ::testing::Return;
-using ::testing::ReturnRef;
-using am::commands::SetGlobalPropertiesRequest;
-using ::test::components::application_manager_test::MockApplication;
-
-class SetGlobalPropertiesRequestTest
-    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
- public:
-};
-
-TEST_F(SetGlobalPropertiesRequestTest, OnEvent_SUCCESS_Expect_MessageNotSend) {
-  MessageSharedPtr response = CreateMessage(smart_objects::SmartType_Map);
-  (*response)[am::strings::params][am::hmi_response::code] =
-      hmi_apis::Common_Result::SUCCESS;
-  (*response)[am::strings::msg_params][am::strings::info] = "test";
-
-  am::event_engine::Event event(hmi_apis::FunctionID::TTS_SetGlobalProperties);
-  event.set_smart_object(*response);
-
-  utils::SharedPtr<SetGlobalPropertiesRequest> command =
-      CreateCommand<SetGlobalPropertiesRequest>(response);
-
-  MockAppPtr mock_app(CreateMockApp());
-  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(mock_app));
-
-  EXPECT_CALL(
-      app_mngr_,
-      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
-      .Times(0);
-  command->on_event(event);
-}
-
-TEST_F(SetGlobalPropertiesRequestTest,
-       OnEvent_UNSUPPORTED_RESOURCE_Expect_false) {
-  MessageSharedPtr response = CreateMessage(smart_objects::SmartType_Map);
-  (*response)[am::strings::params][am::hmi_response::code] =
-      hmi_apis::Common_Result::SUCCESS;
-  (*response)[am::strings::msg_params][am::strings::info] = "qwe";
-
-  am::event_engine::Event event_tts(
-      hmi_apis::FunctionID::TTS_SetGlobalProperties);
-  event_tts.set_smart_object(*response);
-  am::event_engine::Event event_ui(
-      hmi_apis::FunctionID::UI_SetGlobalProperties);
-  event_tts.set_smart_object(*response);
-  utils::SharedPtr<SetGlobalPropertiesRequest> command =
-      CreateCommand<SetGlobalPropertiesRequest>(response);
-
-  MockAppPtr mock_app(CreateMockApp());
-  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(mock_app));
-
-  MockMessageHelper* mock_message_helper =
-      MockMessageHelper::message_helper_mock();
-  EXPECT_CALL(*mock_message_helper, HMIToMobileResult(_))
-      .WillOnce(Return(mobile_apis::Result::UNSUPPORTED_RESOURCE));
-
-  MockHmiInterfaces hmi_interfaces;
-  EXPECT_CALL(app_mngr_, hmi_interfaces())
-      .WillRepeatedly(ReturnRef(hmi_interfaces));
-  EXPECT_CALL(hmi_interfaces, GetInterfaceState(_))
-      .WillRepeatedly(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
-
-  MessageSharedPtr response_to_mobile;
-  EXPECT_CALL(
-      app_mngr_,
-      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
-      .WillOnce(DoAll(SaveArg<0>(&response_to_mobile), Return(true)));
-  command->Run();
-  command->on_event(event_ui);
-  command->on_event(event_tts);
-
-  EXPECT_EQ((*response_to_mobile)[am::strings::msg_params][am::strings::success]
-                .asBool(),
-            false);
-  EXPECT_EQ(
-      (*response_to_mobile)[am::strings::msg_params][am::strings::result_code]
-          .asInt(),
-      static_cast<int32_t>(mobile_apis::Result::INVALID_DATA));
-}
-
-}  // namespace commands_test
-}  // namespace components
-}  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/set_global_properties_test.cc b/src/components/application_manager/test/commands/mobile/set_global_properties_test.cc
new file mode 100644
index 0000000000..487be74667
--- /dev/null
+++ b/src/components/application_manager/test/commands/mobile/set_global_properties_test.cc
@@ -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.
+ */
+
+#include <stdint.h>
+#include <string>
+#include <set>
+
+#include "application_manager/commands/mobile/set_global_properties_request.h"
+
+#include "gtest/gtest.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/event_engine/event.h"
+#include "application_manager/mock_hmi_interface.h"
+
+namespace test {
+namespace components {
+namespace commands_test {
+namespace set_global_properties_request {
+
+namespace am = application_manager;
+using am::commands::SetGlobalPropertiesRequest;
+using am::commands::CommandImpl;
+using am::commands::MessageSharedPtr;
+using am::MockMessageHelper;
+using am::MockHmiInterfaces;
+using ::utils::SharedPtr;
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+
+namespace {
+const int32_t kCommandId = 1;
+const uint32_t kAppId = 1u;
+const uint32_t kCmdId = 1u;
+const uint32_t kConnectionKey = 2u;
+}  // namespace
+
+class SetGlobalPropertiesRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  SetGlobalPropertiesRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock())
+      , mock_app_(CreateMockApp()) {}
+
+  MessageSharedPtr CreateFullParamsUISO() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    msg_params[am::strings::cmd_icon] = 1;
+    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
+    msg_params[am::strings::vr_help_title] = "vr_help_title";
+    msg_params[am::strings::vr_help][0][am::strings::text] = "vr_help";
+    msg_params[am::strings::vr_help][0][am::strings::position] = 1u;
+    msg_params[am::strings::help_prompt][0][am::strings::text] = "help_promt";
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
+
+  void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, application(kConnectionKey))
+        .WillByDefault(Return(mock_app_));
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kConnectionKey));
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(hmi_interfaces_));
+  }
+
+  void TearDown() OVERRIDE {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
+
+  void ResultCommandExpectations(MessageSharedPtr msg,
+                                 const std::string& info) {
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::success].asBool(),
+              true);
+    EXPECT_EQ(
+        (*msg)[am::strings::msg_params][am::strings::result_code].asInt(),
+        static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::info].asString(),
+              info);
+  }
+
+  void ExpectationsHmiInterface_Run() {
+    EXPECT_CALL(
+        hmi_interfaces_,
+        GetInterfaceFromFunction(hmi_apis::FunctionID::UI_SetGlobalProperties))
+        .WillOnce(Return(am::HmiInterfaces::HMI_INTERFACE_UI));
+    EXPECT_CALL(
+        hmi_interfaces_,
+        GetInterfaceFromFunction(hmi_apis::FunctionID::TTS_SetGlobalProperties))
+        .WillOnce(Return(am::HmiInterfaces::HMI_INTERFACE_TTS));
+    ON_CALL(hmi_interfaces_,
+            GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+        .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+    ON_CALL(hmi_interfaces_,
+            GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_TTS))
+        .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+  }
+  sync_primitives::Lock lock_;
+  NiceMock<MockHmiInterfaces> hmi_interfaces_;
+  MockMessageHelper& mock_message_helper_;
+  MockAppPtr mock_app_;
+};
+
+TEST_F(SetGlobalPropertiesRequestTest,
+       OnEvent_UIHmiSendSuccess_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr msg_vr = CreateFullParamsUISO();
+  (*msg_vr)[am::strings::msg_params][am::strings::vr_commands][0] =
+      "vr_command";
+
+  utils::SharedPtr<SetGlobalPropertiesRequest> command =
+      CreateCommand<SetGlobalPropertiesRequest>(msg_vr);
+
+  EXPECT_CALL(app_mngr_, RemoveAppFromTTSGlobalPropertiesList(kConnectionKey));
+  const smart_objects::SmartObject* vr_help_title =
+      &((*msg_vr)[am::strings::msg_params][am::strings::vr_help_title]);
+  const smart_objects::SmartObject* vr_help =
+      &((*msg_vr)[am::strings::msg_params][am::strings::vr_help]);
+  const smart_objects::SmartObject* vr_help_prompt =
+      &((*msg_vr)[am::strings::msg_params][am::strings::help_prompt]);
+  ON_CALL(*mock_app_, vr_help_title()).WillByDefault(Return(vr_help_title));
+  ON_CALL(*mock_app_, vr_help()).WillByDefault(Return(vr_help));
+  ON_CALL(*mock_app_, help_prompt()).WillByDefault(Return(vr_help_prompt));
+
+  ExpectationsHmiInterface_Run();
+
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*msg)[am::strings::msg_params][am::strings::cmd_id] = kCommandId;
+  (*msg)[am::strings::msg_params][am::strings::info] =
+      "UI is not supported by system";
+
+  Event event(hmi_apis::FunctionID::UI_SetGlobalProperties);
+  event.set_smart_object(*msg);
+
+  ON_CALL(mock_message_helper_,
+          VerifyImageVrHelpItems(
+              (*msg_vr)[am::strings::msg_params][am::strings::vr_help], _, _))
+      .WillByDefault(Return(mobile_apis::Result::SUCCESS));
+
+  ON_CALL(mock_message_helper_, VerifyImage(_, _, _))
+      .WillByDefault(Return(mobile_apis::Result::SUCCESS));
+
+  EXPECT_CALL(*mock_app_, UpdateHash());
+
+  (*msg_vr)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::SUCCESS;
+  Event event_vr(hmi_apis::FunctionID::TTS_SetGlobalProperties);
+  event_vr.set_smart_object(*msg_vr);
+
+  command->Run();
+  command->on_event(event_vr);
+
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
+
+  command->on_event(event);
+
+  ResultCommandExpectations(ui_command_result, "UI is not supported by system");
+}
+
+TEST_F(SetGlobalPropertiesRequestTest, OnEvent_SUCCESS_Expect_MessageNotSend) {
+  MessageSharedPtr response = CreateMessage(smart_objects::SmartType_Map);
+  (*response)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::SUCCESS;
+  (*response)[am::strings::msg_params][am::strings::info] = "test";
+
+  am::event_engine::Event event(hmi_apis::FunctionID::TTS_SetGlobalProperties);
+  event.set_smart_object(*response);
+
+  utils::SharedPtr<SetGlobalPropertiesRequest> command =
+      CreateCommand<SetGlobalPropertiesRequest>(response);
+
+  MockAppPtr mock_app(CreateMockApp());
+  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(mock_app));
+
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .Times(0);
+  command->on_event(event);
+}
+
+TEST_F(SetGlobalPropertiesRequestTest,
+       OnEvent_UNSUPPORTED_RESOURCE_Expect_false) {
+  MessageSharedPtr response = CreateMessage(smart_objects::SmartType_Map);
+  (*response)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::SUCCESS;
+  (*response)[am::strings::msg_params][am::strings::info] = "qwe";
+
+  am::event_engine::Event event_tts(
+      hmi_apis::FunctionID::TTS_SetGlobalProperties);
+  event_tts.set_smart_object(*response);
+  am::event_engine::Event event_ui(
+      hmi_apis::FunctionID::UI_SetGlobalProperties);
+  event_tts.set_smart_object(*response);
+  utils::SharedPtr<SetGlobalPropertiesRequest> command =
+      CreateCommand<SetGlobalPropertiesRequest>(response);
+
+  MockAppPtr mock_app(CreateMockApp());
+  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(mock_app));
+
+  ON_CALL(mock_message_helper_, HMIToMobileResult(_))
+      .WillByDefault(Return(mobile_apis::Result::UNSUPPORTED_RESOURCE));
+
+  MockHmiInterfaces hmi_interfaces;
+  EXPECT_CALL(app_mngr_, hmi_interfaces())
+      .WillRepeatedly(ReturnRef(hmi_interfaces));
+  EXPECT_CALL(hmi_interfaces, GetInterfaceState(_))
+      .WillRepeatedly(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));
+
+  MessageSharedPtr response_to_mobile;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&response_to_mobile), Return(true)));
+
+  command->Run();
+  command->on_event(event_ui);
+  command->on_event(event_tts);
+
+  EXPECT_EQ((*response_to_mobile)[am::strings::msg_params][am::strings::success]
+                .asBool(),
+            false);
+  EXPECT_EQ(
+      (*response_to_mobile)[am::strings::msg_params][am::strings::result_code]
+          .asInt(),
+      static_cast<int32_t>(mobile_apis::Result::INVALID_DATA));
+}
+
+}  // namespace set_global_properties_request
+}  // namespace commands_test
+}  // namespace components
+}  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/set_media_clock_timer_test.cc b/src/components/application_manager/test/commands/mobile/set_media_clock_timer_test.cc
new file mode 100644
index 0000000000..e7e4513f15
--- /dev/null
+++ b/src/components/application_manager/test/commands/mobile/set_media_clock_timer_test.cc
@@ -0,0 +1,145 @@
+/*
+ * 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 <stdint.h>
+#include <string>
+
+#include "application_manager/commands/mobile/set_media_clock_timer_request.h"
+
+#include "gtest/gtest.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/event_engine/event.h"
+#include "application_manager/mock_hmi_interface.h"
+
+namespace test {
+namespace components {
+namespace commands_test {
+namespace mobile_commands_test {
+namespace set_media_clock_timer_request {
+
+namespace am = ::application_manager;
+using am::commands::SetMediaClockRequest;
+using am::commands::MessageSharedPtr;
+using am::event_engine::Event;
+using am::MockHmiInterfaces;
+using am::MockMessageHelper;
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+
+typedef SharedPtr<SetMediaClockRequest> SetMediaClockRequestPtr;
+
+namespace {
+const uint32_t kConnectionKey = 2u;
+}  // namespace
+
+class SetMediaClockRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  SetMediaClockRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock())
+      , mock_app_(CreateMockApp()) {}
+
+  void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, application(kConnectionKey))
+        .WillByDefault(Return(mock_app_));
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kConnectionKey));
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(hmi_interfaces_));
+  }
+
+  void TearDown() OVERRIDE {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
+
+  void ResultCommandExpectations(MessageSharedPtr msg,
+                                 const std::string& info) {
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::success].asBool(),
+              true);
+    EXPECT_EQ(
+        (*msg)[am::strings::msg_params][am::strings::result_code].asInt(),
+        static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::info].asString(),
+              info);
+  }
+
+  NiceMock<MockHmiInterfaces> hmi_interfaces_;
+  MockMessageHelper& mock_message_helper_;
+  MockAppPtr mock_app_;
+};
+
+TEST_F(SetMediaClockRequestTest,
+       OnEvent_UIHmiSendUnsupportedResource_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+
+  utils::SharedPtr<SetMediaClockRequest> command =
+      CreateCommand<SetMediaClockRequest>(msg);
+
+  MessageSharedPtr ev_msg = CreateMessage(smart_objects::SmartType_Map);
+  (*ev_msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*ev_msg)[am::strings::msg_params][am::strings::app_id] = kConnectionKey;
+  (*ev_msg)[am::strings::msg_params][am::strings::info] =
+      "UI is not supported by system";
+
+  Event event(hmi_apis::FunctionID::UI_SetMediaClockTimer);
+  event.set_smart_object(*ev_msg);
+
+  EXPECT_CALL(hmi_interfaces_,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillRepeatedly(Return(am::HmiInterfaces::STATE_NOT_RESPONSE));
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE))
+      .WillOnce(Return(mobile_apis::Result::UNSUPPORTED_RESOURCE));
+
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
+
+  command->on_event(event);
+
+  ResultCommandExpectations(ui_command_result, "UI is not supported by system");
+}
+
+}  // namespace set_media_clock_timer_request
+}  // namespace mobile_commands_test
+}  // namespace commands_test
+}  // namespace components
+}  // namespace test
diff --git a/src/components/application_manager/test/commands/mobile/show_test.cc b/src/components/application_manager/test/commands/mobile/show_test.cc
new file mode 100644
index 0000000000..89c600362b
--- /dev/null
+++ b/src/components/application_manager/test/commands/mobile/show_test.cc
@@ -0,0 +1,158 @@
+/*
+ * 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 <stdint.h>
+#include <string>
+#include <set>
+
+#include "application_manager/commands/mobile/show_request.h"
+
+#include "gtest/gtest.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/event_engine/event.h"
+#include "application_manager/mock_hmi_interface.h"
+
+namespace test {
+namespace components {
+namespace commands_test {
+
+namespace am = application_manager;
+using am::commands::ShowRequest;
+using am::commands::CommandImpl;
+using am::commands::MessageSharedPtr;
+using am::MockMessageHelper;
+using am::MockHmiInterfaces;
+using ::utils::SharedPtr;
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+
+namespace {
+const int32_t kCommandId = 1;
+const uint32_t kAppId = 1u;
+const uint32_t kCmdId = 1u;
+const uint32_t kConnectionKey = 2u;
+}  // namespace
+
+class ShowRequestTest : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  ShowRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock()) {}
+  sync_primitives::Lock lock_;
+
+  MessageSharedPtr CreateFullParamsUISO() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    msg_params[am::strings::cmd_icon] = 1;
+    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
+  MockMessageHelper& mock_message_helper_;
+};
+
+TEST_F(ShowRequestTest, OnEvent_UI_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr msg_vr = CreateFullParamsUISO();
+  (*msg_vr)[am::strings::msg_params][am::strings::menu_params]
+           [am::hmi_request::parent_id] = 10u;
+  (*msg_vr)[am::strings::msg_params][am::strings::menu_params]
+           [am::strings::menu_name] = "menu_name";
+
+  utils::SharedPtr<ShowRequest> command = CreateCommand<ShowRequest>(msg_vr);
+
+  MockAppPtr mock_app = CreateMockApp();
+  ON_CALL(app_mngr_, application(kConnectionKey))
+      .WillByDefault(Return(mock_app));
+  ON_CALL(*mock_app, app_id()).WillByDefault(Return(kConnectionKey));
+  MockHmiInterfaces hmi_interfaces;
+  ON_CALL(app_mngr_, hmi_interfaces()).WillByDefault(ReturnRef(hmi_interfaces));
+  ON_CALL(hmi_interfaces, GetInterfaceFromFunction(_))
+      .WillByDefault(
+          Return(am::HmiInterfaces::HMI_INTERFACE_BasicCommunication));
+  ON_CALL(hmi_interfaces, GetInterfaceState(_))
+      .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));
+
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*msg)[am::strings::msg_params][am::strings::cmd_id] = kCommandId;
+
+  Event event(hmi_apis::FunctionID::UI_Show);
+  event.set_smart_object(*msg);
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE))
+      .WillOnce(Return(mobile_apis::Result::UNSUPPORTED_RESOURCE));
+
+  MessageSharedPtr vr_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&vr_command_result), Return(true)));
+
+  command->on_event(event);
+
+  EXPECT_EQ((*vr_command_result)[am::strings::msg_params][am::strings::success]
+                .asBool(),
+            true);
+  EXPECT_EQ(
+      (*vr_command_result)[am::strings::msg_params][am::strings::result_code]
+          .asInt(),
+      static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+  if ((*vr_command_result)[am::strings::msg_params].keyExists(
+          am::strings::info)) {
+    EXPECT_FALSE(
+        (*vr_command_result)[am::strings::msg_params][am::strings::info]
+            .asString()
+            .empty());
+  }
+  Mock::VerifyAndClearExpectations(&mock_message_helper_);
+}
+
+}  // namespace commands_test
+}  // namespace components
+}  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/slider_test.cc b/src/components/application_manager/test/commands/mobile/slider_test.cc
new file mode 100644
index 0000000000..7600d30304
--- /dev/null
+++ b/src/components/application_manager/test/commands/mobile/slider_test.cc
@@ -0,0 +1,156 @@
+/*
+ * 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 <stdint.h>
+#include <string>
+#include <set>
+
+#include "application_manager/commands/mobile/slider_request.h"
+
+#include "gtest/gtest.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_message_helper.h"
+#include "application_manager/event_engine/event.h"
+#include "application_manager/mock_hmi_interface.h"
+
+namespace test {
+namespace components {
+namespace commands_test {
+
+namespace am = application_manager;
+using am::commands::SliderRequest;
+using am::commands::CommandImpl;
+using am::commands::MessageSharedPtr;
+using am::MockMessageHelper;
+using am::MockHmiInterfaces;
+using ::utils::SharedPtr;
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+
+namespace {
+const int32_t kCommandId = 1;
+const uint32_t kAppId = 1u;
+const uint32_t kCmdId = 1u;
+const uint32_t kConnectionKey = 2u;
+}  // namespace
+
+class SliderRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  SliderRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock()) {}
+  MockMessageHelper& mock_message_helper_;
+  sync_primitives::Lock lock_;
+
+  MessageSharedPtr CreateFullParamsUISO() {
+    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+    smart_objects::SmartObject menu_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    menu_params[am::strings::position] = 10;
+    menu_params[am::strings::menu_name] = "LG";
+
+    smart_objects::SmartObject msg_params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    msg_params[am::strings::cmd_id] = kCmdId;
+    msg_params[am::strings::menu_params] = menu_params;
+    msg_params[am::strings::app_id] = kAppId;
+    msg_params[am::strings::cmd_icon] = 1;
+    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
+    (*msg)[am::strings::msg_params] = msg_params;
+
+    return msg;
+  }
+};
+
+TEST_F(SliderRequestTest, OnEvent_UI_UNSUPPORTED_RESOURCE) {
+  MessageSharedPtr msg_ui = CreateFullParamsUISO();
+  (*msg_ui)[am::strings::params][am::strings::connection_key] = kConnectionKey;
+
+  utils::SharedPtr<SliderRequest> command =
+      CreateCommand<SliderRequest>(msg_ui);
+
+  MockAppPtr mock_app = CreateMockApp();
+  ON_CALL(app_mngr_, application(kConnectionKey))
+      .WillByDefault(Return(mock_app));
+
+  ON_CALL(*mock_app, app_id()).WillByDefault(Return(kConnectionKey));
+  MockHmiInterfaces hmi_interfaces;
+  ON_CALL(app_mngr_, hmi_interfaces()).WillByDefault(ReturnRef(hmi_interfaces));
+  EXPECT_CALL(hmi_interfaces,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillOnce(Return(am::HmiInterfaces::STATE_AVAILABLE));
+
+  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
+  (*msg)[am::strings::params][am::hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*msg)[am::strings::msg_params][am::strings::info] = "info";
+
+  Event event(hmi_apis::FunctionID::UI_Slider);
+  event.set_smart_object(*msg);
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE))
+      .WillOnce(Return(mobile_apis::Result::UNSUPPORTED_RESOURCE));
+
+  MessageSharedPtr ui_command_result;
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
+
+  command->on_event(event);
+
+  EXPECT_EQ((*ui_command_result)[am::strings::msg_params][am::strings::success]
+                .asBool(),
+            true);
+  EXPECT_EQ(
+      (*ui_command_result)[am::strings::msg_params][am::strings::result_code]
+          .asInt(),
+      static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
+  if ((*ui_command_result)[am::strings::msg_params].keyExists(
+          am::strings::info)) {
+    EXPECT_FALSE(
+        (*ui_command_result)[am::strings::msg_params][am::strings::info]
+            .asString()
+            .empty());
+  }
+  Mock::VerifyAndClearExpectations(&mock_message_helper_);
+}
+
+}  // namespace commands_test
+}  // namespace components
+}  // namespace tests
diff --git a/src/components/application_manager/test/commands/mobile/unsubscribe_way_points_request_test.cc b/src/components/application_manager/test/commands/mobile/unsubscribe_way_points_request_test.cc
deleted file mode 100644
index 906c7d8f0f..0000000000
--- a/src/components/application_manager/test/commands/mobile/unsubscribe_way_points_request_test.cc
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * 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 "gtest/gtest.h"
-#include "utils/shared_ptr.h"
-#include "smart_objects/smart_object.h"
-#include "application_manager/test/include/application_manager/commands/commands_test.h"
-#include "application_manager/test/include/application_manager/commands/command_request_test.h"
-#include "application_manager/application.h"
-#include "application_manager/mock_application_manager.h"
-#include "application_manager/mock_application.h"
-#include "application_manager/mock_hmi_capabilities.h"
-#include "application_manager/commands/mobile/unsubscribe_way_points_request.h"
-#include "interfaces/MOBILE_API.h"
-#include "application_manager/smart_object_keys.h"
-
-namespace test {
-namespace components {
-namespace commands_test {
-namespace mobile_commands_test {
-
-using ::testing::_;
-using ::testing::Return;
-using ::testing::ReturnRef;
-using ::testing::DoAll;
-using ::testing::SaveArg;
-using ::testing::InSequence;
-namespace am = ::application_manager;
-using am::commands::UnSubscribeWayPointsRequest;
-using am::commands::MessageSharedPtr;
-
-typedef SharedPtr<UnSubscribeWayPointsRequest> CommandPtr;
-
-class UnsubscribeWayPointsRequestTest
-    : public CommandRequestTest<CommandsTestMocks::kIsNice> {};
-
-TEST_F(UnsubscribeWayPointsRequestTest, OnEvent_SUCCESS) {
-  CommandPtr command(CreateCommand<UnSubscribeWayPointsRequest>());
-  MockAppPtr app(CreateMockApp());
-  Event event(hmi_apis::FunctionID::Navigation_UnsubscribeWayPoints);
-
-  MessageSharedPtr event_msg(CreateMessage(smart_objects::SmartType_Map));
-  (*event_msg)[am::strings::params][am::hmi_response::code] =
-      mobile_apis::Result::SUCCESS;
-  (*event_msg)[am::strings::msg_params] = 0;
-
-  event.set_smart_object(*event_msg);
-
-  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(app));
-
-  {
-    InSequence dummy;
-    EXPECT_CALL(app_mngr_, UnsubscribeAppFromWayPoints(_));
-    EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _));
-    EXPECT_CALL(*app, UpdateHash());
-  }
-
-  command->on_event(event);
-}
-
-}  // namespace mobile_commands_test
-}  // namespace commands_test
-}  // namespace components
-}  // namespace test