Merge pull request #1076 from indlu/feature/Cover_add_command_request_send_location_request_with_UT

Cover add_command_request send location request with unit tests

2 files changed, 1357 insertions, 188 deletions

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 78a6aa2f4d..567c3d32f9 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
@@ -57,285 +57,1055 @@ namespace mobile_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 ::testing::Mock;
-using ::testing::Return;
-using ::testing::ReturnRef;
 using ::utils::SharedPtr;
+using ::testing::Return;
+using ::testing::Mock;
+using ::testing::InSequence;
+using am::commands::AddCommandRequest;
+using NsSmartDeviceLink::NsSmartObjects::SmartObjectSPtr;
 using ::test::components::application_manager_test::MockApplication;
+using am::event_engine::EventObserver;
+using namespace smart_objects;
 
 namespace custom_str = utils::custom_string;
 namespace strings = ::application_manager::strings;
+namespace mobile_result = mobile_apis::Result;
 namespace hmi_response = ::application_manager::hmi_response;
+namespace hmi_request = ::application_manager::hmi_request;
+using namespace strings;
 
 namespace {
-const int32_t kCommandId = 1;
+const hmi_apis::FunctionID::eType kInvalidFunctionId =
+    hmi_apis::FunctionID::INVALID_ENUM;
 const uint32_t kAppId = 1u;
 const uint32_t kCmdId = 1u;
 const uint32_t kConnectionKey = 2u;
+const std::string kMenuName = "LG";
+const uint32_t kFirstParentId = 10u;
+const uint32_t kSecondParentId = 1u;
+const std::string kErroredVRCommand = "l\namer";
+const std::string kFirstVrCommand = "lamer";
+const std::string kSecondVrCommand = "hacker";
+const uint32_t kFirstCommandId = 10u;
+const uint32_t kSecondCommandId = 11u;
+const int32_t kType = 34;
+const int32_t kGrammarId = 12;
+const int32_t kPosition = 10;
 }  // namespace
 
 class AddCommandRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
  public:
   AddCommandRequestTest()
-      : mock_message_helper_(*MockMessageHelper::message_helper_mock())
-      , mock_app_(CreateMockApp()) {}
+      : msg_(CreateMessage())
+      , default_app_name_("test_default_app_name_")
+      , mock_message_helper_(*MockMessageHelper::message_helper_mock())
+      , mock_app_(CreateMockApp()) {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+    EXPECT_CALL(app_mngr_, application(kConnectionKey))
+        .WillRepeatedly(Return(mock_app_));
+    InitGetters();
+    InitBasicMessage();
+  }
+
+  ~AddCommandRequestTest() {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
 
  protected:
-  MessageSharedPtr CreateFullParamsVRSO() {
-    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
-    (*msg)[strings::params][strings::connection_key] = kConnectionKey;
-    smart_objects::SmartObject msg_params =
-        smart_objects::SmartObject(smart_objects::SmartType_Map);
-    msg_params[strings::cmd_id] = kCmdId;
-    msg_params[strings::vr_commands] =
-        smart_objects::SmartObject(smart_objects::SmartType_Array);
-    msg_params[strings::vr_commands][0] = "lamer";
-    msg_params[strings::type] = 34;
-    msg_params[strings::grammar_id] = 12;
-    msg_params[strings::app_id] = kAppId;
-    (*msg)[strings::msg_params] = msg_params;
-
-    return msg;
+  void InitBasicMessage() {
+    (*msg_)[params][connection_key] = kConnectionKey;
+    (*msg_)[msg_params][app_id] = kAppId;
+    (*msg_)[msg_params][app_name] = default_app_name_;
   }
 
-  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 InitGetters() {
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kAppId));
+    ON_CALL(*mock_app_, FindCommand(kCmdId))
+        .WillByDefault(Return(so_ptr_.get()));
   }
 
-  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 CreateBasicParamsUIRequest() {
+    SmartObject menu_params = SmartObject(SmartType_Map);
+    menu_params[position] = kPosition;
+    menu_params[menu_name] = kMenuName;
+    SmartObject& msg_params = (*msg_)[strings::msg_params];
+    msg_params[cmd_id] = kCmdId;
+    msg_params[strings::menu_params] = menu_params;
+    msg_params[cmd_icon] = 1;
+    msg_params[cmd_icon][value] = "10";
+    msg_params[info] = "UI 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 CreateBasicParamsVRRequest() {
+    SmartObject& msg_params = (*msg_)[strings::msg_params];
+    msg_params[cmd_id] = kCmdId;
+    msg_params[vr_commands] = SmartObject(SmartType_Array);
+    msg_params[vr_commands][0] = kFirstVrCommand;
+    msg_params[type] = kPosition;
+    msg_params[grammar_id] = kGrammarId;
+    msg_params[info] = "VR info";
   }
 
-  void TearDown() OVERRIDE {
-    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  const am::CommandsMap CreateCommandsMap(SmartObject& first_command,
+                                          SmartObject& second_command) {
+    second_command[menu_params] = SmartObject(SmartType_Map);
+    second_command[menu_params][hmi_request::parent_id] = kFirstParentId;
+    second_command[menu_params][menu_name] = kMenuName;
+    second_command[vr_commands] = SmartObject(SmartType_Array);
+    second_command[vr_commands][0] = kSecondVrCommand;
+    am::CommandsMap commands_map;
+    commands_map.insert(std::make_pair(kFirstCommandId, &first_command));
+    commands_map.insert(std::make_pair(kSecondCommandId, &second_command));
+    return commands_map;
   }
 
-  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 CheckOnTimeOutCommandDeletion(
+      const hmi_apis::FunctionID::eType incoming_cmd,
+      const hmi_apis::FunctionID::eType cmd_to_delete) {
+    CreateBasicParamsVRRequest();
+    CreateBasicParamsUIRequest();
+    SmartObject& msg_params = (*msg_)[strings::msg_params];
+    msg_params[menu_params][hmi_request::parent_id] = kSecondParentId;
+    SmartObject& image = msg_params[cmd_icon];
+    EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+        .WillOnce(Return(mobile_apis::Result::SUCCESS));
+    EXPECT_CALL(*mock_app_, FindCommand(kCmdId))
+        .WillOnce(Return(so_ptr_.get()));
+    SmartObject first_command = SmartObject(SmartType_Map);
+    SmartObject second_command = SmartObject(SmartType_Map);
+    const am::CommandsMap commands_map =
+        CreateCommandsMap(first_command, second_command);
+    EXPECT_CALL(*mock_app_, commands_map())
+        .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+            commands_map, lock_)));
+    so_ptr_ = utils::MakeShared<SmartObject>(SmartType_Map);
+    EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
+        .WillOnce(Return(so_ptr_.get()));
+    {
+      InSequence dummy;
+      EXPECT_CALL(app_mngr_,
+                  ManageHMICommand(
+                      HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+          .WillOnce(Return(true));
+      EXPECT_CALL(app_mngr_,
+                  ManageHMICommand(
+                      HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+          .WillOnce(Return(true));
+    }
+    EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
+    utils::SharedPtr<AddCommandRequest> request_ptr =
+        CreateCommand<AddCommandRequest>(msg_);
+    request_ptr->Run();
+    Event event(incoming_cmd);
+    event.set_smart_object(*msg_);
+    request_ptr->on_event(event);
+    EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
+    EXPECT_CALL(app_mngr_, ManageHMICommand(HMIResultCodeIs(cmd_to_delete)))
+        .WillOnce(Return(true));
+    SmartObjectSPtr response;
+    EXPECT_CALL(
+        mock_message_helper_,
+        CreateNegativeResponse(_, _, _, mobile_apis::Result::GENERIC_ERROR))
+        .WillOnce(Return(response));
+    EXPECT_CALL(
+        app_mngr_,
+        ManageMobileCommand(response,
+                            am::commands::Command::CommandOrigin::ORIGIN_SDL));
+    utils::SharedPtr<CommandRequestImpl> base_class_request =
+        static_cast<utils::SharedPtr<CommandRequestImpl> >(request_ptr);
+    base_class_request->onTimeOut();
   }
 
+  MessageSharedPtr msg_;
+  SmartObjectSPtr so_ptr_;
+  const utils::custom_string::CustomString default_app_name_;
+  am::MockMessageHelper& mock_message_helper_;
   sync_primitives::Lock lock_;
-  NiceMock<MockHmiInterfaces> hmi_interfaces_;
-  MockMessageHelper& mock_message_helper_;
   MockAppPtr mock_app_;
 };
 
-TEST_F(AddCommandRequestTest, OnTimeout_GENERIC_ERROR) {
-  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
-  (*msg)[strings::msg_params][strings::result_code] =
-      am::mobile_api::Result::GENERIC_ERROR;
-  (*msg)[strings::msg_params][strings::success] = false;
-  (*msg)[strings::params][strings::connection_key] = kConnectionKey;
+TEST_F(AddCommandRequestTest, Run_AppNotExisted_EXPECT_AppNotRegistered) {
+  CreateBasicParamsUIRequest();
+  EXPECT_CALL(app_mngr_, application(kConnectionKey))
+      .WillOnce(Return(ApplicationSharedPtr()));
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(
+          MobileResultCodeIs(mobile_result::APPLICATION_NOT_REGISTERED), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+}
+
+TEST_F(AddCommandRequestTest, Run_ImageVerificationFailed_EXPECT_INVALID_DATA) {
+  CreateBasicParamsUIRequest();
+  SmartObject& msg_params = (*msg_)[strings::msg_params];
+  SmartObject& image = msg_params[cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::INVALID_DATA));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+}
+
+TEST_F(AddCommandRequestTest, Run_MenuNameHasSyntaxError_EXPECT_INVALID_DATA) {
+  CreateBasicParamsUIRequest();
+  SmartObject& msg_params = (*msg_)[strings::msg_params];
+  msg_params[menu_params][hmi_request::parent_id] = kFirstParentId;
+  const std::string errored_menu_name = "L\nG";
+  msg_params[menu_params][menu_name] = errored_menu_name;
+  SmartObject& image = msg_params[cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  SmartObject parent = SmartObject(SmartType_Map);
+  EXPECT_CALL(*mock_app_, FindSubMenu(kFirstParentId))
+      .WillOnce(Return(&parent));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+}
+
+TEST_F(AddCommandRequestTest,
+       Run_VRCommandsHaveSyntaxError_EXPECT_INVALID_DATA) {
+  CreateBasicParamsVRRequest();
+  SmartObject& msg_params = (*msg_)[strings::msg_params];
+  msg_params[vr_commands][0] = kErroredVRCommand;
+  EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+}
 
-  utils::SharedPtr<AddCommandRequest> command =
+TEST_F(AddCommandRequestTest, Run_CMDIconHasError_EXPECT_INVALID_DATA) {
+  MessageSharedPtr msg = CreateMessage();
+  SmartObject& msg_params = (*msg)[strings::msg_params];
+  (*msg)[params][connection_key] = kConnectionKey;
+  msg_params[cmd_id] = kCmdId;
+  msg_params[cmd_icon] = 1;
+  const std::string errored_cmd_icon_value = "1\n0";
+  msg_params[cmd_icon][value] = errored_cmd_icon_value;
+  msg_params[vr_commands][0] = kFirstVrCommand;
+  SmartObject& image = msg_params[cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
       CreateCommand<AddCommandRequest>(msg);
+  request_ptr->Run();
+}
 
-  ON_CALL(*mock_app_, get_grammar_id()).WillByDefault(Return(kConnectionKey));
-  ON_CALL(*mock_app_, RemoveCommand(_)).WillByDefault(Return());
+TEST_F(AddCommandRequestTest, Run_CommandIDAlreadyExists_EXPECT_INVALID_ID) {
+  CreateBasicParamsUIRequest();
+  SmartObject& msg_params = (*msg_)[strings::msg_params];
+  SmartObject& image = msg_params[cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  so_ptr_ = utils::MakeShared<SmartObject>(SmartType_Map);
+  EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::INVALID_ID), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+}
 
-  EXPECT_CALL(
-      mock_message_helper_,
-      CreateNegativeResponse(_, _, _, am::mobile_api::Result::GENERIC_ERROR))
-      .WillOnce(Return(msg));
+TEST_F(AddCommandRequestTest,
+       Run_CommandNameAlreadyExists_EXPECT_DUPLICATE_NAME) {
+  CreateBasicParamsUIRequest();
+  SmartObject& msg_params = (*msg_)[strings::msg_params];
+  msg_params[menu_params][hmi_request::parent_id] = kFirstParentId;
+  SmartObject& image = msg_params[cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
+  SmartObject first_command = SmartObject(SmartType_Map);
+  SmartObject second_command = SmartObject(SmartType_Map);
+  const am::CommandsMap commands_map =
+      CreateCommandsMap(first_command, second_command);
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::DUPLICATE_NAME), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+}
+
+TEST_F(AddCommandRequestTest,
+       Run_CmdAndMsgParentIDsAreDifferentSubmenuNotExisted_EXPECT_INVALID_ID) {
+  CreateBasicParamsUIRequest();
+  SmartObject& msg_params = (*msg_)[strings::msg_params];
+  msg_params[menu_params][hmi_request::parent_id] = kSecondParentId;
+  SmartObject& image = msg_params[cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
+  SmartObject first_command = SmartObject(SmartType_Map);
+  SmartObject second_command = SmartObject(SmartType_Map);
+  const am::CommandsMap commands_map =
+      CreateCommandsMap(first_command, second_command);
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
+      .WillOnce(Return(so_ptr_.get()));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::INVALID_ID), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+}
+
+TEST_F(AddCommandRequestTest,
+       Run_CmdAndMsgVrSynonymsAreTheSame_EXPECT_DUPLICATE_NAME) {
+  CreateBasicParamsVRRequest();
+  SmartObject& msg_params = (*msg_)[strings::msg_params];
+  msg_params[menu_params][hmi_request::parent_id] = kSecondParentId;
+  msg_params[vr_commands][0] = kSecondVrCommand;
+  SmartObject& image = msg_params[cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
 
-  MessageSharedPtr command_result;
+  SmartObject first_command = SmartObject(SmartType_Map);
+  SmartObject second_command = SmartObject(SmartType_Map);
+  const am::CommandsMap commands_map =
+      CreateCommandsMap(first_command, second_command);
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  so_ptr_ = utils::MakeShared<SmartObject>(SmartType_Map);
+  EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
+      .WillOnce(Return(so_ptr_.get()));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::DUPLICATE_NAME), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+}
+
+TEST_F(AddCommandRequestTest, Run_MsgDataEmpty_EXPECT_INVALID_DATA) {
+  MessageSharedPtr msg = CreateMessage();
+  (*msg)[params][connection_key] = kConnectionKey;
+  SmartObject& msg_params = (*msg)[strings::msg_params];
+  msg_params[app_id] = kAppId;
+  msg_params[cmd_id] = kCmdId;
+  EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg);
+  request_ptr->Run();
+}
+
+TEST_F(AddCommandRequestTest,
+       Run_CmdAndMsg_UI_and_Vr_AreCorrect_EXPECT_VR_AND_UI_SENT) {
+  CreateBasicParamsVRRequest();
+  CreateBasicParamsUIRequest();
+  SmartObject& msg_params = (*msg_)[strings::msg_params];
+  msg_params[menu_params][hmi_request::parent_id] = kSecondParentId;
+  SmartObject& image = msg_params[cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
+  SmartObject first_command = SmartObject(SmartType_Map);
+  SmartObject second_command = SmartObject(SmartType_Map);
+  const am::CommandsMap commands_map =
+      CreateCommandsMap(first_command, second_command);
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  so_ptr_ = utils::MakeShared<SmartObject>(SmartType_Map);
+  EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
+      .WillOnce(Return(so_ptr_.get()));
+  {
+    InSequence dummy;
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+        .WillOnce(Return(true));
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+        .WillOnce(Return(true));
+  }
+  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+}
+
+TEST_F(AddCommandRequestTest, GetRunMethods_SUCCESS) {
+  CreateBasicParamsUIRequest();
+  SmartObject& image = (*msg_)[msg_params][cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
+  EXPECT_CALL(*mock_app_, AddCommand(kCmdId, (*msg_)[msg_params]));
+
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
   EXPECT_CALL(
       app_mngr_,
-      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
-      .WillOnce(DoAll(SaveArg<0>(&command_result), Return(true)));
-
-  command->onTimeOut();
-  EXPECT_EQ((*command_result)[strings::msg_params][strings::success].asBool(),
-            false);
-  EXPECT_EQ(
-      (*command_result)[strings::msg_params][strings::result_code].asInt(),
-      static_cast<int32_t>(am::mobile_api::Result::GENERIC_ERROR));
+      ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+      .WillOnce(Return(true));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
 }
 
-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";
+TEST_F(AddCommandRequestTest, OnEvent_UI_SUCCESS) {
+  CreateBasicParamsUIRequest();
+  (*msg_)[params][hmi_response::code] = hmi_apis::Common_Result::SUCCESS;
+  SmartObject& image = (*msg_)[msg_params][cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_, AddCommand(kCmdId, (*msg_)[msg_params]));
 
-  utils::SharedPtr<AddCommandRequest> command =
-      CreateCommand<AddCommandRequest>(msg_vr);
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(
+          Return(DataAccessor<am::CommandsMap>(commands_map, lock_)));
 
-  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));
+  Event event(hmi_apis::FunctionID::UI_AddCommand);
+  event.set_smart_object(*msg_);
+  EXPECT_CALL(
+      app_mngr_,
+      ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+      .WillOnce(Return(true));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::SUCCESS))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_, UpdateHash());
+  request_ptr->on_event(event);
+}
 
-  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
-  (*msg)[strings::params][hmi_response::code] =
-      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
-  (*msg)[am::strings::msg_params][am::strings::info] =
-      "VR is not supported by system";
-  (*msg)[strings::msg_params][strings::cmd_id] = kCommandId;
+TEST_F(AddCommandRequestTest, OnEvent_VR_SUCCESS) {
+  CreateBasicParamsVRRequest();
+  MessageSharedPtr msg = CreateMessage(SmartType_Map);
+  (*msg)[params][hmi_response::code] = hmi_apis::Common_Result::SUCCESS;
+  (*msg)[msg_params][cmd_id] = kCmdId;
 
   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));
-
-  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_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::SUCCESS))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_, AddCommand(kCmdId, (*msg_)[msg_params]));
 
   am::CommandsMap commands_map;
-  ON_CALL(*mock_app_, commands_map())
-      .WillByDefault(
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(
           Return(DataAccessor<am::CommandsMap>(commands_map, lock_)));
-
   EXPECT_CALL(*mock_app_, UpdateHash());
+  EXPECT_CALL(
+      app_mngr_,
+      ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+      .WillOnce(Return(true));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+  request_ptr->on_event(event);
+}
 
-  MessageSharedPtr msg_ui(CreateMessage(smart_objects::SmartType_Map));
-  (*msg_ui)[am::strings::params][am::hmi_response::code] =
-      hmi_apis::Common_Result::SUCCESS;
+TEST_F(AddCommandRequestTest, OnTimeOut_EXPECT_VR_DeleteCommand) {
+  CheckOnTimeOutCommandDeletion(hmi_apis::FunctionID::VR_AddCommand,
+                                hmi_apis::FunctionID::VR_DeleteCommand);
+}
+
+TEST_F(AddCommandRequestTest, OnTimeOut_EXPECT_UI_DeleteCommand) {
+  CheckOnTimeOutCommandDeletion(hmi_apis::FunctionID::UI_AddCommand,
+                                hmi_apis::FunctionID::UI_DeleteCommand);
+}
+
+TEST_F(AddCommandRequestTest, OnEvent_BothSend_SUCCESS) {
+  MessageSharedPtr command_msg = CreateMessage(SmartType_Map);
+  (*command_msg)[params][connection_key] = kConnectionKey;
+  MessageSharedPtr event_msg = CreateMessage(SmartType_Map);
+  (*event_msg)[params][hmi_response::code] = hmi_apis::Common_Result::SUCCESS;
+  (*event_msg)[msg_params][cmd_id] = kCmdId;
 
   Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
-  event_ui.set_smart_object(*msg_ui);
+  event_ui.set_smart_object(*event_msg);
+
+  Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
+  event_vr.set_smart_object(*event_msg);
 
-  command->Run();
-  command->on_event(event_ui);
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(0);
 
-  MessageSharedPtr vr_command_result;
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(command_msg);
+  request_ptr->Run();
+  request_ptr->on_event(event_ui);
+  request_ptr->on_event(event_vr);
+}
+
+TEST_F(AddCommandRequestTest, OnEvent_UnknownEvent_UNSUCCESS) {
+  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  Event event(hmi_apis::FunctionID::INVALID_ENUM);
+  request_ptr->on_event(event);
+}
+
+TEST_F(AddCommandRequestTest, OnEvent_AppNotExisted_UNSUCCESS) {
+  CreateBasicParamsUIRequest();
+  EXPECT_CALL(app_mngr_, application(kConnectionKey))
+      .WillOnce(Return(ApplicationSharedPtr()));
+  Event event(hmi_apis::FunctionID::UI_AddCommand);
+  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->on_event(event);
+}
+
+TEST_F(AddCommandRequestTest,
+       OnEvent_HmiResponseCodeIsRejected_ExpectUICommandRemoved) {
+  CreateBasicParamsUIRequest();
+  SmartObject& params = (*msg_)[strings::params];
+  params[hmi_response::code] = hmi_apis::Common_Result::REJECTED;
+  SmartObject& image = (*msg_)[msg_params][cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
   EXPECT_CALL(
       app_mngr_,
-      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
-      .WillOnce(DoAll(SaveArg<0>(&vr_command_result), Return(true)));
-
-  command->on_event(event);
+      ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+      .WillOnce(Return(true));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::REJECTED))
+      .WillOnce(Return(mobile_apis::Result::REJECTED));
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::REJECTED), _));
+  Event event(hmi_apis::FunctionID::UI_AddCommand);
+  event.set_smart_object(*msg_);
+  request_ptr->on_event(event);
+}
 
-  ResultCommandExpectations(vr_command_result, "VR is not supported by system");
+TEST_F(AddCommandRequestTest,
+       OnEvent_HmiResponseCodeIsWarnings_ExpectCommandUpdated) {
+  CreateBasicParamsVRRequest();
+  CreateBasicParamsUIRequest();
+  SmartObject& params = (*msg_)[strings::params];
+  params[hmi_response::code] = hmi_apis::Common_Result::WARNINGS;
+  SmartObject& image = (*msg_)[msg_params][cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  {
+    InSequence dummy;
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+        .WillOnce(Return(true));
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+        .WillOnce(Return(true));
+  }
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::WARNINGS), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+  Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
+  event_ui.set_smart_object(*msg_);
+  Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
+  event_vr.set_smart_object(*msg_);
+  EXPECT_CALL(*mock_app_, UpdateHash());
+  request_ptr->on_event(event_ui);
+  request_ptr->on_event(event_vr);
 }
 
-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";
+TEST_F(
+    AddCommandRequestTest,
+    OnEvent_UI_HmiResponseCodeIsGenericError_VR_HmiResponseCodeIsUnsupportedResourse_ExpectCommandRemoved) {
+  CreateBasicParamsVRRequest();
+  CreateBasicParamsUIRequest();
+  SmartObject& params = (*msg_)[strings::params];
+  params[hmi_response::code] = hmi_apis::Common_Result::GENERIC_ERROR;
+  SmartObject& image = (*msg_)[msg_params][cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  {
+    InSequence dummy;
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+        .WillOnce(Return(true));
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+        .WillOnce(Return(true));
+  }
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::GENERIC_ERROR))
+      .WillRepeatedly(Return(mobile_apis::Result::GENERIC_ERROR));
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
 
-  utils::SharedPtr<AddCommandRequest> command =
-      CreateCommand<AddCommandRequest>(msg_vr);
+  Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
+  event_ui.set_smart_object(*msg_);
+  request_ptr->on_event(event_ui);
+
+  Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
+  MessageSharedPtr msg_vr = CreateMessage(SmartType_Map);
+  (*msg_vr)[strings::params][hmi_response::code] =
+      hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  (*msg_vr)[msg_params][cmd_id] = kCmdId;
+  event_vr.set_smart_object(*msg_vr);
+  request_ptr->on_event(event_vr);
+}
+
+TEST_F(
+    AddCommandRequestTest,
+    OnEvent_VR_HmiResponseCodeIsGenericError_UI_HmiResponseCodeIsUnsupportedResourse_ExpectCommandRemoved) {
+  CreateBasicParamsVRRequest();
+  CreateBasicParamsUIRequest();
+  SmartObject& params = (*msg_)[strings::params];
+  params[hmi_response::code] = hmi_apis::Common_Result::GENERIC_ERROR;
+  SmartObject& image = (*msg_)[msg_params][cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  {
+    InSequence dummy;
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+        .WillOnce(Return(true));
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+        .WillOnce(Return(true));
+  }
 
-  ON_CALL(*mock_app_, FindSubMenu(_)).WillByDefault(Return(&(*msg_vr)));
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::GENERIC_ERROR))
+      .WillRepeatedly(Return(mobile_apis::Result::GENERIC_ERROR));
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
 
-  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));
+  Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
+  event_vr.set_smart_object(*msg_);
+  request_ptr->on_event(event_vr);
 
-  MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
-  (*msg)[am::strings::params][am::hmi_response::code] =
+  Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
+  MessageSharedPtr msg_ui = CreateMessage(SmartType_Map);
+  (*msg_ui)[strings::params][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;
+  (*msg_ui)[msg_params][cmd_id] = kCmdId;
+  event_ui.set_smart_object(*msg_ui);
+  request_ptr->on_event(event_ui);
+}
 
-  Event event(hmi_apis::FunctionID::UI_AddCommand);
-  event.set_smart_object(*msg);
+TEST_F(
+    AddCommandRequestTest,
+    OnEvent_UI_VR_HmiResponseCodeIsUnsupportedResourse_UI_NotAvailableInterfaceState_ExpectCommandRemoved) {
+  CreateBasicParamsVRRequest();
+  CreateBasicParamsUIRequest();
+  SmartObject& params = (*msg_)[strings::params];
+  params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  SmartObject& image = (*msg_)[msg_params][cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  {
+    InSequence dummy;
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+        .WillOnce(Return(true));
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+        .WillOnce(Return(true));
+  }
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
 
-  smart_objects::SmartObject* ptr = NULL;
-  ON_CALL(*mock_app_, FindCommand(kCmdId)).WillByDefault(Return(ptr));
-  EXPECT_EQ(NULL, ptr);
+  EXPECT_CALL(mock_hmi_interfaces_,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillRepeatedly(
+          Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
+  EXPECT_CALL(mock_hmi_interfaces_,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
+      .WillRepeatedly(Return(am::HmiInterfaces::STATE_AVAILABLE));
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(
+          MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _));
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
+  Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
+  event_ui.set_smart_object(*msg_);
+  Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
+  event_vr.set_smart_object(*msg_);
+  request_ptr->on_event(event_ui);
+  request_ptr->on_event(event_vr);
+}
 
-  ON_CALL(mock_message_helper_, HMIToMobileResult(_))
-      .WillByDefault(Return(mobile_apis::Result::SUCCESS));
+TEST_F(
+    AddCommandRequestTest,
+    OnEvent_UI_VR_HmiResponseCodeIsUnsupportedResourse_VR_NotAvailableInterfaceState_ExpectCommandRemoved) {
+  CreateBasicParamsVRRequest();
+  CreateBasicParamsUIRequest();
+  SmartObject& params = (*msg_)[strings::params];
+  params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  SmartObject& image = (*msg_)[msg_params][cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  {
+    InSequence dummy;
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+        .WillOnce(Return(true));
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+        .WillOnce(Return(true));
+  }
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
 
-  ON_CALL(mock_message_helper_, VerifyImage(_, _, _))
-      .WillByDefault(Return(mobile_apis::Result::SUCCESS));
-  EXPECT_CALL(*mock_app_,
-              AddCommand(kCmdId, (*msg_vr)[am::strings::msg_params]));
+  EXPECT_CALL(mock_hmi_interfaces_,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillRepeatedly(Return(am::HmiInterfaces::STATE_AVAILABLE));
+  EXPECT_CALL(mock_hmi_interfaces_,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
+      .WillRepeatedly(
+          Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(
+          MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _));
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
+  Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
+  event_ui.set_smart_object(*msg_);
+  Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
+  event_vr.set_smart_object(*msg_);
+  request_ptr->on_event(event_ui);
+  request_ptr->on_event(event_vr);
+}
 
+TEST_F(
+    AddCommandRequestTest,
+    OnEvent_UI_HmiResponseCodeIsUnsupportedResource_NotAvailableInterfaceState_ExpectCommandRemoved) {
+  CreateBasicParamsUIRequest();
+  SmartObject& params = (*msg_)[strings::params];
+  params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  SmartObject& image = (*msg_)[msg_params][cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
   am::CommandsMap commands_map;
-  ON_CALL(*mock_app_, commands_map())
-      .WillByDefault(
-          Return(DataAccessor<am::CommandsMap>(commands_map, lock_)));
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  EXPECT_CALL(
+      app_mngr_,
+      ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+      .WillOnce(Return(true));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+  EXPECT_CALL(mock_hmi_interfaces_,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillRepeatedly(
+          Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
+  EXPECT_CALL(mock_hmi_interfaces_,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
+      .WillRepeatedly(
+          Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(
+          MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _));
+  Event event(hmi_apis::FunctionID::UI_AddCommand);
+  event.set_smart_object(*msg_);
+  request_ptr->on_event(event);
+}
 
-  EXPECT_CALL(*mock_app_, UpdateHash());
+TEST_F(
+    AddCommandRequestTest,
+    OnEvent_VR_HmiResponseCodeIsUnsupportedResource_NotAvailableInterfaceState_ExpectCommandRemoved) {
+  CreateBasicParamsVRRequest();
+  SmartObject& params = (*msg_)[strings::params];
+  params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  EXPECT_CALL(
+      app_mngr_,
+      ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+      .WillOnce(Return(true));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+  EXPECT_CALL(mock_hmi_interfaces_,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+      .WillRepeatedly(
+          Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
+  EXPECT_CALL(mock_hmi_interfaces_,
+              GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
+      .WillRepeatedly(
+          Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(
+          MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _));
+  Event event(hmi_apis::FunctionID::VR_AddCommand);
+  event.set_smart_object(*msg_);
+  request_ptr->on_event(event);
+}
 
-  MessageSharedPtr msg_ui(CreateMessage(smart_objects::SmartType_Map));
-  (*msg_ui)[am::strings::params][am::hmi_response::code] =
-      hmi_apis::Common_Result::SUCCESS;
+TEST_F(AddCommandRequestTest,
+       OnEvent_UI_EventWithNotSuccesResponseCode_ExpectVRCommandDelete) {
+  CreateBasicParamsVRRequest();
+  CreateBasicParamsUIRequest();
+  SmartObject& params = (*msg_)[strings::params];
+  params[hmi_response::code] = hmi_apis::Common_Result::SUCCESS;
+  SmartObject& image = (*msg_)[msg_params][cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  {
+    InSequence dummy;
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+        .WillOnce(Return(true));
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+        .WillOnce(Return(true));
+  }
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::GENERIC_ERROR), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
 
+  MessageSharedPtr msg_ui = CreateMessage(SmartType_Map);
+  (*msg_ui)[strings::params][hmi_response::code] =
+      hmi_apis::Common_Result::ABORTED;
+  (*msg_ui)[msg_params][cmd_id] = kCmdId;
+  Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
+  event_ui.set_smart_object(*msg_ui);
   Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
-  event_vr.set_smart_object(*msg_vr);
+  event_vr.set_smart_object(*msg_);
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::ABORTED))
+      .WillOnce(Return(mobile_apis::Result::ABORTED));
+  EXPECT_CALL(
+      app_mngr_,
+      ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_DeleteCommand)))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(2);
+  request_ptr->on_event(event_ui);
+  request_ptr->on_event(event_vr);
+}
 
-  command->Run();
-  command->on_event(event_vr);
-  MessageSharedPtr ui_command_result;
+TEST_F(AddCommandRequestTest,
+       OnEvent_UI_VR_Events_VRErrorPresent_ExpectRemoveCommand) {
+  CreateBasicParamsVRRequest();
+  CreateBasicParamsUIRequest();
+  SmartObject& params = (*msg_)[strings::params];
+  params[hmi_response::code] = hmi_apis::Common_Result::SUCCESS;
+  SmartObject& image = (*msg_)[msg_params][cmd_icon];
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  am::CommandsMap commands_map;
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  {
+    InSequence dummy;
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+        .WillOnce(Return(true));
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+        .WillOnce(Return(true));
+  }
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::GENERIC_ERROR), _));
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::ABORTED))
+      .WillOnce(Return(mobile_apis::Result::ABORTED));
+
+  Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
+  event_ui.set_smart_object(*msg_);
+  request_ptr->on_event(event_ui);
   EXPECT_CALL(
       app_mngr_,
-      ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL))
-      .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
+      ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_DeleteCommand)))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(2);
+  Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
+  MessageSharedPtr msg_vr = CreateMessage(SmartType_Map);
+  (*msg_vr)[strings::params][hmi_response::code] =
+      hmi_apis::Common_Result::ABORTED;
+  (*msg_vr)[msg_params][cmd_id] = kCmdId;
+  event_vr.set_smart_object(*msg_vr);
+  request_ptr->on_event(event_vr);
+}
 
-  command->on_event(event);
+TEST_F(AddCommandRequestTest,
+       OnTimeOut_AppNotExisted_NoAppRemoveCommandCalled) {
+  CreateBasicParamsUIRequest();
+  EXPECT_CALL(app_mngr_, application(kConnectionKey))
+      .WillOnce(Return(ApplicationSharedPtr()));
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(0);
+  SmartObjectSPtr response;
+  EXPECT_CALL(
+      mock_message_helper_,
+      CreateNegativeResponse(_, _, _, mobile_apis::Result::GENERIC_ERROR))
+      .WillOnce(Return(response));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  response, am::commands::Command::CommandOrigin::ORIGIN_SDL));
+  utils::SharedPtr<CommandRequestImpl> base_class_request =
+      static_cast<utils::SharedPtr<CommandRequestImpl> >(
+          CreateCommand<AddCommandRequest>(msg_));
+  base_class_request->onTimeOut();
+}
 
-  ResultCommandExpectations(ui_command_result, "UI is not supported by system");
+TEST_F(AddCommandRequestTest, OnTimeOut_AppRemoveCommandCalled) {
+  CreateBasicParamsVRRequest();
+  CreateBasicParamsUIRequest();
+  SmartObject& msg_params = (*msg_)[strings::msg_params];
+  SmartObject& image = msg_params[cmd_icon];
+  msg_params[menu_params][hmi_request::parent_id] = kSecondParentId;
+  EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
+  SmartObject first_command = SmartObject(SmartType_Map);
+  SmartObject second_command = SmartObject(SmartType_Map);
+  const am::CommandsMap commands_map =
+      CreateCommandsMap(first_command, second_command);
+  EXPECT_CALL(*mock_app_, commands_map())
+      .WillRepeatedly(Return(
+          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+  so_ptr_ = utils::MakeShared<SmartObject>(SmartType_Map);
+  EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
+      .WillOnce(Return(so_ptr_.get()));
+  {
+    InSequence dummy;
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
+        .WillOnce(Return(true));
+    EXPECT_CALL(
+        app_mngr_,
+        ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
+        .WillOnce(Return(true));
+  }
+  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
+  utils::SharedPtr<AddCommandRequest> request_ptr =
+      CreateCommand<AddCommandRequest>(msg_);
+  request_ptr->Run();
+  EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
+  SmartObjectSPtr response;
+  EXPECT_CALL(
+      mock_message_helper_,
+      CreateNegativeResponse(_, _, _, mobile_apis::Result::GENERIC_ERROR))
+      .WillOnce(Return(response));
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  response, am::commands::Command::CommandOrigin::ORIGIN_SDL));
+  utils::SharedPtr<CommandRequestImpl> base_class_request =
+      static_cast<utils::SharedPtr<CommandRequestImpl> >(request_ptr);
+  base_class_request->onTimeOut();
 }
 
 }  // namespace add_command_test
diff --git a/src/components/application_manager/test/commands/mobile/send_location_request_test.cc b/src/components/application_manager/test/commands/mobile/send_location_request_test.cc
new file mode 100644
index 0000000000..7d197010c7
--- /dev/null
+++ b/src/components/application_manager/test/commands/mobile/send_location_request_test.cc
@@ -0,0 +1,399 @@
+/*
+ * 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 "gtest/gtest.h"
+#include "application_manager/commands/mobile/send_location_request.h"
+#include "application_manager/mock_hmi_capabilities.h"
+#include "application_manager/mock_message_helper.h"
+#include "utils/shared_ptr.h"
+#include "commands/command_request_test.h"
+
+namespace test {
+namespace components {
+namespace commands_test {
+namespace mobile_commands_test {
+namespace send_location_request {
+
+using application_manager::commands::MessageSharedPtr;
+using application_manager::commands::SendLocationRequest;
+using application_manager::MockMessageHelper;
+using test::components::application_manager_test::MockHMICapabilities;
+using smart_objects::SmartObject;
+using utils::SharedPtr;
+using testing::_;
+using testing::Return;
+using testing::ReturnRef;
+using ::testing::Mock;
+
+namespace strings = application_manager::strings;
+namespace hmi_response = application_manager::hmi_response;
+namespace Common_TextFieldName = hmi_apis::Common_TextFieldName;
+
+namespace {
+const uint32_t kConnectionKey = 1u;
+const uint32_t kFunctionID = 2u;
+const uint32_t kAppID = 3u;
+const double kLongitudeDegrees = 13.4;
+const std::string kLocationDescription = "Location_Description";
+const std::string kNewLine = "\\n";
+const std::string kAddressLine = "Address_Line";
+const std::string kPhoneNumber = "Phone_number";
+const std::string kCorrectAddress = "Correct address";
+const std::string kEmptyAddress = "";
+const std::string kAddressWithWrongSyntax = "Wrong Syntax\\n";
+}  // namespace
+
+class SendLocationRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  class UnwrappedSendLocationRequest : public SendLocationRequest {
+   public:
+    UnwrappedSendLocationRequest(
+        const MessageSharedPtr& message,
+        application_manager::ApplicationManager& application_manager)
+        : SendLocationRequest(message, application_manager) {}
+
+    ::application_manager::CommandParametersPermissions&
+    get_parameters_permissions() {
+      return parameters_permissions_;
+    }
+  };
+
+  typedef SharedPtr<UnwrappedSendLocationRequest> CommandSPrt;
+
+  SendLocationRequestTest()
+      : mock_message_helper_(*MockMessageHelper::message_helper_mock()) {
+    mock_app_ = CreateMockApp();
+    disp_cap_ = utils::MakeShared<SmartObject>(smart_objects::SmartType_Map);
+    message_ = CreateMessage();
+    command_ = CreateCommand<UnwrappedSendLocationRequest>(message_);
+  }
+
+  void TearDown() OVERRIDE {
+    Mock::VerifyAndClearExpectations(&mock_message_helper_);
+  }
+
+  void InitialSetup(MessageSharedPtr message_) {
+    (*message_)[strings::params][strings::connection_key] = kConnectionKey;
+    (*message_)[strings::params][strings::function_id] = kFunctionID;
+    (*message_)[strings::msg_params] =
+        SmartObject(smart_objects::SmartType_Map);
+    (*message_)[strings::msg_params][strings::address] = kCorrectAddress;
+    EXPECT_CALL(app_mngr_, application(kConnectionKey))
+        .WillOnce(Return(mock_app_));
+
+    AllowMandatoryFields();
+  }
+
+  void HMICapabilitiesSetupHelper() {
+    EXPECT_CALL(app_mngr_, hmi_capabilities())
+        .WillOnce(ReturnRef(mock_hmi_capabilities_));
+    EXPECT_CALL(mock_hmi_capabilities_, is_ui_cooperating())
+        .WillOnce(Return(true));
+  }
+
+  void HMICapabilitiesSetupWithArguments(
+      Common_TextFieldName::eType field_name) {
+    HMICapabilitiesSetupHelper();
+    (*disp_cap_)[hmi_response::text_fields] =
+        SmartObject(smart_objects::SmartType_Array);
+    (*disp_cap_)[hmi_response::text_fields][0] =
+        SmartObject(smart_objects::SmartType_Map);
+    (*disp_cap_)[hmi_response::text_fields][0][strings::name] = field_name;
+    EXPECT_CALL(mock_hmi_capabilities_, display_capabilities())
+        .Times(2)
+        .WillRepeatedly(Return(disp_cap_.get()));
+  }
+
+  void FinishSetup() {
+    EXPECT_CALL(*mock_app_, hmi_app_id()).WillOnce(Return(kAppID));
+    EXPECT_CALL(app_mngr_,
+                ManageHMICommand(HMIResultCodeIs(
+                    hmi_apis::FunctionID::Navigation_SendLocation)));
+  }
+
+  void FinishSetupCancelled(mobile_apis::Result::eType result) {
+    EXPECT_CALL(*mock_app_, hmi_app_id()).Times(0);
+    EXPECT_CALL(app_mngr_, ManageHMICommand(_)).Times(0);
+    EXPECT_CALL(app_mngr_, ManageMobileCommand(MobileResultCodeIs(result), _));
+  }
+
+  void AllowMandatoryFields() {
+    application_manager::CommandParametersPermissions& permissions =
+        command_->get_parameters_permissions();
+    permissions.allowed_params.push_back(strings::longitude_degrees);
+    permissions.allowed_params.push_back(strings::latitude_degrees);
+  }
+
+  MockAppPtr mock_app_;
+  MockHMICapabilities mock_hmi_capabilities_;
+  MockMessageHelper& mock_message_helper_;
+  SharedPtr<SmartObject> disp_cap_;
+  MessageSharedPtr message_;
+  CommandSPrt command_;
+};
+
+TEST_F(SendLocationRequestTest, Run_InvalidApp_Success) {
+  (*message_)[strings::params][strings::connection_key] = kConnectionKey;
+  EXPECT_CALL(app_mngr_, application(kConnectionKey))
+      .WillOnce(Return(MockAppPtr()));
+  FinishSetupCancelled(mobile_apis::Result::APPLICATION_NOT_REGISTERED);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_DeliveryMode_Success) {
+  InitialSetup(message_);
+  SmartObject msg_params = (*message_)[strings::msg_params];
+  msg_params[strings::delivery_mode] = SmartObject();
+  (*message_)[strings::msg_params] = msg_params;
+  msg_params.erase(strings::delivery_mode);
+  FinishSetup();
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_LocationNameIsAllowed_Success) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::location_name] = "Location_Name";
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::locationName);
+  FinishSetup();
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_LocationNameIsNotAllowed_Cancelled) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::location_name] = "Location_Name";
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::INVALID_ENUM);
+  FinishSetupCancelled(mobile_apis::Result::UNSUPPORTED_RESOURCE);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_LocationNameWrongSyntax_Cancelled) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::location_name] = "Location_Name\\n";
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::locationName);
+  FinishSetupCancelled(mobile_apis::Result::INVALID_DATA);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_LocationDescriptionIsAllowed_Success) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::location_description] =
+      kLocationDescription;
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::locationDescription);
+  FinishSetup();
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_LocationDescriptionIsNotAllowed_Cancelled) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::location_description] =
+      kLocationDescription;
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::INVALID_ENUM);
+  FinishSetupCancelled(mobile_apis::Result::UNSUPPORTED_RESOURCE);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_LocationDescriptionWrongSyntax_Cancelled) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::location_description] =
+      kLocationDescription + kNewLine;
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::locationDescription);
+  FinishSetupCancelled(mobile_apis::Result::INVALID_DATA);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_AddressLinesAreAllowed_Success) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::address_lines] =
+      SmartObject(smart_objects::SmartType_Array);
+  (*message_)[strings::msg_params][strings::address_lines][0] = kAddressLine;
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::addressLines);
+  FinishSetup();
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_AddressLinesAreNotAllowed_Cancelled) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::address_lines] =
+      SmartObject(smart_objects::SmartType_Array);
+  (*message_)[strings::msg_params][strings::address_lines][0] = kAddressLine;
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::INVALID_ENUM);
+  FinishSetupCancelled(mobile_apis::Result::UNSUPPORTED_RESOURCE);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_AddressLinesWrongSyntax_Cancelled) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::address_lines] =
+      SmartObject(smart_objects::SmartType_Array);
+  (*message_)[strings::msg_params][strings::address_lines][0] =
+      kAddressLine + kNewLine;
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::addressLines);
+  FinishSetupCancelled(mobile_apis::Result::INVALID_DATA);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_PhoneNumberIsAllowed_Success) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::phone_number] = kPhoneNumber;
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::phoneNumber);
+  FinishSetup();
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_PhoneNumberIsNotAllowed_Cancelled) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::phone_number] = kPhoneNumber;
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::INVALID_ENUM);
+  FinishSetupCancelled(mobile_apis::Result::UNSUPPORTED_RESOURCE);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_PhoneNumberWrongSyntax_Cancelled) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::phone_number] =
+      kPhoneNumber + kNewLine;
+  HMICapabilitiesSetupWithArguments(Common_TextFieldName::phoneNumber);
+  FinishSetupCancelled(mobile_apis::Result::INVALID_DATA);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_AddressesContainWrongSyntax_Cancelled) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::address] =
+      SmartObject(smart_objects::SmartType_Array);
+  (*message_)[strings::msg_params][strings::address]["Address 1"] =
+      kCorrectAddress;
+  (*message_)[strings::msg_params][strings::address]["Address 2"] =
+      kAddressWithWrongSyntax;
+  FinishSetupCancelled(mobile_apis::Result::INVALID_DATA);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_LocationImageValid_Success) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::location_image] =
+      SmartObject(smart_objects::SmartType_Map);
+  (*message_)[strings::msg_params][strings::location_image][strings::value] =
+      "1";
+  EXPECT_CALL(
+      mock_message_helper_,
+      VerifyImage(
+          (*message_)[strings::msg_params][strings::location_image], _, _))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  FinishSetup();
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_LocationImageInvalid_Cancelled) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::location_image] =
+      SmartObject(smart_objects::SmartType_Map);
+  (*message_)[strings::msg_params][strings::location_image][strings::value] =
+      "1";
+  EXPECT_CALL(
+      mock_message_helper_,
+      VerifyImage(
+          (*message_)[strings::msg_params][strings::location_image], _, _))
+      .WillOnce(Return(mobile_apis::Result::ABORTED));
+  FinishSetupCancelled(mobile_apis::Result::ABORTED);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, Run_HMIUINotCoop_Cancelled) {
+  InitialSetup(message_);
+  (*message_)[strings::msg_params][strings::phone_number] = kPhoneNumber;
+  (*disp_cap_)[hmi_response::text_fields] =
+      SmartObject(smart_objects::SmartType_Array);
+  (*disp_cap_)[hmi_response::text_fields][0] =
+      SmartObject(smart_objects::SmartType_Map);
+  (*disp_cap_)[hmi_response::text_fields][0][strings::name] =
+      Common_TextFieldName::phoneNumber;
+  EXPECT_CALL(app_mngr_, hmi_capabilities())
+      .WillOnce(ReturnRef(mock_hmi_capabilities_));
+  EXPECT_CALL(mock_hmi_capabilities_, is_ui_cooperating())
+      .WillOnce(Return(false));
+  FinishSetupCancelled(mobile_apis::Result::UNSUPPORTED_RESOURCE);
+  command_->Run();
+}
+
+TEST_F(SendLocationRequestTest, OnEvent_Success) {
+  mobile_apis::Result::eType response_code = mobile_apis::Result::SUCCESS;
+  (*message_)[strings::params][hmi_response::code] = response_code;
+  Event event(hmi_apis::FunctionID::Navigation_SendLocation);
+  event.set_smart_object(*message_);
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::SUCCESS))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  command_->on_event(event);
+}
+
+TEST_F(SendLocationRequestTest, OnEvent_Cancelled) {
+  (*message_)[strings::params][hmi_response::code] =
+      mobile_apis::Result::SUCCESS;
+  Event event(hmi_apis::FunctionID::Navigation_OnWayPointChange);
+  event.set_smart_object(*message_);
+  EXPECT_CALL(
+      app_mngr_,
+      ManageMobileCommand(MobileResultCodeIs(mobile_apis::Result::SUCCESS), _))
+      .Times(0);
+  command_->on_event(event);
+}
+
+TEST_F(SendLocationRequestTest, Run_MandatoryParamsDisallowed_InvalidData) {
+  (*message_)[strings::params][strings::connection_key] = kConnectionKey;
+  (*message_)[strings::params][strings::function_id] = kFunctionID;
+  (*message_)[strings::msg_params] = SmartObject(smart_objects::SmartType_Map);
+  (*message_)[strings::msg_params][strings::address] = kCorrectAddress;
+  (*message_)[strings::msg_params][strings::longitude_degrees] =
+      kLongitudeDegrees;
+  EXPECT_CALL(app_mngr_, application(kConnectionKey))
+      .WillOnce(Return(mock_app_));
+  application_manager::CommandParametersPermissions& permissions =
+      command_->get_parameters_permissions();
+  // 1st one allowed
+  permissions.allowed_params.push_back(strings::longitude_degrees);
+  // 2nd one disallowed
+  permissions.disallowed_params.push_back(strings::latitude_degrees);
+  EXPECT_CALL(app_mngr_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
+  command_->Run();
+}
+
+}  // namespace send_location_request
+}  // namespace mobile_commands_test
+}  // namespace commands_test
+}  // namespace components
+}  // namespace test