1 files changed, 668 insertions, 0 deletions
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/resource_allocation_manager_impl_test.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/resource_allocation_manager_impl_test.cc
new file mode 100644
index 0000000000..86c58b9d46
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/resource_allocation_manager_impl_test.cc
@@ -0,0 +1,668 @@
+/*
+ * Copyright (c) 2018, 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 <algorithm>
+#include "gtest/gtest.h"
+
+#include "rc_rpc_plugin/resource_allocation_manager_impl.h"
+#include "rc_rpc_plugin/rc_rpc_plugin.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_rpc_service.h"
+#include "application_manager/policies/mock_policy_handler_interface.h"
+#include "interfaces/HMI_API.h"
+#include "interfaces/MOBILE_API.h"
+
+using test::components::application_manager_test::MockApplication;
+using test::components::application_manager_test::MockApplicationManager;
+using test::components::application_manager_test::MockRPCService;
+
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::NiceMock;
+using ::testing::StrictMock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::SaveArg;
+using ::testing::Eq;
+using ::testing::DoAll;
+using ::testing::SetArgPointee;
+using ::application_manager::Message;
+using ::application_manager::MessageType;
+using ::application_manager::ApplicationSharedPtr;
+using ::protocol_handler::MessagePriority;
+
+namespace {
+const bool kDeviceHandle = 1u;
+const std::string kModuleType1 = "CLIMATE";
+const std::string kModuleType2 = "RADIO";
+const int32_t kConnectionKey = 5;
+const int32_t kCorrelationId = 5;
+const uint32_t kAppId1 = 11u;
+const uint32_t kHMIAppId1 = 1u;
+const uint32_t kAppId2 = 22u;
+const std::string policy_app_id_1_ = "policy_id_1";
+const uint32_t kSizeOfModules = 6u;
+}
+
+namespace rc_rpc_plugin_test {
+
+using namespace rc_rpc_plugin;
+
+class RAManagerTest : public ::testing::Test {
+ public:
+  RAManagerTest()
+      : message_(std::make_shared<Message>(MessagePriority::FromServiceType(
+            protocol_handler::ServiceType::kRpc)))
+      , mock_app_1_(std::make_shared<NiceMock<MockApplication> >())
+      , mock_app_2_(std::make_shared<NiceMock<MockApplication> >())
+      , apps_lock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , apps_da_(apps_, apps_lock_ptr_) {
+    ON_CALL(mock_app_mngr_, GetPolicyHandler())
+        .WillByDefault(ReturnRef(mock_policy_handler_));
+    auto plugin_id = rc_rpc_plugin::RCRPCPlugin::kRCPluginID;
+    app_ext_ptr_ = std::make_shared<rc_rpc_plugin::RCAppExtension>(plugin_id);
+    ON_CALL(*mock_app_1_, app_id()).WillByDefault(Return(kAppId1));
+
+    OnRCStatusNotificationExpectations();
+  }
+
+  void CheckResultWithHMILevelAndAccessMode(
+      ResourceAllocationManagerImpl& ra_manager,
+      mobile_apis::HMILevel::eType app_level,
+      const rc_rpc_plugin::AcquireResult::eType expected_result,
+      const hmi_apis::Common_RCAccessMode::eType access_mode);
+
+  void OnRCStatusNotificationExpectations();
+
+ protected:
+  NiceMock<MockApplicationManager> mock_app_mngr_;
+  NiceMock<MockRPCService> mock_rpc_service_;
+  test::components::policy_test::MockPolicyHandlerInterface
+      mock_policy_handler_;
+  application_manager::MessagePtr message_;
+
+  application_manager::AppExtensionPtr app_ext_ptr_;
+  std::shared_ptr<NiceMock<MockApplication> > mock_app_1_;
+  std::shared_ptr<NiceMock<MockApplication> > mock_app_2_;
+  application_manager::ApplicationSet apps_;
+  std::shared_ptr<sync_primitives::Lock> apps_lock_ptr_;
+  DataAccessor<application_manager::ApplicationSet> apps_da_;
+};
+
+void RAManagerTest::CheckResultWithHMILevelAndAccessMode(
+    ResourceAllocationManagerImpl& ra_manager,
+    mobile_apis::HMILevel::eType app_level,
+    const AcquireResult::eType expected_result,
+    const hmi_apis::Common_RCAccessMode::eType access_mode) {
+  // Arrange
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(mock_app_1_));
+  ra_manager.SetAccessMode(access_mode);
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillOnce(Return(mock_app_2_));
+  EXPECT_CALL(*mock_app_2_, hmi_level()).WillOnce(Return(app_level));
+  // Second app tries to get already acquired resource by 1st app
+  EXPECT_EQ(expected_result, ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+void RAManagerTest::OnRCStatusNotificationExpectations() {
+  ON_CALL(mock_app_mngr_, application(kAppId1))
+      .WillByDefault(Return(mock_app_1_));
+  ON_CALL(*mock_app_1_, QueryInterface(rc_rpc_plugin::RCRPCPlugin::kRCPluginID))
+      .WillByDefault(Return(app_ext_ptr_));
+  apps_.insert(mock_app_1_);
+  ON_CALL(mock_app_mngr_, applications()).WillByDefault(Return(apps_da_));
+}
+
+TEST_F(RAManagerTest, AcquireResource_NoAppRegistered_Expect_InUse) {
+  // Arrange
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(ApplicationSharedPtr()));
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  // Act & Assert
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::IN_USE,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+}
+
+TEST_F(RAManagerTest,
+       AcquireResource_AppRegisteredAnyHmiLevelResourceFree_Expect_Allowed) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  // Act & Assert
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+}
+
+TEST_F(
+    RAManagerTest,
+    AcquireResource_AppInAnyHmiLevelWantsToAcquireSameResourceTwice_Expect_Allowed) {
+  // Arrange
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(mock_app_1_));
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(mock_app_1_));
+  // Same app tries to get already acquired resource
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+}
+
+TEST_F(
+    RAManagerTest,
+    AcquireResource_App2_NotInFULLWantsToGetAcquiredResource_Expect_Rejected) {
+  using namespace mobile_apis;
+  using namespace hmi_apis;
+  using namespace rc_rpc_plugin;
+  const HMILevel::eType app_level = HMILevel::eType::HMI_BACKGROUND;
+  const AcquireResult::eType expected_result = AcquireResult::REJECTED;
+  const Common_RCAccessMode::eType access_mode =
+      Common_RCAccessMode::eType::AUTO_ALLOW;
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  CheckResultWithHMILevelAndAccessMode(
+      ra_manager, app_level, expected_result, access_mode);
+}
+
+TEST_F(
+    RAManagerTest,
+    AcquireResource_App2_InFULLWantsToGetAcquiredResource_AUTO_DENY_Expect_InUse) {
+  using namespace mobile_apis;
+  using namespace hmi_apis;
+  using namespace rc_rpc_plugin;
+  const HMILevel::eType app_level = HMILevel::eType::HMI_FULL;
+  const AcquireResult::eType expected_result = AcquireResult::IN_USE;
+  const Common_RCAccessMode::eType access_mode =
+      Common_RCAccessMode::eType::AUTO_DENY;
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  CheckResultWithHMILevelAndAccessMode(
+      ra_manager, app_level, expected_result, access_mode);
+}
+
+TEST_F(
+    RAManagerTest,
+    AcquireResource_App2_InFULLWantsToGetAcquiredResource_AUTO_ALLOW_Expect_Allowed) {
+  using namespace mobile_apis;
+  using namespace hmi_apis;
+  using namespace rc_rpc_plugin;
+  const HMILevel::eType app_level = HMILevel::eType::HMI_FULL;
+  const AcquireResult::eType expected_result = AcquireResult::ALLOWED;
+  const Common_RCAccessMode::eType access_mode =
+      Common_RCAccessMode::eType::AUTO_ALLOW;
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  CheckResultWithHMILevelAndAccessMode(
+      ra_manager, app_level, expected_result, access_mode);
+}
+
+TEST_F(
+    RAManagerTest,
+    AcquireResource_App2_InFULLWantsToGetAcquiredResource_ASK_DRIVER_Expect_AskDriver) {
+  using namespace mobile_apis;
+  using namespace hmi_apis;
+  using namespace rc_rpc_plugin;
+  const HMILevel::eType app_level = HMILevel::eType::HMI_FULL;
+  const AcquireResult::eType expected_result = AcquireResult::ASK_DRIVER;
+  const Common_RCAccessMode::eType access_mode =
+      Common_RCAccessMode::eType::ASK_DRIVER;
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  CheckResultWithHMILevelAndAccessMode(
+      ra_manager, app_level, expected_result, access_mode);
+}
+
+TEST_F(RAManagerTest,
+       AcquireResource_AcquiredModuleIsRejectedForApp2_ExpectApp2Rejected) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_1_));
+  EXPECT_EQ(AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+
+  // Act
+  ra_manager.OnDriverDisallowed(kModuleType1, kAppId2);
+
+  // Assert
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillOnce(Return(mock_app_2_));
+  EXPECT_EQ(AcquireResult::REJECTED,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+TEST_F(RAManagerTest, AppExit_ReleaseResource) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_1_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+
+  // Act
+  ra_manager.OnApplicationEvent(
+      application_manager::plugin_manager::kApplicationExit, mock_app_1_);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillRepeatedly(Return(mock_app_2_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+TEST_F(RAManagerTest, AnotherAppExit_NoReleaseResource) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(mock_app_1_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillRepeatedly(Return(mock_app_2_));
+
+  // Act
+  application_manager::ApplicationSharedPtr app_ptr(mock_app_2_);
+  EXPECT_CALL(*mock_app_2_, app_id()).WillRepeatedly(Return(kAppId2));
+  ra_manager.OnApplicationEvent(
+      application_manager::plugin_manager::kApplicationExit, app_ptr);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillOnce(Return(mock_app_2_));
+  EXPECT_CALL(*mock_app_2_, hmi_level())
+      .WillOnce(Return(mobile_apis::HMILevel::HMI_FULL));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::IN_USE,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+TEST_F(RAManagerTest, AppUnregistered_ReleaseResource) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  RCAppExtensionPtr rc_extention_ptr =
+      std::make_shared<RCAppExtension>(application_manager::AppExtensionUID(
+          rc_rpc_plugin::RCRPCPlugin::kRCPluginID));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+
+  // Act
+  application_manager::ApplicationSharedPtr app_ptr(mock_app_1_);
+  EXPECT_CALL(*mock_app_1_, app_id()).WillRepeatedly(Return(kAppId1));
+
+  ra_manager.OnApplicationEvent(
+      application_manager::plugin_manager::kApplicationUnregistered, app_ptr);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillOnce(Return(mock_app_2_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+TEST_F(RAManagerTest, AnotherAppUnregistered_NoReleaseResource) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(mock_app_1_));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_2_));
+
+  // Act
+  application_manager::ApplicationSharedPtr app_ptr(mock_app_2_);
+  EXPECT_CALL(*mock_app_2_, app_id()).WillRepeatedly(Return(kAppId2));
+
+  ra_manager.OnApplicationEvent(
+      application_manager::plugin_manager::kApplicationUnregistered, app_ptr);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillOnce(Return(mock_app_2_));
+  EXPECT_CALL(*mock_app_2_, hmi_level())
+      .WillOnce(Return(mobile_apis::HMILevel::HMI_FULL));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::IN_USE,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+TEST_F(RAManagerTest, AppsDisallowed_ReleaseAllResources) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_1_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType2, kAppId1));
+
+  application_manager::ApplicationSet apps;
+  apps.insert(mock_app_1_);
+  std::shared_ptr<sync_primitives::Lock> apps_lock =
+      std::make_shared<sync_primitives::Lock>();
+  DataAccessor<application_manager::ApplicationSet> apps_da(apps, apps_lock);
+
+  EXPECT_CALL(mock_app_mngr_, applications()).WillRepeatedly(Return(apps_da));
+
+  RCAppExtensionPtr rc_extention_ptr =
+      std::make_shared<RCAppExtension>(application_manager::AppExtensionUID(
+          rc_rpc_plugin::RCRPCPlugin::kRCPluginID));
+
+  EXPECT_CALL(*mock_app_1_, QueryInterface(RCRPCPlugin::kRCPluginID))
+      .WillRepeatedly(Return(rc_extention_ptr));
+
+  // Act
+  ra_manager.OnPolicyEvent(
+      application_manager::plugin_manager::PolicyEvent::kApplicationsDisabled);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillRepeatedly(Return(mock_app_2_));
+  EXPECT_CALL(*mock_app_2_, hmi_level())
+      .WillRepeatedly(Return(mobile_apis::HMILevel::HMI_FULL));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType2, kAppId2));
+  Mock::VerifyAndClearExpectations(&mock_app_mngr_);
+}
+
+TEST_F(RAManagerTest, AppGotRevokedModulesWithPTU_ReleaseRevokedResource) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_1_));
+
+  RCAppExtensionPtr rc_extention_ptr =
+      std::make_shared<rc_rpc_plugin::RCAppExtension>(
+          application_manager::AppExtensionUID(
+              rc_rpc_plugin::RCRPCPlugin::kRCPluginID));
+
+  EXPECT_CALL(*mock_app_1_, QueryInterface(RCRPCPlugin::kRCPluginID))
+      .WillRepeatedly(Return(rc_extention_ptr));
+
+  ON_CALL(*mock_app_1_, is_remote_control_supported())
+      .WillByDefault(Return(true));
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_1_));
+
+  EXPECT_CALL(*mock_app_1_, app_id()).WillRepeatedly(Return(kAppId1));
+
+  EXPECT_CALL(*mock_app_1_, policy_app_id())
+      .WillRepeatedly(Return(policy_app_id_1_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType2, kAppId1));
+
+  application_manager::ApplicationSet apps;
+  apps.insert(mock_app_1_);
+  std::shared_ptr<sync_primitives::Lock> apps_lock =
+      std::make_shared<sync_primitives::Lock>();
+  DataAccessor<application_manager::ApplicationSet> apps_da(apps, apps_lock);
+
+  EXPECT_CALL(mock_app_mngr_, applications()).WillRepeatedly(Return(apps_da));
+
+  Resources allowed_modules;
+  allowed_modules.push_back(kModuleType1);
+
+  EXPECT_CALL(mock_policy_handler_, GetModuleTypes(policy_app_id_1_, _))
+      .WillOnce(DoAll(SetArgPointee<1>(allowed_modules), Return(true)));
+
+  // Act
+  ra_manager.OnPolicyEvent(application_manager::plugin_manager::PolicyEvent::
+                               kApplicationPolicyUpdated);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillRepeatedly(Return(mock_app_2_));
+  EXPECT_CALL(*mock_app_2_, hmi_level())
+      .WillRepeatedly(Return(mobile_apis::HMILevel::HMI_FULL));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::IN_USE,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType2, kAppId2));
+  Mock::VerifyAndClearExpectations(&mock_app_mngr_);
+}
+
+TEST_F(RAManagerTest, GetAccessMode_ExpectedSameAsHadSet) {
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::AUTO_DENY);
+  EXPECT_EQ(hmi_apis::Common_RCAccessMode::AUTO_DENY,
+            ra_manager.GetAccessMode());
+
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::ASK_DRIVER);
+  EXPECT_EQ(hmi_apis::Common_RCAccessMode::ASK_DRIVER,
+            ra_manager.GetAccessMode());
+
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::AUTO_ALLOW);
+  EXPECT_EQ(hmi_apis::Common_RCAccessMode::AUTO_ALLOW,
+            ra_manager.GetAccessMode());
+
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::INVALID_ENUM);
+  EXPECT_EQ(hmi_apis::Common_RCAccessMode::INVALID_ENUM,
+            ra_manager.GetAccessMode());
+}
+
+TEST_F(RAManagerTest, OnRCStatus_AppRegistation_RC_allowed) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ON_CALL((*mock_app_1_), is_remote_control_supported())
+      .WillByDefault(Return(true));
+  ON_CALL((*mock_app_1_), hmi_app_id()).WillByDefault(Return(kHMIAppId1));
+
+  application_manager::commands::MessageSharedPtr message_to_mob;
+  EXPECT_CALL(mock_rpc_service_, SendMessageToMobile(_, false))
+      .WillOnce(SaveArg<0>(&message_to_mob));
+  application_manager::commands::MessageSharedPtr message_to_hmi;
+  EXPECT_CALL(mock_rpc_service_, SendMessageToHMI(_)).Times(0);
+
+  // Act
+  ra_manager.SendOnRCStatusNotifications(NotificationTrigger::APP_REGISTRATION,
+                                         mock_app_1_);
+
+  auto msg_to_mob_params =
+      (*message_to_mob)[application_manager::strings::msg_params];
+
+  // Assert
+  EXPECT_EQ(msg_to_mob_params[message_params::kAllowed].asBool(), true);
+  EXPECT_EQ(
+      msg_to_mob_params[message_params::kAllocatedModules].asArray()->size(),
+      0u);
+  EXPECT_EQ(msg_to_mob_params[message_params::kFreeModules].asArray()->size(),
+            kSizeOfModules);
+}
+
+TEST_F(RAManagerTest, OnRCStatus_AppRegistation_RC_disallowed) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.set_rc_enabled(false);
+
+  ON_CALL((*mock_app_1_), is_remote_control_supported())
+      .WillByDefault(Return(true));
+
+  application_manager::commands::MessageSharedPtr message_to_mob;
+  EXPECT_CALL(mock_rpc_service_, SendMessageToMobile(_, false))
+      .WillOnce(SaveArg<0>(&message_to_mob));
+  EXPECT_CALL(mock_rpc_service_, SendMessageToHMI(_)).Times(0);
+
+  // Act
+  ra_manager.SendOnRCStatusNotifications(NotificationTrigger::APP_REGISTRATION,
+                                         mock_app_1_);
+
+  auto msg_to_mob_params =
+      (*message_to_mob)[application_manager::strings::msg_params];
+  // Assert
+  EXPECT_EQ(msg_to_mob_params[message_params::kAllowed].asBool(), false);
+  EXPECT_EQ(
+      msg_to_mob_params[message_params::kAllocatedModules].asArray()->size(),
+      0u);
+  EXPECT_EQ(msg_to_mob_params[message_params::kFreeModules].asArray()->size(),
+            0u);
+}
+
+TEST_F(RAManagerTest, OnRCStatus_RCStateChanging_RC_disabling) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ON_CALL((*mock_app_1_), is_remote_control_supported())
+      .WillByDefault(Return(true));
+  ON_CALL((*mock_app_1_), hmi_app_id()).WillByDefault(Return(kHMIAppId1));
+
+  application_manager::commands::MessageSharedPtr message_to_mob;
+  EXPECT_CALL(mock_rpc_service_, SendMessageToMobile(_, false))
+      .WillOnce(SaveArg<0>(&message_to_mob));
+  application_manager::commands::MessageSharedPtr message_to_hmi;
+  EXPECT_CALL(mock_rpc_service_, SendMessageToHMI(_))
+      .WillOnce(SaveArg<0>(&message_to_hmi));
+
+  // Act
+  ra_manager.set_rc_enabled(false);
+
+  auto msg_to_mob_params =
+      (*message_to_mob)[application_manager::strings::msg_params];
+  auto msg_to_hmi_params =
+      (*message_to_hmi)[application_manager::strings::msg_params];
+  // Assert
+  EXPECT_EQ(msg_to_mob_params[message_params::kAllowed].asBool(), false);
+  EXPECT_EQ(
+      msg_to_mob_params[message_params::kAllocatedModules].asArray()->size(),
+      0u);
+  EXPECT_EQ(msg_to_mob_params[message_params::kFreeModules].asArray()->size(),
+            0u);
+  EXPECT_EQ(
+      msg_to_hmi_params[message_params::kAllocatedModules].asArray()->size(),
+      0u);
+  EXPECT_EQ(msg_to_hmi_params[message_params::kFreeModules].asArray()->size(),
+            kSizeOfModules);
+  EXPECT_EQ(msg_to_hmi_params[application_manager::strings::app_id].asInt(),
+            kHMIAppId1);
+}
+
+TEST_F(RAManagerTest, OnRCStatus_RCStateChanging_RC_enabling) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ON_CALL((*mock_app_1_), is_remote_control_supported())
+      .WillByDefault(Return(true));
+  ON_CALL((*mock_app_1_), hmi_app_id()).WillByDefault(Return(kHMIAppId1));
+
+  application_manager::commands::MessageSharedPtr message_to_mob;
+  EXPECT_CALL(mock_rpc_service_, SendMessageToMobile(_, false))
+      .WillOnce(SaveArg<0>(&message_to_mob));
+  application_manager::commands::MessageSharedPtr message_to_hmi;
+  EXPECT_CALL(mock_rpc_service_, SendMessageToHMI(_))
+      .WillOnce(SaveArg<0>(&message_to_hmi));
+
+  // Act
+  ra_manager.set_rc_enabled(true);
+
+  auto msg_to_mob_params =
+      (*message_to_mob)[application_manager::strings::msg_params];
+  auto msg_to_hmi_params =
+      (*message_to_hmi)[application_manager::strings::msg_params];
+  // Assert
+  EXPECT_EQ(msg_to_mob_params[message_params::kAllowed].asBool(), true);
+  EXPECT_EQ(
+      msg_to_mob_params[message_params::kAllocatedModules].asArray()->size(),
+      0u);
+  EXPECT_EQ(msg_to_mob_params[message_params::kFreeModules].asArray()->size(),
+            kSizeOfModules);
+  EXPECT_EQ(
+      msg_to_hmi_params[message_params::kAllocatedModules].asArray()->size(),
+      0u);
+  EXPECT_EQ(msg_to_hmi_params[message_params::kFreeModules].asArray()->size(),
+            kSizeOfModules);
+  EXPECT_EQ(msg_to_hmi_params[application_manager::strings::app_id].asInt(),
+            kHMIAppId1);
+}
+
+TEST_F(RAManagerTest, OnRCStatus_ModuleAllocation) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+
+  ON_CALL((*mock_app_1_), is_remote_control_supported())
+      .WillByDefault(Return(true));
+  ON_CALL((*mock_app_1_), hmi_app_id()).WillByDefault(Return(kHMIAppId1));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+
+  application_manager::commands::MessageSharedPtr message_to_mob;
+  EXPECT_CALL(mock_rpc_service_, SendMessageToMobile(_, false))
+      .WillOnce(SaveArg<0>(&message_to_mob));
+
+  application_manager::commands::MessageSharedPtr message_to_hmi;
+  EXPECT_CALL(mock_rpc_service_, SendMessageToHMI(_))
+      .WillOnce(SaveArg<0>(&message_to_hmi));
+
+  // Act
+  ra_manager.SendOnRCStatusNotifications(
+      NotificationTrigger::MODULE_ALLOCATION,
+      std::shared_ptr<application_manager::Application>());
+
+  auto msg_to_mob_params =
+      (*message_to_mob)[application_manager::strings::msg_params];
+  auto msg_to_hmi_params =
+      (*message_to_hmi)[application_manager::strings::msg_params];
+  // Assert
+  EXPECT_EQ(msg_to_mob_params[message_params::kAllowed].asBool(), true);
+  EXPECT_EQ(
+      msg_to_mob_params[message_params::kAllocatedModules].asArray()->size(),
+      1u);
+  EXPECT_EQ(msg_to_mob_params[message_params::kFreeModules].asArray()->size(),
+            kSizeOfModules - 1u);
+  EXPECT_EQ(
+      msg_to_hmi_params[message_params::kAllocatedModules].asArray()->size(),
+      1u);
+  EXPECT_EQ(msg_to_hmi_params[message_params::kFreeModules].asArray()->size(),
+            kSizeOfModules - 1u);
+  EXPECT_EQ(msg_to_hmi_params[application_manager::strings::app_id].asInt(),
+            kHMIAppId1);
+}
+
+}  // namespace rc_rpc_plugin