修改格式及静态告警问题2

Signed-off-by: liqiang <liqiang121@huawei.com>
Change-Id: I6199d4eca9ead8dc93a656aa331a70d961a27f61

test/mock/common/src/mock_native_token.cpp

@@ -21,7 +21,7 @@ namespace AppExecFwk {
 void MockNativeToken::SetNativeToken()
 {
     uint64_t tokenId;
-    const char **perms = new const char *[5];
+    const char** perms = new const char* [5];
     perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
     perms[1] = "ohos.permission.INTERACT_ACROSS_LOCAL_ACCOUNTS";
     perms[2] = "ohos.permission.UPDATE_CONFIGURATION";

test/mock/frameworks_kits_ability_ability_runtime_test/AMS/mock_ability_manager_client.cpp

@@ -47,7 +47,7 @@ AbilityManagerClient::~AbilityManagerClient()
 {}
 
 ErrCode AbilityManagerClient::AttachAbilityThread(
-    const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
+    const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token)
 {
     HILOG_INFO("AbilityManagerClient::AttachAbilityThread start");
     ErrCode err = Connect();
@@ -59,7 +59,7 @@ ErrCode AbilityManagerClient::AttachAbilityThread(
     return abms->AttachAbilityThread(scheduler, token);
 }
 
-ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject> &token, int state, const PacMap &saveData)
+ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject>& token, int state, const PacMap& saveData)
 {
     if (g_remoteObject == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -69,7 +69,7 @@ ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject> &t
 }
 
 ErrCode AbilityManagerClient::ScheduleConnectAbilityDone(
-    const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
+    const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject)
 {
     if (g_remoteObject == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -78,7 +78,7 @@ ErrCode AbilityManagerClient::ScheduleConnectAbilityDone(
     return abms->ScheduleConnectAbilityDone(token, remoteObject);
 }
 
-ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token)
 {
     if (g_remoteObject == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -87,7 +87,7 @@ ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteOb
     return abms->ScheduleDisconnectAbilityDone(token);
 }
 
-ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token)
 {
     if (g_remoteObject == nullptr) {
         HILOG_ERROR("%{private}s:ability service not command", __func__);
@@ -97,7 +97,7 @@ ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObjec
     return abms->ScheduleCommandAbilityDone(token);
 }
 
-ErrCode AbilityManagerClient::StartAbility(const Want &want, int32_t userId, int requestCode)
+ErrCode AbilityManagerClient::StartAbility(const Want& want, int32_t userId, int requestCode)
 {
     if (g_remoteObject == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -107,7 +107,7 @@ ErrCode AbilityManagerClient::StartAbility(const Want &want, int32_t userId, int
 }
 
 ErrCode AbilityManagerClient::StartAbility(
-    const Want &want, const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode)
+    const Want& want, const sptr<IRemoteObject>& callerToken, int32_t userId, int requestCode)
 {
     if (g_remoteObject == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -117,7 +117,7 @@ ErrCode AbilityManagerClient::StartAbility(
 }
 
 ErrCode AbilityManagerClient::StartAbilityByCall(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken)
 {
     HILOG_INFO("AbilityManagerClient::StartAbilityByCall start");
     if (g_remoteObject == nullptr) {
@@ -131,12 +131,12 @@ ErrCode AbilityManagerClient::StartAbilityByCall(
 }
 
 ErrCode AbilityManagerClient::ReleaseCall(
-    const sptr<IAbilityConnection> &connect, const AppExecFwk::ElementName &element)
+    const sptr<IAbilityConnection>& connect, const AppExecFwk::ElementName& element)
 {
     HILOG_INFO("AbilityManagerClient::ReleaseCall start");
     if (g_remoteObject == nullptr) {
         HILOG_INFO("AbilityManagerClient::ReleaseCall fail because remoteObject is null");
-                g_remoteObject =
+        g_remoteObject =
             OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
     }
     sptr<IAbilityManager> abms = iface_cast<IAbilityManager>(g_remoteObject);
@@ -145,7 +145,7 @@ ErrCode AbilityManagerClient::ReleaseCall(
 }
 
 ErrCode AbilityManagerClient::TerminateAbility(
-    const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+    const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     HILOG_INFO("AbilityManagerClient::TerminateAbility start");
     if (g_remoteObject == nullptr) {
@@ -157,7 +157,7 @@ ErrCode AbilityManagerClient::TerminateAbility(
     return abms->TerminateAbility(token, resultCode, resultWant);
 }
 
-ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &callerToken, int requestCode)
+ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject>& callerToken, int requestCode)
 {
     if (g_remoteObject == nullptr) {
         HILOG_ERROR("%{private}s:ability service not connect", __func__);
@@ -168,7 +168,7 @@ ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &caller
 }
 
 ErrCode AbilityManagerClient::ConnectAbility(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken, int32_t userId)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken, int32_t userId)
 {
     if (g_remoteObject == nullptr) {
         g_remoteObject =
@@ -178,7 +178,7 @@ ErrCode AbilityManagerClient::ConnectAbility(
     return abms->ConnectAbility(want, connect, callerToken, userId);
 }
 
-ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection> &connect)
+ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection>& connect)
 {
     if (g_remoteObject == nullptr) {
         g_remoteObject =
@@ -188,7 +188,7 @@ ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection> &
     return abms->DisconnectAbility(connect);
 }
 
-ErrCode AbilityManagerClient::DumpState(const std::string &args, std::vector<std::string> &state)
+ErrCode AbilityManagerClient::DumpState(const std::string& args, std::vector<std::string>& state)
 {
     if (g_remoteObject == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -211,7 +211,7 @@ ErrCode AbilityManagerClient::Connect()
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::StopServiceAbility(const Want &want)
+ErrCode AbilityManagerClient::StopServiceAbility(const Want& want)
 {
     if (g_remoteObject == nullptr) {
         g_remoteObject =
@@ -222,7 +222,7 @@ ErrCode AbilityManagerClient::StopServiceAbility(const Want &want)
 }
 
 sptr<IAbilityScheduler> AbilityManagerClient::AcquireDataAbility(
-    const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken)
+    const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken)
 {
     g_remoteObject =
         OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
@@ -235,7 +235,7 @@ sptr<IAbilityScheduler> AbilityManagerClient::AcquireDataAbility(
 }
 
 ErrCode AbilityManagerClient::ReleaseDataAbility(
-    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken)
+    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken)
 {
     g_remoteObject =
         OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
@@ -247,8 +247,8 @@ ErrCode AbilityManagerClient::ReleaseDataAbility(
     return abms->ReleaseDataAbility(dataAbilityScheduler, callerToken);
 }
 
-ErrCode AbilityManagerClient::ContinueMission(const std::string &srcDeviceId, const std::string &dstDeviceId,
-    int32_t missionId, const sptr<IRemoteObject> &callback, AAFwk::WantParams &wantParams)
+ErrCode AbilityManagerClient::ContinueMission(const std::string& srcDeviceId, const std::string& dstDeviceId,
+    int32_t missionId, const sptr<IRemoteObject>& callback, AAFwk::WantParams& wantParams)
 {
     if (g_remoteObject == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -258,7 +258,7 @@ ErrCode AbilityManagerClient::ContinueMission(const std::string &srcDeviceId, co
     return abms->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
 }
 
-ErrCode AbilityManagerClient::StartContinuation(const Want &want, const sptr<IRemoteObject> &abilityToken,
+ErrCode AbilityManagerClient::StartContinuation(const Want& want, const sptr<IRemoteObject>& abilityToken,
     int32_t status)
 {
     if (g_remoteObject == nullptr) {
@@ -269,7 +269,7 @@ ErrCode AbilityManagerClient::StartContinuation(const Want &want, const sptr<IRe
     return abms->StartContinuation(want, abilityToken, status);
 }
 
-void AbilityManagerClient::NotifyCompleteContinuation(const std::string &deviceId, int32_t sessionId, bool isSuccess)
+void AbilityManagerClient::NotifyCompleteContinuation(const std::string& deviceId, int32_t sessionId, bool isSuccess)
 {
     if (g_remoteObject == nullptr) {
         return;
@@ -309,7 +309,7 @@ ErrCode AbilityManagerClient::StartUser(int accountId)
     return abms->StartUser(accountId);
 }
 
-ErrCode AbilityManagerClient::StopUser(int accountId, const sptr<IStopUserCallback> &callback)
+ErrCode AbilityManagerClient::StopUser(int accountId, const sptr<IStopUserCallback>& callback)
 {
     if (g_remoteObject == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;

test/mock/frameworks_kits_ability_ability_runtime_test/AMS/mock_serviceability_manager_service.cpp

@@ -31,19 +31,19 @@ MockServiceAbilityManagerService::MockServiceAbilityManagerService()
 MockServiceAbilityManagerService::~MockServiceAbilityManagerService()
 {}
 
-int MockServiceAbilityManagerService::StartAbility(const Want &want, int32_t userId, int requestCode)
+int MockServiceAbilityManagerService::StartAbility(const Want& want, int32_t userId, int requestCode)
 {
     return 0;
 }
 
 int MockServiceAbilityManagerService::StartAbility(
-    const Want &want, const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode)
+    const Want& want, const sptr<IRemoteObject>& callerToken, int32_t userId, int requestCode)
 {
     return 0;
 }
 
 int MockServiceAbilityManagerService::StartAbilityByCall(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken)
 {
     GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::StartAbilityByCall begain";
     if (!connect) {
@@ -55,36 +55,36 @@ int MockServiceAbilityManagerService::StartAbilityByCall(
 }
 
 int MockServiceAbilityManagerService::StartAbility(
-    const Want &want, const StartOptions &startOptions,
-    const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode)
+    const Want& want, const StartOptions& startOptions,
+    const sptr<IRemoteObject>& callerToken, int32_t userId, int requestCode)
 {
     return 0;
 }
 
 int MockServiceAbilityManagerService::TerminateAbility(
-    const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+    const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     return 0;
 }
 
 int MockServiceAbilityManagerService::ConnectAbility(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken, int32_t userId)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken, int32_t userId)
 {
     return 0;
 }
 
-int MockServiceAbilityManagerService::DisconnectAbility(const sptr<IAbilityConnection> &connect)
+int MockServiceAbilityManagerService::DisconnectAbility(const sptr<IAbilityConnection>& connect)
 {
     return 0;
 }
 
 int MockServiceAbilityManagerService::AttachAbilityThread(
-    const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
+    const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token)
 {
     return 0;
 }
 
-void MockServiceAbilityManagerService::DumpState(const std::string &args, std::vector<std::string> &info)
+void MockServiceAbilityManagerService::DumpState(const std::string& args, std::vector<std::string>& info)
 {}
 
 void MockServiceAbilityManagerService::DumpSysState(
@@ -92,45 +92,45 @@ void MockServiceAbilityManagerService::DumpSysState(
 {}
 
 int MockServiceAbilityManagerService::AbilityTransitionDone(
-    const sptr<IRemoteObject> &token, int state, const PacMap &saveData)
+    const sptr<IRemoteObject>& token, int state, const PacMap& saveData)
 {
     return 0;
 }
 
 int MockServiceAbilityManagerService::ScheduleConnectAbilityDone(
-    const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
+    const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject)
 {
     return 0;
 }
 
-int MockServiceAbilityManagerService::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token)
+int MockServiceAbilityManagerService::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token)
 {
     return 0;
 }
 
-int MockServiceAbilityManagerService::ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token)
+int MockServiceAbilityManagerService::ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token)
 {
     return 0;
 }
 
-int MockServiceAbilityManagerService::TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId)
+int MockServiceAbilityManagerService::TerminateAbilityResult(const sptr<IRemoteObject>& token, int startId)
 {
     return 0;
 }
 
-int MockServiceAbilityManagerService::TerminateAbilityByCaller(const sptr<IRemoteObject> &callerToken, int requestCode)
+int MockServiceAbilityManagerService::TerminateAbilityByCaller(const sptr<IRemoteObject>& callerToken, int requestCode)
 {
     return 0;
 }
 
-int MockServiceAbilityManagerService::ReleaseCall(const sptr<IAbilityConnection> &connect,
-    const AppExecFwk::ElementName &element)
+int MockServiceAbilityManagerService::ReleaseCall(const sptr<IAbilityConnection>& connect,
+    const AppExecFwk::ElementName& element)
 {
     GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::ReleaseCall";
     return 0;
 }
 
-int MockServiceAbilityManagerService::StopServiceAbility(const Want &want, int32_t userId)
+int MockServiceAbilityManagerService::StopServiceAbility(const Want& want, int32_t userId)
 {
     return 0;
 }

test/mock/frameworks_kits_ability_ability_runtime_test/AMS/mock_serviceability_manager_service.h

@@ -30,119 +30,119 @@ namespace OHOS {
 namespace AAFwk {
 enum class ServiceRunningState { STATE_NOT_START, STATE_RUNNING };
 class MockServiceAbilityManagerService : public AbilityManagerStub,
-                                         public std::enable_shared_from_this<MockServiceAbilityManagerService> {
+    public std::enable_shared_from_this<MockServiceAbilityManagerService> {
 public:
     MockServiceAbilityManagerService();
     ~MockServiceAbilityManagerService();
 
     int StartAbility(
-        const Want &want,
+        const Want& want,
         int32_t userId = DEFAULT_INVAL_VALUE,
         int requestCode = DEFAULT_INVAL_VALUE) override;
     int StartAbility(
-        const Want &want,
-        const sptr<IRemoteObject> &callerToken,
+        const Want& want,
+        const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE,
         int requestCode = DEFAULT_INVAL_VALUE) override;
     int StartAbility(
-        const Want &want,
-        const StartOptions &startOptions,
-        const sptr<IRemoteObject> &callerToken,
+        const Want& want,
+        const StartOptions& startOptions,
+        const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE,
         int requestCode = DEFAULT_INVAL_VALUE) override;
 
     int StartAbilityByCall(
-        const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken);
+        const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken);
 
     int TerminateAbility(
-        const sptr<IRemoteObject> &token, int resultCode = -1, const Want *resultWant = nullptr) override;
-    int CloseAbility(const sptr<IRemoteObject> &token, int resultCode = DEFAULT_INVAL_VALUE,
-        const Want *resultWant = nullptr) override
+        const sptr<IRemoteObject>& token, int resultCode = -1, const Want* resultWant = nullptr) override;
+    int CloseAbility(const sptr<IRemoteObject>& token, int resultCode = DEFAULT_INVAL_VALUE,
+        const Want* resultWant = nullptr) override
     {
         return 0;
     }
-    int MinimizeAbility(const sptr<IRemoteObject> &token, bool fromUser) override
+    int MinimizeAbility(const sptr<IRemoteObject>& token, bool fromUser) override
     {
         return 0;
     }
     int ConnectAbility(
-        const Want &want,
-        const sptr<IAbilityConnection> &connect,
-        const sptr<IRemoteObject> &callerToken,
+        const Want& want,
+        const sptr<IAbilityConnection>& connect,
+        const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE) override;
-    int DisconnectAbility(const sptr<IAbilityConnection> &connect) override;
+    int DisconnectAbility(const sptr<IAbilityConnection>& connect) override;
 
-    int AttachAbilityThread(const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token) override;
+    int AttachAbilityThread(const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token) override;
 
-    int AbilityTransitionDone(const sptr<IRemoteObject> &token, int state, const PacMap &saveData) override;
-    int ScheduleConnectAbilityDone(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject) override;
-    int ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token) override;
-    int ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token) override;
+    int AbilityTransitionDone(const sptr<IRemoteObject>& token, int state, const PacMap& saveData) override;
+    int ScheduleConnectAbilityDone(const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject) override;
+    int ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token) override;
+    int ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token) override;
 
-    void DumpState(const std::string &args, std::vector<std::string> &info) override;
+    void DumpState(const std::string& args, std::vector<std::string>& info) override;
     void DumpSysState(
         const std::string& args, std::vector<std::string>& state, bool isClient, bool isUserID, int UserID) override;
 
-    int TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId) override;
-    int StopServiceAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE) override;
+    int TerminateAbilityResult(const sptr<IRemoteObject>& token, int startId) override;
+    int StopServiceAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE) override;
 
-    int TerminateAbilityByCaller(const sptr<IRemoteObject> &callerToken, int requestCode) override;
+    int TerminateAbilityByCaller(const sptr<IRemoteObject>& callerToken, int requestCode) override;
 
-    int ReleaseCall(const sptr<IAbilityConnection> &connect, const AppExecFwk::ElementName &element) override;
+    int ReleaseCall(const sptr<IAbilityConnection>& connect, const AppExecFwk::ElementName& element) override;
 
-    MOCK_METHOD1(KillProcess, int(const std::string &bundleName));
-    MOCK_METHOD2(UninstallApp, int(const std::string &bundleName, int32_t uid));
+    MOCK_METHOD1(KillProcess, int(const std::string& bundleName));
+    MOCK_METHOD2(UninstallApp, int(const std::string& bundleName, int32_t uid));
     MOCK_METHOD2(
-        GetWantSender, sptr<IWantSender>(const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken));
-    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender> &target, const SenderInfo &senderInfo));
-    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender> &sender));
-    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender> &target));
-    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender> &target, std::shared_ptr<Want> &want));
-    MOCK_METHOD5(StartAbility, int(const Want &want, const AbilityStartSetting &abilityStartSetting,
-                                   const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode));
+        GetWantSender, sptr<IWantSender>(const WantSenderInfo& wantSenderInfo, const sptr<IRemoteObject>& callerToken));
+    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender>& target, const SenderInfo& senderInfo));
+    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender>& sender));
+    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender>& target));
+    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender>& target, std::shared_ptr<Want>& want));
+    MOCK_METHOD5(StartAbility, int(const Want& want, const AbilityStartSetting& abilityStartSetting,
+        const sptr<IRemoteObject>& callerToken, int32_t userId, int requestCode));
     MOCK_METHOD1(GetPendinTerminateAbilityTestgRequestWant, void(int id));
-    MOCK_METHOD3(StartContinuation, int(const Want &want, const sptr<IRemoteObject> &abilityToken, int32_t status));
+    MOCK_METHOD3(StartContinuation, int(const Want& want, const sptr<IRemoteObject>& abilityToken, int32_t status));
     MOCK_METHOD2(NotifyContinuationResult, int(int32_t missionId, int32_t result));
 
     MOCK_METHOD1(LockMissionForCleanup, int(int32_t missionId));
     MOCK_METHOD1(UnlockMissionForCleanup, int(int32_t missionId));
 
-    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener> &listener));
-    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener> &listener));
-    MOCK_METHOD2(RegisterMissionListener, int(const std::string &deviceId,
-                                              const sptr<IRemoteMissionListener> &listener));
-    MOCK_METHOD2(UnRegisterMissionListener, int(const std::string &deviceId,
-                                                const sptr<IRemoteMissionListener> &listener));
+    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener>& listener));
+    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener>& listener));
+    MOCK_METHOD2(RegisterMissionListener, int(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener));
+    MOCK_METHOD2(UnRegisterMissionListener, int(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener));
     MOCK_METHOD3(
-        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo> &missionInfos));
-    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo &missionInfo));
+        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo>& missionInfos));
+    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo& missionInfo));
     MOCK_METHOD1(CleanMission, int(int32_t missionId));
     MOCK_METHOD0(CleanAllMissions, int());
     MOCK_METHOD1(MoveMissionToFront, int(int32_t missionId));
-    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions &startOptions));
-    MOCK_METHOD1(GetMissionIdByToken, int32_t(const sptr<IRemoteObject> &token));
+    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions& startOptions));
+    MOCK_METHOD1(GetMissionIdByToken, int32_t(const sptr<IRemoteObject>& token));
 #ifdef ABILITY_COMMAND_FOR_TEST
     MOCK_METHOD0(BlockAppService, int());
     MOCK_METHOD0(BlockAmsService, int());
     MOCK_METHOD1(BlockAbility, int(int32_t abilityRecordId));
 #endif
 
-    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender> &target, std::shared_ptr<WantSenderInfo> &info));
+    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender>& target, std::shared_ptr<WantSenderInfo>& info));
 
     sptr<IAbilityScheduler> AcquireDataAbility(
-        const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken) override
+        const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken) override
     {
         return nullptr;
     }
 
     int ReleaseDataAbility(
-        sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken) override
+        sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken) override
     {
         return 0;
     }
@@ -158,23 +158,23 @@ public:
         return;
     }
 
-    int ClearUpApplicationData(const std::string &bundleName) override
+    int ClearUpApplicationData(const std::string& bundleName) override
     {
         return 0;
     }
 
-    int ContinueMission(const std::string &srcDeviceId, const std::string &dstDeviceId,
-        int32_t missionId, const sptr<IRemoteObject> &callback, AAFwk::WantParams &wantParams)
+    int ContinueMission(const std::string& srcDeviceId, const std::string& dstDeviceId,
+        int32_t missionId, const sptr<IRemoteObject>& callback, AAFwk::WantParams& wantParams)
     {
         return 0;
     }
 
-    int ContinueAbility(const std::string &deviceId, int32_t missionId, uint32_t versionCode)
+    int ContinueAbility(const std::string& deviceId, int32_t missionId, uint32_t versionCode)
     {
         return 0;
     }
 
-    void NotifyCompleteContinuation(const std::string &deviceId, int32_t sessionId, bool isSuccess)
+    void NotifyCompleteContinuation(const std::string& deviceId, int32_t sessionId, bool isSuccess)
     {}
 
     int StartSyncRemoteMissions(const std::string& devId, bool fixConflict, int64_t tag)
@@ -192,39 +192,39 @@ public:
         return 0;
     }
 
-    int StopUser(int accountId, const sptr<IStopUserCallback> &callback)
+    int StopUser(int accountId, const sptr<IStopUserCallback>& callback)
     {
         return 0;
     }
 
-    int SetMissionIcon(const sptr<IRemoteObject> &abilityToken,
-        const std::shared_ptr<OHOS::Media::PixelMap> &icon)
+    int SetMissionIcon(const sptr<IRemoteObject>& abilityToken,
+        const std::shared_ptr<OHOS::Media::PixelMap>& icon)
     {
         return commonMockResultFlag_ ? 0 : -1;
     }
 
-    int SetMissionLabel(const sptr<IRemoteObject> &abilityToken, const std::string &label)
+    int SetMissionLabel(const sptr<IRemoteObject>& abilityToken, const std::string& label)
     {
         return commonMockResultFlag_ ? 0 : -1;
     }
 
-    int GetAbilityRunningInfos(std::vector<AbilityRunningInfo> &info) override
+    int GetAbilityRunningInfos(std::vector<AbilityRunningInfo>& info) override
     {
         return 0;
     }
 
-    int GetExtensionRunningInfos(int upperLimit, std::vector<ExtensionRunningInfo> &info) override
+    int GetExtensionRunningInfos(int upperLimit, std::vector<ExtensionRunningInfo>& info) override
     {
         return 0;
     }
 
-    int GetProcessRunningInfos(std::vector<AppExecFwk::RunningProcessInfo> &info) override
+    int GetProcessRunningInfos(std::vector<AppExecFwk::RunningProcessInfo>& info) override
     {
         return 0;
     }
 
     int SetAbilityController(
-        const sptr<AppExecFwk::IAbilityController> &abilityController, bool imAStabilityTest) override
+        const sptr<AppExecFwk::IAbilityController>& abilityController, bool imAStabilityTest) override
     {
         return 0;
     }
@@ -244,28 +244,28 @@ public:
         return 0;
     }
 
-    int StartUserTest(const Want &want, const sptr<IRemoteObject> &observer) override
+    int StartUserTest(const Want& want, const sptr<IRemoteObject>& observer) override
     {
         return 0;
     }
 
     int FinishUserTest(
-        const std::string &msg, const int64_t &resultCode, const std::string &bundleName) override
+        const std::string& msg, const int64_t& resultCode, const std::string& bundleName) override
     {
         return 0;
     }
 
-    int GetTopAbility(sptr<IRemoteObject> &token) override
+    int GetTopAbility(sptr<IRemoteObject>& token) override
     {
         return 0;
     }
 
-    int DelegatorDoAbilityForeground(const sptr<IRemoteObject> &token) override
+    int DelegatorDoAbilityForeground(const sptr<IRemoteObject>& token) override
     {
         return 0;
     }
 
-    int DelegatorDoAbilityBackground(const sptr<IRemoteObject> &token) override
+    int DelegatorDoAbilityBackground(const sptr<IRemoteObject>& token) override
     {
         return 0;
     }
@@ -275,10 +275,10 @@ public:
         return 0;
     }
 
-    void CompleteFirstFrameDrawing(const sptr<IRemoteObject> &abilityToken) override {}
+    void CompleteFirstFrameDrawing(const sptr<IRemoteObject>& abilityToken) override {}
 
 #ifdef ABILITY_COMMAND_FOR_TEST
-    int ForceTimeoutForTest(const std::string &abilityName, const std::string &state) override
+    int ForceTimeoutForTest(const std::string& abilityName, const std::string& state) override
     {
         return 0;
     }

test/mock/frameworks_kits_ability_native_test/include/mock_ability.cpp

@@ -24,8 +24,8 @@ namespace OHOS {
 namespace AppExecFwk {
 REGISTER_AA(Ability)
 
-void Ability::Init(std::shared_ptr<AbilityInfo> &abilityInfo, const std::shared_ptr<OHOSApplication> &application,
-    std::shared_ptr<AbilityHandler> &handler, const sptr<IRemoteObject> &token)
+void Ability::Init(std::shared_ptr<AbilityInfo>& abilityInfo, const std::shared_ptr<OHOSApplication>& application,
+    std::shared_ptr<AbilityHandler>& handler, const sptr<IRemoteObject>& token)
 {
     HILOG_INFO("Ability::Init called.");
 
@@ -49,7 +49,7 @@ std::shared_ptr<Global::Resource::ResourceManager> Ability::GetResourceManager()
     return remoteObject;
 }
 
-void Ability::OnStart(const Want &want)
+void Ability::OnStart(const Want& want)
 {
     return;
 }
@@ -67,42 +67,42 @@ void Ability::OnActive()
 void Ability::OnInactive()
 {}
 
-sptr<IRemoteObject> Ability::OnConnect(const Want &want)
+sptr<IRemoteObject> Ability::OnConnect(const Want& want)
 {
     return nullptr;
 }
 
-void Ability::OnDisconnect(const Want &want)
+void Ability::OnDisconnect(const Want& want)
 {}
 
-void Ability::StartAbilityForResult(const Want &want, int requestCode)
+void Ability::StartAbilityForResult(const Want& want, int requestCode)
 {
     return;
 }
 
-void Ability::StartAbilityForResult(const Want &want, int requestCode, AbilityStartSetting abilityStartSetting)
+void Ability::StartAbilityForResult(const Want& want, int requestCode, AbilityStartSetting abilityStartSetting)
 {
     return;
 }
 
-void Ability::StartAbility(const Want &want, AbilityStartSetting abilityStartSetting)
+void Ability::StartAbility(const Want& want, AbilityStartSetting abilityStartSetting)
 {
     return;
 }
 
-std::string Ability::GetType(const Uri &uri)
+std::string Ability::GetType(const Uri& uri)
 {
     std::string value("\nullptr");
     return value;
 }
 
-int Ability::Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
+int Ability::Insert(const Uri& uri, const NativeRdb::ValuesBucket& value)
 {
     GTEST_LOG_(INFO) << "Mock Ability::Insert called";
     return 1;
 }
 
-void Ability::OnConfigurationUpdated(const Configuration &configuration)
+void Ability::OnConfigurationUpdated(const Configuration& configuration)
 {
     return;
 }
@@ -112,13 +112,13 @@ void Ability::OnMemoryLevel(int level)
     return;
 }
 
-std::shared_ptr<RawFileDescriptor> Ability::OpenRawFile(const Uri &uri, const std::string &mode)
+std::shared_ptr<RawFileDescriptor> Ability::OpenRawFile(const Uri& uri, const std::string& mode)
 {
     return nullptr;
 }
 
-int Ability::Update(const Uri &uri, const NativeRdb::ValuesBucket &value,
-    const NativeRdb::DataAbilityPredicates &predicates)
+int Ability::Update(const Uri& uri, const NativeRdb::ValuesBucket& value,
+    const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "Mock Ability::Update called";
     return 1;
@@ -139,7 +139,7 @@ bool Ability::IsTerminating()
     return false;
 }
 
-void Ability::OnAbilityResult(int requestCode, int resultCode, const Want &want)
+void Ability::OnAbilityResult(int requestCode, int resultCode, const Want& want)
 {}
 
 void Ability::OnBackPressed()
@@ -147,17 +147,17 @@ void Ability::OnBackPressed()
     return;
 }
 
-void Ability::OnNewWant(const Want &want)
+void Ability::OnNewWant(const Want& want)
 {
     HILOG_INFO("Ability::OnNewWant called");
 }
 
-void Ability::OnRestoreAbilityState(const PacMap &inState)
+void Ability::OnRestoreAbilityState(const PacMap& inState)
 {
     HILOG_INFO("Ability::OnRestoreAbilityState called");
 }
 
-void Ability::OnSaveAbilityState(const PacMap &outState)
+void Ability::OnSaveAbilityState(const PacMap& outState)
 {
     HILOG_INFO("Ability::OnSaveAbilityState called");
 }
@@ -167,7 +167,7 @@ void Ability::OnEventDispatch()
     return;
 }
 
-void Ability::SetWant(const AAFwk::Want &want)
+void Ability::SetWant(const AAFwk::Want& want)
 {
     setWant_ = std::make_shared<AAFwk::Want>(want);
 }
@@ -177,7 +177,7 @@ std::shared_ptr<AAFwk::Want> Ability::GetWant()
     return setWant_;
 }
 
-void Ability::SetResult(int resultCode, const Want &resultData)
+void Ability::SetResult(int resultCode, const Want& resultData)
 {
     if (abilityInfo_ == nullptr) {
         HILOG_INFO("Ability::SetResult nullptr == abilityInfo_");
@@ -190,17 +190,17 @@ void Ability::SetResult(int resultCode, const Want &resultData)
     }
 }
 
-void Ability::OnCommand(const AAFwk::Want &want, bool restart, int startId)
+void Ability::OnCommand(const AAFwk::Want& want, bool restart, int startId)
 {
     return;
 }
 
-void Ability::Dump(const std::string &extra)
+void Ability::Dump(const std::string& extra)
 {
     return;
 }
 
-void Ability::KeepBackgroundRunning(int id, const NotificationRequest &notificationRequest)
+void Ability::KeepBackgroundRunning(int id, const NotificationRequest& notificationRequest)
 {
     return;
 }
@@ -210,18 +210,18 @@ void Ability::CancelBackgroundRunning()
     return;
 }
 
-const std::shared_ptr<Uri> Ability::NormalizeUri(const Uri &uri)
+const std::shared_ptr<Uri> Ability::NormalizeUri(const Uri& uri)
 {
     return nullptr;
 }
 
-int Ability::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
+int Ability::Delete(const Uri& uri, const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "Mock Ability::Delete called";
     return 1;
 }
 
-std::vector<std::string> Ability::GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
+std::vector<std::string> Ability::GetFileTypes(const Uri& uri, const std::string& mimeTypeFilter)
 {
     std::vector<std::string> value;
     value.push_back(mimeTypeFilter);
@@ -229,25 +229,25 @@ std::vector<std::string> Ability::GetFileTypes(const Uri &uri, const std::string
     return value;
 }
 
-int Ability::OpenFile(const Uri &uri, const std::string &mode)
+int Ability::OpenFile(const Uri& uri, const std::string& mode)
 {
     GTEST_LOG_(INFO) << "Mock Ability::OpenFile called";
     return 1;
 }
 
 std::shared_ptr<NativeRdb::AbsSharedResultSet> Ability::Query(
-    const Uri &uri, const std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
+    const Uri& uri, const std::vector<std::string>& columns, const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "Mock Ability::Query called";
     return nullptr;
 }
 
-bool Ability::Reload(const Uri &uri, const PacMap &extras)
+bool Ability::Reload(const Uri& uri, const PacMap& extras)
 {
     return true;
 }
 
-void Ability::ContinueAbilityReversibly(const std::string &deviceId)
+void Ability::ContinueAbilityReversibly(const std::string& deviceId)
 {
     return;
 }
@@ -267,7 +267,7 @@ std::shared_ptr<ContinuationState> Ability::GetContinuationState()
     return nullptr;
 }
 
-std::shared_ptr<Uri> Ability::DenormalizeUri(const Uri &uri)
+std::shared_ptr<Uri> Ability::DenormalizeUri(const Uri& uri)
 {
     return nullptr;
 }
@@ -290,7 +290,7 @@ AbilityLifecycleExecutor::LifecycleState Ability::GetState()
     return (AbilityLifecycleExecutor::LifecycleState)abilityLifecycleExecutor_->GetState();
 }
 
-void Ability::StartAbility(const Want &want)
+void Ability::StartAbility(const Want& want)
 {
     HILOG_INFO("Ability::StartAbility called");
     AbilityContext::StartAbility(want, -1);
@@ -302,13 +302,13 @@ void Ability::TerminateAbility()
     AbilityContext::TerminateAbility();
 }
 
-int Ability::TerminateAbility(Want &want)
+int Ability::TerminateAbility(Want& want)
 {
     return -1;
 }
 
 #ifdef SUPPORT_GRAPHICS
-void Ability::OnForeground(const Want &want)
+void Ability::OnForeground(const Want& want)
 {
     return;
 }
@@ -318,22 +318,22 @@ void Ability::OnBackground()
     return;
 }
 
-bool Ability::OnKeyDown(int keyCode, const KeyEvent &keyEvent)
+bool Ability::OnKeyDown(int keyCode, const KeyEvent& keyEvent)
 {
     return false;
 }
 
-bool Ability::OnKeyUp(int keyCode, const KeyEvent &keyEvent)
+bool Ability::OnKeyUp(int keyCode, const KeyEvent& keyEvent)
 {
     return false;
 }
 
-bool Ability::OnTouchEvent(const TouchEvent &touchEvent)
+bool Ability::OnTouchEvent(const TouchEvent& touchEvent)
 {
     return false;
 }
 
-void Ability::SetUIContent(const ComponentContainer &componentContainer)
+void Ability::SetUIContent(const ComponentContainer& componentContainer)
 {
     return;
 }
@@ -344,12 +344,12 @@ void Ability::SetUIContent(int layoutRes)
 }  // namespace AppExecFwk
 
 void Ability::SetUIContent(
-    const ComponentContainer &componentContainer, std::shared_ptr<Context> &context, int typeFlag)
+    const ComponentContainer& componentContainer, std::shared_ptr<Context>& context, int typeFlag)
 {
     return;
 }
 
-void Ability::SetUIContent(int layoutRes, std::shared_ptr<Context> &context, int typeFlag)
+void Ability::SetUIContent(int layoutRes, std::shared_ptr<Context>& context, int typeFlag)
 {
     return;
 }
@@ -359,7 +359,7 @@ void Ability::SetUIContent(int layoutRes, std::shared_ptr<Context> &context, int
  *
  * @param config Indicates the window config defined by the user.
  */
-void Ability::SetUIContent(const WindowConfig &config)
+void Ability::SetUIContent(const WindowConfig& config)
 {
     if (abilityWindow_ == nullptr) {
         HILOG_ERROR("Ability::SetUIContent abilityWindow_ is nullptr");
@@ -375,7 +375,7 @@ void Ability::SetUIContent(const WindowConfig &config)
  *
  * @return Returns a IWindowsManager object pointer.
  */
-std::unique_ptr<Window> &Ability::GetWindow(int windowID)
+std::unique_ptr<Window>& Ability::GetWindow(int windowID)
 {
     HILOG_INFO("Ability::GetWindow called windowID = %d.", windowID);
 
@@ -392,7 +392,7 @@ bool Ability::HasWindowFocus()
     return false;
 }
 
-bool Ability::OnKeyPressAndHold(int keyCode, const std::shared_ptr<KeyEvent> &keyEvent)
+bool Ability::OnKeyPressAndHold(int keyCode, const std::shared_ptr<KeyEvent>& keyEvent)
 {
     return false;
 }

test/mock/frameworks_kits_ability_native_test/include/mock_ability_impl.h

@@ -29,7 +29,7 @@ public:
     MockAbilityimpl() = default;
     virtual ~MockAbilityimpl() = default;
 
-    void ImplStart(const Want &want)
+    void ImplStart(const Want& want)
     {
         this->Start(want);
     }
@@ -82,7 +82,7 @@ public:
     }
 
 #ifdef SUPPORT_GRAPHICS
-    void ImplForeground(const Want &want)
+    void ImplForeground(const Want& want)
     {
         this->Foreground(want);
     }

test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_client.cpp

@@ -42,67 +42,67 @@ AbilityManagerClient::~AbilityManagerClient()
 {}
 
 ErrCode AbilityManagerClient::AttachAbilityThread(
-    const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
+    const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token)
 {
     GTEST_LOG_(INFO) << "Mock AbilityManagerClient::AttachAbilityThread called";
     return -1;
 }
 
-ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject> &token, int state, const PacMap &saveData)
+ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject>& token, int state, const PacMap& saveData)
 {
     return -1;
 }
 
 ErrCode AbilityManagerClient::ScheduleConnectAbilityDone(
-    const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
+    const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject)
 {
     return -1;
 }
 
-ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token)
 {
     return -1;
 }
 
-ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token)
 {
     return -1;
 }
 
-ErrCode AbilityManagerClient::StartAbility(const Want &want, int requestCode, int32_t userId)
+ErrCode AbilityManagerClient::StartAbility(const Want& want, int requestCode, int32_t userId)
 {
     return -1;
 }
 
-ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     return -1;
 }
 
-ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &callerToken, int requestCode)
+ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject>& callerToken, int requestCode)
 {
     GTEST_LOG_(INFO) << "Mock AbilityManagerClient::TerminateAbility called";
     return -1;
 }
 
-ErrCode AbilityManagerClient::TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId)
+ErrCode AbilityManagerClient::TerminateAbilityResult(const sptr<IRemoteObject>& token, int startId)
 {
     return -1;
 }
 
 ErrCode AbilityManagerClient::ConnectAbility(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken, int32_t userId)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken, int32_t userId)
 {
     return -1;
 }
 
-ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection> &connect)
+ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection>& connect)
 {
     return -1;
 }
 
 sptr<IAbilityScheduler> AbilityManagerClient::AcquireDataAbility(
-    const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken)
+    const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken)
 {
     GTEST_LOG_(INFO) << "Mock AcquireDataAbility called";
     sptr<IAbilityScheduler> dataScheduler = new (std::nothrow) OHOS::AppExecFwk::MockAbilityThread();
@@ -110,13 +110,13 @@ sptr<IAbilityScheduler> AbilityManagerClient::AcquireDataAbility(
 }
 
 ErrCode AbilityManagerClient::ReleaseDataAbility(
-    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken)
+    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken)
 {
     GTEST_LOG_(INFO) << "Mock ReleaseDataAbility called";
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::DumpState(const std::string &args, std::vector<std::string> &state)
+ErrCode AbilityManagerClient::DumpState(const std::string& args, std::vector<std::string>& state)
 {
     return -1;
 }
@@ -126,7 +126,7 @@ ErrCode AbilityManagerClient::Connect()
     return -1;
 }
 
-ErrCode AbilityManagerClient::StopServiceAbility(const Want &want)
+ErrCode AbilityManagerClient::StopServiceAbility(const Want& want)
 {
     return -1;
 }

test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_client.h

@@ -49,94 +49,94 @@ public:
 
 class MockAbilityThread : public IRemoteStub<AAFwk::IAbilityScheduler> {
 public:
-    virtual void ScheduleAbilityTransaction(const Want &want, const LifeCycleStateInfo &targetState) {};
-    virtual void SendResult(int requestCode, int resultCode, const Want &resultWant) {};
-    virtual void ScheduleConnectAbility(const Want &want) {};
-    virtual void ScheduleDisconnectAbility(const Want &want) {};
-    virtual void ScheduleCommandAbility(const Want &want, bool restart, int startId) {};
+    virtual void ScheduleAbilityTransaction(const Want& want, const LifeCycleStateInfo& targetState) {};
+    virtual void SendResult(int requestCode, int resultCode, const Want& resultWant) {};
+    virtual void ScheduleConnectAbility(const Want& want) {};
+    virtual void ScheduleDisconnectAbility(const Want& want) {};
+    virtual void ScheduleCommandAbility(const Want& want, bool restart, int startId) {};
     virtual void ScheduleSaveAbilityState() {};
-    virtual void ScheduleRestoreAbilityState(const PacMap &inState) {};
-    virtual std::vector<std::string> GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
+    virtual void ScheduleRestoreAbilityState(const PacMap& inState) {};
+    virtual std::vector<std::string> GetFileTypes(const Uri& uri, const std::string& mimeTypeFilter)
     {
         return std::vector<std::string>();
     };
-    virtual int OpenFile(const Uri &uri, const std::string &mode)
+    virtual int OpenFile(const Uri& uri, const std::string& mode)
     {
         return OPENFILENUM;
     };
-    virtual int OpenRawFile(const Uri &uri, const std::string &mode)
+    virtual int OpenRawFile(const Uri& uri, const std::string& mode)
     {
         return OPENRAWFILENUM;
     };
-    virtual int Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
+    virtual int Insert(const Uri& uri, const NativeRdb::ValuesBucket& value)
     {
         return INSERTNUM;
     };
     virtual int Update(
-        const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates)
+        const Uri& uri, const NativeRdb::ValuesBucket& value, const NativeRdb::DataAbilityPredicates& predicates)
     {
         return UPDATENUM;
     };
-    virtual int Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
+    virtual int Delete(const Uri& uri, const NativeRdb::DataAbilityPredicates& predicates)
     {
         return DELETENUM;
     };
     virtual std::shared_ptr<NativeRdb::AbsSharedResultSet> Query(
-        const Uri &uri, std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
+        const Uri& uri, std::vector<std::string>& columns, const NativeRdb::DataAbilityPredicates& predicates)
     {
         return std::make_shared<NativeRdb::AbsSharedResultSet>("resultset");
     };
     std::shared_ptr<AppExecFwk::PacMap> Call(
-        const Uri &uri, const std::string &method, const std::string &arg, const AppExecFwk::PacMap &pacMap)
+        const Uri& uri, const std::string& method, const std::string& arg, const AppExecFwk::PacMap& pacMap)
     {
         return nullptr;
     }
-    virtual std::string GetType(const Uri &uri)
+    virtual std::string GetType(const Uri& uri)
     {
         return std::string("Type1");
     };
-    virtual bool Reload(const Uri &uri, const PacMap &extras)
+    virtual bool Reload(const Uri& uri, const PacMap& extras)
     {
         return true;
     };
-    virtual int BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values)
+    virtual int BatchInsert(const Uri& uri, const std::vector<NativeRdb::ValuesBucket>& values)
     {
         return BATCHINSERTNUM;
     };
-    virtual bool ScheduleRegisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
+    virtual bool ScheduleRegisterObserver(const Uri& uri, const sptr<AAFwk::IDataAbilityObserver>& dataObserver)
     {
         return true;
     };
-    virtual bool ScheduleUnregisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
+    virtual bool ScheduleUnregisterObserver(const Uri& uri, const sptr<AAFwk::IDataAbilityObserver>& dataObserver)
     {
         return true;
     };
-    virtual bool ScheduleNotifyChange(const Uri &uri)
+    virtual bool ScheduleNotifyChange(const Uri& uri)
     {
         return true;
     };
-    virtual Uri NormalizeUri(const Uri &uri)
+    virtual Uri NormalizeUri(const Uri& uri)
     {
         return Uri("dataability:///test.aaa");
     };
-    virtual Uri DenormalizeUri(const Uri &uri)
+    virtual Uri DenormalizeUri(const Uri& uri)
     {
         return Uri("dataability:///test.aaa");
     };
     virtual std::vector<std::shared_ptr<AppExecFwk::DataAbilityResult>> ExecuteBatch(
-        const std::vector<std::shared_ptr<AppExecFwk::DataAbilityOperation>> &operations)
+        const std::vector<std::shared_ptr<AppExecFwk::DataAbilityOperation>>& operations)
     {
         return std::vector<std::shared_ptr<AppExecFwk::DataAbilityResult>>();
     };
-    #ifdef ABILITY_COMMAND_FOR_TEST
+#ifdef ABILITY_COMMAND_FOR_TEST
     virtual int BlockAbility()
     {
         return 0;
     };
-    #endif
+#endif
     virtual void NotifyContinuationResult(int32_t result) {};
     virtual void ContinueAbility(const std::string& deviceId, uint32_t versionCode) {};
-    virtual void DumpAbilityInfo(const std::vector<std::string> &params, std::vector<std::string> &info) {};
+    virtual void DumpAbilityInfo(const std::vector<std::string>& params, std::vector<std::string>& info) {};
     virtual sptr<IRemoteObject> CallRequest()
     {
         return sptr<IRemoteObject>(nullptr);

test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_client_for_data_ability_observer.h

@@ -30,7 +30,7 @@ namespace OHOS {
 namespace AppExecFwk {
 class MockAbilitySchedulerTools {
 public:
-    MockAbilitySchedulerTools():mockStatus(false) {};
+    MockAbilitySchedulerTools() : mockStatus(false) {}
     ~MockAbilitySchedulerTools() = default;
 
     // return Copy AbilityThread class Smart pointer
@@ -100,13 +100,13 @@ std::shared_ptr<MockAbilitySchedulerTools> MockAbilitySchedulerTools::instance_
 namespace OHOS {
 namespace AAFwk {
 sptr<AAFwk::IAbilityScheduler> AAFwk::AbilityManagerClient::AcquireDataAbility(
-    const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken)
+    const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken)
 {
     return AppExecFwk::MockAbilitySchedulerTools::GetInstance()->GetAbilitySchedulerProxy();
 }
 
 ErrCode AbilityManagerClient::ReleaseDataAbility(
-    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken)
+    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken)
 {
     return ERR_OK;
 }

test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_client_interface1.cpp

@@ -72,61 +72,61 @@ AbilityManagerClient::~AbilityManagerClient()
 {}
 
 ErrCode AbilityManagerClient::AttachAbilityThread(
-    const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
+    const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject> &token, int state, const PacMap &saveData)
+ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject>& token, int state, const PacMap& saveData)
 {
     return ERR_OK;
 }
 
 ErrCode AbilityManagerClient::ScheduleConnectAbilityDone(
-    const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
+    const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     return ERR_OK;
 }
 
 ErrCode AbilityManagerClient::ConnectAbility(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection> &connect)
+ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection>& connect)
 {
     return ERR_OK;
 }
 
 sptr<IAbilityScheduler> AbilityManagerClient::AcquireDataAbility(
-    const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken)
+    const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken)
 {
     return nullptr;
 }
 
 ErrCode AbilityManagerClient::ReleaseDataAbility(
-    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken)
+    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::DumpState(const std::string &args, std::vector<std::string> &state)
+ErrCode AbilityManagerClient::DumpState(const std::string& args, std::vector<std::string>& state)
 {
     return ERR_OK;
 }
@@ -136,33 +136,33 @@ ErrCode AbilityManagerClient::Connect()
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::StopServiceAbility(const Want &want)
+ErrCode AbilityManagerClient::StopServiceAbility(const Want& want)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::KillProcess(const std::string &bundleName)
+ErrCode AbilityManagerClient::KillProcess(const std::string& bundleName)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::StartAbility(const Want &want, int requestCode)
+ErrCode AbilityManagerClient::StartAbility(const Want& want, int requestCode)
 {
     return MockAbilityManagerClient::GetInstance()->GetStartAbility();
 }
 
-ErrCode AbilityManagerClient::StartAbility(const Want &want, const sptr<IRemoteObject> &callerToken, int requestCode)
+ErrCode AbilityManagerClient::StartAbility(const Want& want, const sptr<IRemoteObject>& callerToken, int requestCode)
 {
     return MockAbilityManagerClient::GetInstance()->GetStartAbility();
 }
 
-ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &callerToken, int requestCode)
+ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject>& callerToken, int requestCode)
 {
     MockAbilityManagerClient::GetInstance()->SetTerminateAbilityValue(requestCode);
     return MockAbilityManagerClient::GetInstance()->GetTerminateAbility();
 }
 
-ErrCode AbilityManagerClient::TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId)
+ErrCode AbilityManagerClient::TerminateAbilityResult(const sptr<IRemoteObject>& token, int startId)
 {
     return MockAbilityManagerClient::GetInstance()->GetTerminateAbilityResult();
 }
@@ -237,7 +237,7 @@ MockAbilityContextTest::MockAbilityContextTest()
 MockAbilityContextTest::~MockAbilityContextTest()
 {}
 
-void MockAbilityContextTest::StartAbility(const AAFwk::Want &want, int requestCode)
+void MockAbilityContextTest::StartAbility(const AAFwk::Want& want, int requestCode)
 {
     ++startAbilityRunCount_;
 }

test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_client_interface1.h

@@ -41,7 +41,7 @@ public:
     MockAbilityStub() = default;
     ~MockAbilityStub() = default;
     int OnRemoteRequest(
-        uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override
+        uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override
     {
         return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
     };
@@ -62,7 +62,7 @@ public:
     MockAbilityContextTest();
     ~MockAbilityContextTest();
 
-    void StartAbility(const AAFwk::Want &want, int requestCode);
+    void StartAbility(const AAFwk::Want& want, int requestCode);
 
     void SetToken(const sptr<IRemoteObject> token);
 

test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_clientex.cpp

@@ -47,7 +47,7 @@ AbilityManagerClient::~AbilityManagerClient()
 {}
 
 ErrCode AbilityManagerClient::AttachAbilityThread(
-    const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
+    const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token)
 {
     HILOG_INFO("AbilityManagerClient::AttachAbilityThread start");
     ErrCode err = Connect();
@@ -59,7 +59,7 @@ ErrCode AbilityManagerClient::AttachAbilityThread(
     return abms->AttachAbilityThread(scheduler, token);
 }
 
-ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject> &token, int state, const PacMap &saveData)
+ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject>& token, int state, const PacMap& saveData)
 {
     if (remoteObject_ == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -69,7 +69,7 @@ ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject> &t
 }
 
 ErrCode AbilityManagerClient::ScheduleConnectAbilityDone(
-    const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
+    const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject)
 {
     if (remoteObject_ == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -78,7 +78,7 @@ ErrCode AbilityManagerClient::ScheduleConnectAbilityDone(
     return abms->ScheduleConnectAbilityDone(token, remoteObject);
 }
 
-ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token)
 {
     if (remoteObject_ == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -87,7 +87,7 @@ ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteOb
     return abms->ScheduleDisconnectAbilityDone(token);
 }
 
-ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token)
 {
     if (remoteObject_ == nullptr) {
         HILOG_ERROR("%{private}s:ability service not command", __func__);
@@ -97,7 +97,7 @@ ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObjec
     return abms->ScheduleCommandAbilityDone(token);
 }
 
-ErrCode AbilityManagerClient::StartAbility(const Want &want, int requestCode, int32_t userId)
+ErrCode AbilityManagerClient::StartAbility(const Want& want, int requestCode, int32_t userId)
 {
     if (remoteObject_ == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -106,7 +106,7 @@ ErrCode AbilityManagerClient::StartAbility(const Want &want, int requestCode, in
     return abms->StartAbility(want, requestCode);
 }
 
-ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     HILOG_INFO("AbilityManagerClient::TerminateAbility start");
     if (remoteObject_ == nullptr) {
@@ -118,7 +118,7 @@ ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &token,
     return abms->TerminateAbility(token, resultCode, resultWant);
 }
 
-ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &callerToken, int requestCode)
+ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject>& callerToken, int requestCode)
 {
     if (remoteObject_ == nullptr) {
         HILOG_ERROR("%{private}s:ability service not connect", __func__);
@@ -129,7 +129,7 @@ ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &caller
 }
 
 ErrCode AbilityManagerClient::ConnectAbility(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken, int32_t userId)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken, int32_t userId)
 {
     if (remoteObject_ == nullptr) {
         remoteObject_ =
@@ -139,7 +139,7 @@ ErrCode AbilityManagerClient::ConnectAbility(
     return abms->ConnectAbility(want, connect, callerToken);
 }
 
-ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection> &connect)
+ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection>& connect)
 {
     if (remoteObject_ == nullptr) {
         remoteObject_ =
@@ -149,7 +149,7 @@ ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection> &
     return abms->DisconnectAbility(connect);
 }
 
-ErrCode AbilityManagerClient::DumpState(const std::string &args, std::vector<std::string> &state)
+ErrCode AbilityManagerClient::DumpState(const std::string& args, std::vector<std::string>& state)
 {
     if (remoteObject_ == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -172,7 +172,7 @@ ErrCode AbilityManagerClient::Connect()
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::StopServiceAbility(const Want &want)
+ErrCode AbilityManagerClient::StopServiceAbility(const Want& want)
 {
     if (remoteObject_ == nullptr) {
         remoteObject_ =
@@ -183,7 +183,7 @@ ErrCode AbilityManagerClient::StopServiceAbility(const Want &want)
 }
 
 sptr<IAbilityScheduler> AbilityManagerClient::AcquireDataAbility(
-    const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken)
+    const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken)
 {
     remoteObject_ =
         OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
@@ -196,7 +196,7 @@ sptr<IAbilityScheduler> AbilityManagerClient::AcquireDataAbility(
 }
 
 ErrCode AbilityManagerClient::ReleaseDataAbility(
-    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken)
+    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken)
 {
     remoteObject_ =
         OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);

test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_service.cpp

@@ -31,7 +31,7 @@ MockAbilityManagerService::MockAbilityManagerService() : abilityScheduler_(nullp
 MockAbilityManagerService::~MockAbilityManagerService()
 {}
 
-int MockAbilityManagerService::StartAbility(const Want &want, int32_t userId, int requestCode)
+int MockAbilityManagerService::StartAbility(const Want& want, int32_t userId, int requestCode)
 {
     AbilityLifeCycleState state = AbilityLifeCycleState::ABILITY_STATE_INITIAL;
     RequestCode request = static_cast<RequestCode>(requestCode);
@@ -68,7 +68,7 @@ int MockAbilityManagerService::StartAbility(const Want &want, int32_t userId, in
 }
 
 int MockAbilityManagerService::TerminateAbility(
-    const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+    const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     GTEST_LOG_(INFO) << "MockAbilityManagerService::TerminateAbility";
 
@@ -84,27 +84,27 @@ int MockAbilityManagerService::TerminateAbility(
 }
 
 int MockAbilityManagerService::ConnectAbility(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken, int32_t userId)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken, int32_t userId)
 {
     GTEST_LOG_(INFO) << "MockAbilityManagerService::ConnectAbility";
     return ERR_OK;
 }
 
-int MockAbilityManagerService::DisconnectAbility(const sptr<IAbilityConnection> &connect)
+int MockAbilityManagerService::DisconnectAbility(const sptr<IAbilityConnection>& connect)
 {
     GTEST_LOG_(INFO) << "MockAbilityManagerService::DisconnectAbility";
     return ERR_OK;
 }
 
 int MockAbilityManagerService::AttachAbilityThread(
-    const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
+    const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token)
 {
     abilityScheduler_ = scheduler;
     EXPECT_NE(nullptr, token);
     return 0;
 }
 
-void MockAbilityManagerService::DumpState(const std::string &args, std::vector<std::string> &info)
+void MockAbilityManagerService::DumpState(const std::string& args, std::vector<std::string>& info)
 {}
 
 void MockAbilityManagerService::DumpSysState(
@@ -112,45 +112,45 @@ void MockAbilityManagerService::DumpSysState(
 {}
 
 int MockAbilityManagerService::AbilityTransitionDone(
-    const sptr<IRemoteObject> &token, int state, const PacMap &saveData)
+    const sptr<IRemoteObject>& token, int state, const PacMap& saveData)
 {
     return 0;
 }
 
 int MockAbilityManagerService::ScheduleConnectAbilityDone(
-    const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
+    const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject)
 {
     return 0;
 }
 
-int MockAbilityManagerService::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token)
+int MockAbilityManagerService::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token)
 {
     return 0;
 }
 
-int MockAbilityManagerService::ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token)
+int MockAbilityManagerService::ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token)
 {
     return 0;
 }
 
-int MockAbilityManagerService::TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId)
+int MockAbilityManagerService::TerminateAbilityResult(const sptr<IRemoteObject>& token, int startId)
 {
     GTEST_LOG_(INFO) << "MockAbilityManagerService::TerminateAbilityResult";
     return ERR_OK;
 }
 
-int MockAbilityManagerService::StopServiceAbility(const Want &want, int32_t userId)
+int MockAbilityManagerService::StopServiceAbility(const Want& want, int32_t userId)
 {
     GTEST_LOG_(INFO) << "MockAbilityManagerService::StopServiceAbility";
     return ERR_OK;
 }
 
-int MockAbilityManagerService::KillProcess(const std::string &bundleName)
+int MockAbilityManagerService::KillProcess(const std::string& bundleName)
 {
     return 0;
 }
 
-int MockAbilityManagerService::UninstallApp(const std::string &bundleName, int32_t uid)
+int MockAbilityManagerService::UninstallApp(const std::string& bundleName, int32_t uid)
 {
     return 0;
 }

test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_service.h

@@ -34,17 +34,17 @@ class MockAbilityManagerService : public AbilityManagerStub {
 public:
     MockAbilityManagerService();
     ~MockAbilityManagerService();
-    int StartAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = -1) override;
-    int StartAbility(const Want &want, const sptr<IRemoteObject> &callerToken,
+    int StartAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = -1) override;
+    int StartAbility(const Want& want, const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = -1) override
     {
         return 0;
     }
 
     int StartAbility(
-        const Want &want,
-        const StartOptions &startOptions,
-        const sptr<IRemoteObject> &callerToken,
+        const Want& want,
+        const StartOptions& startOptions,
+        const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE,
         int requestCode = DEFAULT_INVAL_VALUE) override
     {
@@ -52,112 +52,112 @@ public:
     }
 
     int TerminateAbility(
-        const sptr<IRemoteObject> &token, int resultCode = -1, const Want *resultWant = nullptr) override;
-    int CloseAbility(const sptr<IRemoteObject> &token, int resultCode = DEFAULT_INVAL_VALUE,
-        const Want *resultWant = nullptr) override
+        const sptr<IRemoteObject>& token, int resultCode = -1, const Want* resultWant = nullptr) override;
+    int CloseAbility(const sptr<IRemoteObject>& token, int resultCode = DEFAULT_INVAL_VALUE,
+        const Want* resultWant = nullptr) override
     {
         return 0;
     }
-    int MinimizeAbility(const sptr<IRemoteObject> &token, bool fromUser) override
+    int MinimizeAbility(const sptr<IRemoteObject>& token, bool fromUser) override
     {
         return 0;
     }
     int ConnectAbility(
-        const Want &want,
-        const sptr<IAbilityConnection> &connect,
-        const sptr<IRemoteObject> &callerToken,
+        const Want& want,
+        const sptr<IAbilityConnection>& connect,
+        const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE) override;
 
-    int DisconnectAbility(const sptr<IAbilityConnection> &connect) override;
+    int DisconnectAbility(const sptr<IAbilityConnection>& connect) override;
 
-    int AttachAbilityThread(const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token) override;
+    int AttachAbilityThread(const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token) override;
 
-    int AbilityTransitionDone(const sptr<IRemoteObject> &token, int state, const PacMap &saveData) override;
-    int ScheduleConnectAbilityDone(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject) override;
-    int ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token) override;
-    int ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token) override;
+    int AbilityTransitionDone(const sptr<IRemoteObject>& token, int state, const PacMap& saveData) override;
+    int ScheduleConnectAbilityDone(const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject) override;
+    int ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token) override;
+    int ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token) override;
 
-    void DumpState(const std::string &args, std::vector<std::string> &info) override;
+    void DumpState(const std::string& args, std::vector<std::string>& info) override;
 
     void DumpSysState(
         const std::string& args, std::vector<std::string>& state, bool isClient, bool isUserID, int UserID) override;
 
-    int TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId) override;
-    int StopServiceAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE) override;
+    int TerminateAbilityResult(const sptr<IRemoteObject>& token, int startId) override;
+    int StopServiceAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE) override;
 
     MOCK_METHOD2(
-        GetWantSender, sptr<IWantSender>(const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken));
-    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender> &target, const SenderInfo &senderInfo));
-    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender> &sender));
-    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender> &target));
-    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender> &target, std::shared_ptr<Want> &want));
+        GetWantSender, sptr<IWantSender>(const WantSenderInfo& wantSenderInfo, const sptr<IRemoteObject>& callerToken));
+    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender>& target, const SenderInfo& senderInfo));
+    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender>& sender));
+    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender>& target));
+    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender>& target, std::shared_ptr<Want>& want));
 
-    MOCK_METHOD5(StartAbility, int(const Want &want, const AbilityStartSetting &abilityStartSetting,
-        const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode));
+    MOCK_METHOD5(StartAbility, int(const Want& want, const AbilityStartSetting& abilityStartSetting,
+        const sptr<IRemoteObject>& callerToken, int32_t userId, int requestCode));
     MOCK_METHOD1(GetPendinTerminateAbilityTestgRequestWant, void(int id));
-    MOCK_METHOD3(StartContinuation, int(const Want &want, const sptr<IRemoteObject> &abilityToken, int32_t status));
+    MOCK_METHOD3(StartContinuation, int(const Want& want, const sptr<IRemoteObject>& abilityToken, int32_t status));
     MOCK_METHOD2(NotifyContinuationResult, int(int32_t missionId, int32_t result));
-    MOCK_METHOD5(ContinueMission, int(const std::string &srcDeviceId, const std::string &dstDeviceId,
-        int32_t missionId, const sptr<IRemoteObject> &callBack, AAFwk::WantParams &wantParams));
-    MOCK_METHOD3(ContinueAbility, int(const std::string &deviceId, int32_t missionId, uint32_t versionCode));
-    MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string &deviceId, int32_t sessionId, bool isSuccess));
+    MOCK_METHOD5(ContinueMission, int(const std::string& srcDeviceId, const std::string& dstDeviceId,
+        int32_t missionId, const sptr<IRemoteObject>& callBack, AAFwk::WantParams& wantParams));
+    MOCK_METHOD3(ContinueAbility, int(const std::string& deviceId, int32_t missionId, uint32_t versionCode));
+    MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string& deviceId, int32_t sessionId, bool isSuccess));
 
     MOCK_METHOD1(LockMissionForCleanup, int(int32_t missionId));
     MOCK_METHOD1(UnlockMissionForCleanup, int(int32_t missionId));
-    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener> &listener));
-    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener> &listener));
+    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener>& listener));
+    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener>& listener));
     MOCK_METHOD3(
-        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo> &missionInfos));
-    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo &missionInfo));
+        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo>& missionInfos));
+    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo& missionInfo));
     MOCK_METHOD1(CleanMission, int(int32_t missionId));
     MOCK_METHOD0(CleanAllMissions, int());
-    MOCK_METHOD2(SetMissionLabel, int(const sptr<IRemoteObject> &token, const std::string &label));
-    MOCK_METHOD2(SetMissionIcon, int(const sptr<IRemoteObject> &token,
-        const std::shared_ptr<OHOS::Media::PixelMap> &icon));
+    MOCK_METHOD2(SetMissionLabel, int(const sptr<IRemoteObject>& token, const std::string& label));
+    MOCK_METHOD2(SetMissionIcon, int(const sptr<IRemoteObject>& token,
+        const std::shared_ptr<OHOS::Media::PixelMap>& icon));
     MOCK_METHOD1(MoveMissionToFront, int(int32_t missionId));
-    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions &startOptions));
-    MOCK_METHOD1(GetMissionIdByToken, int32_t(const sptr<IRemoteObject> &token));
+    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions& startOptions));
+    MOCK_METHOD1(GetMissionIdByToken, int32_t(const sptr<IRemoteObject>& token));
 
-    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo> &info));
-    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo> &info));
-    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo> &info));
+    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo>& info));
+    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo>& info));
+    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo>& info));
 
-    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender> &target, std::shared_ptr<WantSenderInfo> &info));
-    MOCK_METHOD3(StartAbilityByCall, int(const Want &, const sptr<IAbilityConnection> &, const sptr<IRemoteObject> &));
-    #ifdef ABILITY_COMMAND_FOR_TEST
+    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender>& target, std::shared_ptr<WantSenderInfo>& info));
+    MOCK_METHOD3(StartAbilityByCall, int(const Want&, const sptr<IAbilityConnection>&, const sptr<IRemoteObject>&));
+#ifdef ABILITY_COMMAND_FOR_TEST
     MOCK_METHOD0(BlockAppService, int());
     MOCK_METHOD0(BlockAmsService, int());
     MOCK_METHOD1(BlockAbility, int(int32_t abilityRecordId));
-    #endif
+#endif
 
     sptr<IAbilityScheduler> AcquireDataAbility(
-        const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken) override
+        const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken) override
     {
         return nullptr;
     }
 
     int ReleaseDataAbility(
-        sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken) override
+        sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken) override
     {
         return 0;
     }
 
-    int KillProcess(const std::string &bundleName) override;
+    int KillProcess(const std::string& bundleName) override;
 
-    int UninstallApp(const std::string &bundleName, int32_t uid) override;
+    int UninstallApp(const std::string& bundleName, int32_t uid) override;
 
-    int TerminateAbilityByCaller(const sptr<IRemoteObject> &callerToken, int requestCode) override
+    int TerminateAbilityByCaller(const sptr<IRemoteObject>& callerToken, int requestCode) override
     {
         return 0;
     }
 
-    int ClearUpApplicationData(const std::string &bundleName) override
+    int ClearUpApplicationData(const std::string& bundleName) override
     {
         return 0;
     }
@@ -167,7 +167,7 @@ public:
         return 0;
     }
 
-    int StopUser(int userId, const sptr<IStopUserCallback> &callback) override
+    int StopUser(int userId, const sptr<IStopUserCallback>& callback) override
     {
         return 0;
     }
@@ -181,13 +181,13 @@ public:
     {
         return 0;
     }
-    int RegisterMissionListener(const std::string &deviceId,
-        const sptr<IRemoteMissionListener> &listener) override
+    int RegisterMissionListener(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener) override
     {
         return 0;
     }
-    int UnRegisterMissionListener(const std::string &deviceId,
-        const sptr<IRemoteMissionListener> &listener) override
+    int UnRegisterMissionListener(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener) override
     {
         return 0;
     }
@@ -205,7 +205,7 @@ public:
         return 0;
     }
 
-    int SetAbilityController(const sptr<AppExecFwk::IAbilityController> &abilityController,
+    int SetAbilityController(const sptr<AppExecFwk::IAbilityController>& abilityController,
         bool imAStabilityTest) override
     {
         return 0;
@@ -217,7 +217,7 @@ public:
     }
 
     int ReleaseCall(
-        const sptr<IAbilityConnection> &connect, const AppExecFwk::ElementName &element) override
+        const sptr<IAbilityConnection>& connect, const AppExecFwk::ElementName& element) override
     {
         return 0;
     }
@@ -227,28 +227,28 @@ public:
         return 0;
     }
 
-    int StartUserTest(const Want &want, const sptr<IRemoteObject> &observer) override
+    int StartUserTest(const Want& want, const sptr<IRemoteObject>& observer) override
     {
         return 0;
     }
 
     int FinishUserTest(
-        const std::string &msg, const int64_t &resultCode, const std::string &bundleName) override
+        const std::string& msg, const int64_t& resultCode, const std::string& bundleName) override
     {
         return 0;
     }
 
-    int GetTopAbility(sptr<IRemoteObject> &token) override
+    int GetTopAbility(sptr<IRemoteObject>& token) override
     {
         return 0;
     }
 
-    int DelegatorDoAbilityForeground(const sptr<IRemoteObject> &token) override
+    int DelegatorDoAbilityForeground(const sptr<IRemoteObject>& token) override
     {
         return 0;
     }
 
-    int DelegatorDoAbilityBackground(const sptr<IRemoteObject> &token) override
+    int DelegatorDoAbilityBackground(const sptr<IRemoteObject>& token) override
     {
         return 0;
     }
@@ -258,14 +258,14 @@ public:
         return 0;
     }
 
-    void CompleteFirstFrameDrawing(const sptr<IRemoteObject> &abilityToken) override {}
+    void CompleteFirstFrameDrawing(const sptr<IRemoteObject>& abilityToken) override {}
 
-    #ifdef ABILITY_COMMAND_FOR_TEST
-    int ForceTimeoutForTest(const std::string &abilityName, const std::string &state) override
+#ifdef ABILITY_COMMAND_FOR_TEST
+    int ForceTimeoutForTest(const std::string& abilityName, const std::string& state) override
     {
         return 0;
     }
-    #endif
+#endif
 
     enum class RequestCode {
         E_STATE_INITIAL = 0,

test/mock/frameworks_kits_ability_native_test/include/mock_ability_scheduler_for_observer.h

@@ -30,36 +30,36 @@ public:
     MockAbilitySchedulerStub() = default;
     virtual ~MockAbilitySchedulerStub() = default;
 
-    MOCK_METHOD2(ScheduleAbilityTransaction, void(const AAFwk::Want &, const AAFwk::LifeCycleStateInfo &));
-    MOCK_METHOD3(SendResult, void(int, int, const AAFwk::Want &));
-    MOCK_METHOD1(ScheduleConnectAbility, void(const AAFwk::Want &));
-    MOCK_METHOD1(ScheduleDisconnectAbility, void(const AAFwk::Want &));
-    MOCK_METHOD3(ScheduleCommandAbility, void(const AAFwk::Want &, bool, int));
+    MOCK_METHOD2(ScheduleAbilityTransaction, void(const AAFwk::Want&, const AAFwk::LifeCycleStateInfo&));
+    MOCK_METHOD3(SendResult, void(int, int, const AAFwk::Want&));
+    MOCK_METHOD1(ScheduleConnectAbility, void(const AAFwk::Want&));
+    MOCK_METHOD1(ScheduleDisconnectAbility, void(const AAFwk::Want&));
+    MOCK_METHOD3(ScheduleCommandAbility, void(const AAFwk::Want&, bool, int));
     MOCK_METHOD0(ScheduleSaveAbilityState, void());
-    MOCK_METHOD1(ScheduleRestoreAbilityState, void(const PacMap &));
-    MOCK_METHOD1(ScheduleUpdateConfiguration, void(const AppExecFwk::Configuration &));
-    MOCK_METHOD2(GetFileTypes, std::vector<std::string>(const Uri &, const std::string &));
-    MOCK_METHOD2(OpenFile, int(const Uri &, const std::string &));
-    MOCK_METHOD2(OpenRawFile, int(const Uri &, const std::string &));
-    MOCK_METHOD2(Insert, int(const Uri &, const NativeRdb::ValuesBucket &));
-    MOCK_METHOD3(Update, int(const Uri &, const NativeRdb::ValuesBucket &, const NativeRdb::DataAbilityPredicates &));
-    MOCK_METHOD2(Delete, int(const Uri &, const NativeRdb::DataAbilityPredicates &));
-    MOCK_METHOD3(Query, std::shared_ptr<NativeRdb::AbsSharedResultSet>(const Uri &,
-        std::vector<std::string> &, const NativeRdb::DataAbilityPredicates &));
-    MOCK_METHOD4(Call, std::shared_ptr<PacMap>(const Uri &, const std::string &, const std::string &, const PacMap &));
-    MOCK_METHOD1(GetType, std::string(const Uri &));
-    MOCK_METHOD2(Reload, bool(const Uri &, const PacMap &));
-    MOCK_METHOD2(BatchInsert, int(const Uri &, const std::vector<NativeRdb::ValuesBucket> &));
-    MOCK_METHOD1(DenormalizeUri, Uri(const Uri &));
-    MOCK_METHOD1(NormalizeUri, Uri(const Uri &));
-    MOCK_METHOD2(ScheduleRegisterObserver, bool(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver));
-    MOCK_METHOD2(ScheduleUnregisterObserver, bool(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver));
-    MOCK_METHOD1(ScheduleNotifyChange, bool(const Uri &uri));
+    MOCK_METHOD1(ScheduleRestoreAbilityState, void(const PacMap&));
+    MOCK_METHOD1(ScheduleUpdateConfiguration, void(const AppExecFwk::Configuration&));
+    MOCK_METHOD2(GetFileTypes, std::vector<std::string>(const Uri&, const std::string&));
+    MOCK_METHOD2(OpenFile, int(const Uri&, const std::string&));
+    MOCK_METHOD2(OpenRawFile, int(const Uri&, const std::string&));
+    MOCK_METHOD2(Insert, int(const Uri&, const NativeRdb::ValuesBucket&));
+    MOCK_METHOD3(Update, int(const Uri&, const NativeRdb::ValuesBucket&, const NativeRdb::DataAbilityPredicates&));
+    MOCK_METHOD2(Delete, int(const Uri&, const NativeRdb::DataAbilityPredicates&));
+    MOCK_METHOD3(Query, std::shared_ptr<NativeRdb::AbsSharedResultSet>(const Uri&,
+        std::vector<std::string>&, const NativeRdb::DataAbilityPredicates&));
+    MOCK_METHOD4(Call, std::shared_ptr<PacMap>(const Uri&, const std::string&, const std::string&, const PacMap&));
+    MOCK_METHOD1(GetType, std::string(const Uri&));
+    MOCK_METHOD2(Reload, bool(const Uri&, const PacMap&));
+    MOCK_METHOD2(BatchInsert, int(const Uri&, const std::vector<NativeRdb::ValuesBucket>&));
+    MOCK_METHOD1(DenormalizeUri, Uri(const Uri&));
+    MOCK_METHOD1(NormalizeUri, Uri(const Uri&));
+    MOCK_METHOD2(ScheduleRegisterObserver, bool(const Uri& uri, const sptr<AAFwk::IDataAbilityObserver>& dataObserver));
+    MOCK_METHOD2(ScheduleUnregisterObserver, bool(const Uri& uri, const sptr<AAFwk::IDataAbilityObserver>& dataObserver));
+    MOCK_METHOD1(ScheduleNotifyChange, bool(const Uri& uri));
     MOCK_METHOD1(ExecuteBatch, std::vector<std::shared_ptr<AppExecFwk::DataAbilityResult>>(
-        const std::vector<std::shared_ptr<AppExecFwk::DataAbilityOperation>> &operation));
+        const std::vector<std::shared_ptr<AppExecFwk::DataAbilityOperation>>& operation));
     MOCK_METHOD1(NotifyContinuationResult, void(int32_t result));
     MOCK_METHOD2(ContinueAbility, void(const std::string& deviceId, uint32_t versionCode));
-    MOCK_METHOD2(DumpAbilityInfo, void(const std::vector<std::string> &params, std::vector<std::string> &info));
+    MOCK_METHOD2(DumpAbilityInfo, void(const std::vector<std::string>& params, std::vector<std::string>& info));
 #ifdef ABILITY_COMMAND_FOR_TEST
     virtual int BlockAbility() override
     {

test/mock/frameworks_kits_ability_native_test/include/mock_ability_thread_for_ability_on_configuration_update.h

@@ -28,7 +28,7 @@ public:
     AbilityTest() = default;
     virtual ~AbilityTest() = default;
 
-    MOCK_METHOD1(OnConfigurationUpdated, void(const Configuration &));
+    MOCK_METHOD1(OnConfigurationUpdated, void(const Configuration&));
 
     static std::shared_ptr<AbilityTest> GetInstance()
     {

test/mock/frameworks_kits_ability_native_test/include/mock_ability_token.h

@@ -34,7 +34,7 @@ public:
     MockAbilityToken() = default;
     virtual ~MockAbilityToken() = default;
 
-    virtual int OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
+    virtual int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
     {
         return 0;
     }
@@ -45,7 +45,7 @@ private:
 
 class AbilityTokenProxy : public IRemoteProxy<IAbilityToken> {
 public:
-    explicit AbilityTokenProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IAbilityToken>(impl)
+    explicit AbilityTokenProxy(const sptr<IRemoteObject>& impl) : IRemoteProxy<IAbilityToken>(impl)
     {}
 
     virtual ~AbilityTokenProxy() = default;

test/mock/frameworks_kits_ability_native_test/include/mock_bundle_manager.cpp

@@ -22,7 +22,7 @@ namespace OHOS {
 namespace AppExecFwk {
 const long int UNEXPIRED_TIME = 1860000000;
 bool BundleMgrProxy::GetApplicationInfo(
-    const std::string &appName, const ApplicationFlag flag, const int userId, ApplicationInfo &appInfo)
+    const std::string& appName, const ApplicationFlag flag, const int userId, ApplicationInfo& appInfo)
 {
     if (appName.empty()) {
         return false;
@@ -32,13 +32,13 @@ bool BundleMgrProxy::GetApplicationInfo(
     return true;
 }
 
-std::string BundleMgrProxy::GetAppType(const std::string &bundleName)
+std::string BundleMgrProxy::GetAppType(const std::string& bundleName)
 {
     GTEST_LOG_(INFO) << " BundleMgrProxy::GetAppTyp";
     return "system";
 }
 
-bool BundleMgrProxy::QueryAbilityInfo(const Want &want, AbilityInfo &abilityInfo)
+bool BundleMgrProxy::QueryAbilityInfo(const Want& want, AbilityInfo& abilityInfo)
 {
     ElementName eleName = want.GetElement();
     if (eleName.GetBundleName().empty()) {
@@ -51,28 +51,28 @@ bool BundleMgrProxy::QueryAbilityInfo(const Want &want, AbilityInfo &abilityInfo
     return true;
 }
 
-bool BundleMgrProxy::GetHapModuleInfo(const AbilityInfo &abilityInfo, HapModuleInfo &hapModuleInfo)
+bool BundleMgrProxy::GetHapModuleInfo(const AbilityInfo& abilityInfo, HapModuleInfo& hapModuleInfo)
 {
     GTEST_LOG_(INFO) << " BundleMgrProxy::GetHapModuleInfo";
     hapModuleInfo.name = abilityInfo.package;
     return true;
 }
 
-bool BundleMgrProxy::GetHapModuleInfo(const AbilityInfo &abilityInfo, int32_t userId, HapModuleInfo &hapModuleInfo)
+bool BundleMgrProxy::GetHapModuleInfo(const AbilityInfo& abilityInfo, int32_t userId, HapModuleInfo& hapModuleInfo)
 {
     GTEST_LOG_(INFO) << " BundleMgrProxy::GetHapModuleInfo";
     hapModuleInfo.name = abilityInfo.package;
     return true;
 }
 
-int BundleMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
+int BundleMgrStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
 {
     GTEST_LOG_(INFO) << " BundleMgrStub::OnRemoteRequest";
     return 0;
 }
 
 bool BundleMgrService::GetApplicationInfo(
-    const std::string &appName, const ApplicationFlag flag, const int userId, ApplicationInfo &appInfo)
+    const std::string& appName, const ApplicationFlag flag, const int userId, ApplicationInfo& appInfo)
 {
     if (appName.empty()) {
         return false;
@@ -90,13 +90,13 @@ bool BundleMgrService::GetApplicationInfo(
     return true;
 }
 
-std::string BundleMgrService::GetAppType(const std::string &bundleName)
+std::string BundleMgrService::GetAppType(const std::string& bundleName)
 {
     GTEST_LOG_(INFO) << " BundleMgrService::GetAppType";
     return "system";
 }
 
-bool BundleMgrService::QueryAbilityInfo(const Want &want, AbilityInfo &abilityInfo)
+bool BundleMgrService::QueryAbilityInfo(const Want& want, AbilityInfo& abilityInfo)
 {
     ElementName elementName = want.GetElement();
     if (elementName.GetBundleName().empty()) {
@@ -117,13 +117,13 @@ bool BundleMgrService::QueryAbilityInfo(const Want &want, AbilityInfo &abilityIn
     return true;
 }
 
-bool BundleMgrService::GetHapModuleInfo(const AbilityInfo &abilityInfo, HapModuleInfo &hapModuleInfo)
+bool BundleMgrService::GetHapModuleInfo(const AbilityInfo& abilityInfo, HapModuleInfo& hapModuleInfo)
 {
     GTEST_LOG_(INFO) << " BundleMgrService::GetHapModuleInfo";
     hapModuleInfo.name = abilityInfo.package;
     return true;
 }
-bool BundleMgrService::GetHapModuleInfo(const AbilityInfo &abilityInfo, int32_t userId, HapModuleInfo &hapModuleInfo)
+bool BundleMgrService::GetHapModuleInfo(const AbilityInfo& abilityInfo, int32_t userId, HapModuleInfo& hapModuleInfo)
 {
     GTEST_LOG_(INFO) << " BundleMgrService::GetHapModuleInfo";
     hapModuleInfo.name = abilityInfo.package;

test/mock/frameworks_kits_ability_native_test/include/mock_bundle_manager.h

@@ -30,26 +30,26 @@ namespace OHOS {
 namespace AppExecFwk {
 class BundleMgrProxy : public IRemoteProxy<IBundleMgr> {
 public:
-    explicit BundleMgrProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IBundleMgr>(impl)
+    explicit BundleMgrProxy(const sptr<IRemoteObject>& impl) : IRemoteProxy<IBundleMgr>(impl)
     {}
     ~BundleMgrProxy() = default;
 
     bool GetApplicationInfo(
-        const std::string &appName, const ApplicationFlag flag, const int userId, ApplicationInfo &appInfo) override;
+        const std::string& appName, const ApplicationFlag flag, const int userId, ApplicationInfo& appInfo) override;
 
-    bool GetBundleInfo(const std::string &bundleName,
-        const BundleFlag flag, BundleInfo &bundleInfo, int32_t userId) override
+    bool GetBundleInfo(const std::string& bundleName,
+        const BundleFlag flag, BundleInfo& bundleInfo, int32_t userId) override
     {
         return true;
     }
-    std::string GetAppType(const std::string &bundleName) override;
-    bool QueryAbilityInfo(const Want &want, AbilityInfo &abilityInfo) override;
-    bool GetHapModuleInfo(const AbilityInfo &abilityInfo, HapModuleInfo &hapModuleInfo) override;
+    std::string GetAppType(const std::string& bundleName) override;
+    bool QueryAbilityInfo(const Want& want, AbilityInfo& abilityInfo) override;
+    bool GetHapModuleInfo(const AbilityInfo& abilityInfo, HapModuleInfo& hapModuleInfo) override;
     bool GetHapModuleInfo(
-        const AbilityInfo &abilityInfo, int32_t userId, HapModuleInfo &hapModuleInfo) override;
+        const AbilityInfo& abilityInfo, int32_t userId, HapModuleInfo& hapModuleInfo) override;
 
-    bool ImplicitQueryInfoByPriority(const Want &want, int32_t flags, int32_t userId,
-        AbilityInfo &abilityInfo, ExtensionAbilityInfo &extensionInfo) override
+    bool ImplicitQueryInfoByPriority(const Want& want, int32_t flags, int32_t userId,
+        AbilityInfo& abilityInfo, ExtensionAbilityInfo& extensionInfo) override
     {
         abilityInfo.name = "MainAbility";
         abilityInfo.bundleName = "com.ohos.launcher";
@@ -60,15 +60,15 @@ public:
 class BundleMgrStub : public IRemoteStub<IBundleMgr> {
 public:
     int OnRemoteRequest(
-        uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
+        uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override;
 };
 
 class BundleMgrService : public BundleMgrStub {
 public:
     bool GetApplicationInfo(
-        const std::string &appName, const ApplicationFlag flag, const int userId, ApplicationInfo &appInfo) override;
-    bool GetBundleInfo(const std::string &bundleName,
-        const BundleFlag flag, BundleInfo &bundleInfo, int32_t userId) override
+        const std::string& appName, const ApplicationFlag flag, const int userId, ApplicationInfo& appInfo) override;
+    bool GetBundleInfo(const std::string& bundleName,
+        const BundleFlag flag, BundleInfo& bundleInfo, int32_t userId) override
     {
         if (bundleName == "test_contextImpl") {
             bundleInfo.name = "test_contextImpl";
@@ -79,11 +79,11 @@ public:
         }
         return true;
     }
-    std::string GetAppType(const std::string &bundleName) override;
-    bool QueryAbilityInfo(const Want &want, AbilityInfo &abilityInfo) override;
-    bool GetHapModuleInfo(const AbilityInfo &abilityInfo, HapModuleInfo &hapModuleInfo) override;
+    std::string GetAppType(const std::string& bundleName) override;
+    bool QueryAbilityInfo(const Want& want, AbilityInfo& abilityInfo) override;
+    bool GetHapModuleInfo(const AbilityInfo& abilityInfo, HapModuleInfo& hapModuleInfo) override;
     bool GetHapModuleInfo(
-        const AbilityInfo &abilityInfo, int32_t userId, HapModuleInfo &hapModuleInfo) override;
+        const AbilityInfo& abilityInfo, int32_t userId, HapModuleInfo& hapModuleInfo) override;
 };
 }  // namespace AppExecFwk
 }  // namespace OHOS

test/mock/frameworks_kits_ability_native_test/include/mock_bundle_manager_form.cpp

@@ -31,12 +31,12 @@ const std::string PARAM_FORM_NAME = "com.form.name.test";
 const std::string DEVICE_ID = "ohos-phone1";
 
 bool BundleMgrProxy::GetBundleInfo(
-    const std::string &bundleName, const BundleFlag flag, BundleInfo &bundleInfo, int32_t userId)
+    const std::string& bundleName, const BundleFlag flag, BundleInfo& bundleInfo, int32_t userId)
 {
     return true;
 }
 
-int BundleMgrService::GetUidByBundleName(const std::string &bundleName, const int userId)
+int BundleMgrService::GetUidByBundleName(const std::string& bundleName, const int userId)
 {
     if (bundleName.compare("com.form.host.app600") == 0) {
         return 600;
@@ -45,25 +45,25 @@ int BundleMgrService::GetUidByBundleName(const std::string &bundleName, const in
 }
 
 bool BundleMgrProxy::GetFormsInfoByModule(
-    const std::string &bundleName,
-    const std::string &moduleName,
-    std::vector<FormInfo> &formInfo)
+    const std::string& bundleName,
+    const std::string& moduleName,
+    std::vector<FormInfo>& formInfo)
 {
     return true;
 }
 
-int BundleMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
+int BundleMgrStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
 {
     return 0;
 }
 
-std::string BundleMgrService::GetAppType(const std::string &bundleName)
+std::string BundleMgrService::GetAppType(const std::string& bundleName)
 {
     return "system";
 }
 
 bool BundleMgrService::GetBundleInfo(
-    const std::string &bundleName, const BundleFlag flag, BundleInfo &bundleInfo, int32_t userId)
+    const std::string& bundleName, const BundleFlag flag, BundleInfo& bundleInfo, int32_t userId)
 {
     std::vector<AbilityInfo> abilityInfos;
     ApplicationInfo applicationInfo;
@@ -88,7 +88,7 @@ bool BundleMgrService::GetBundleInfo(
     return true;
 }
 
-bool BundleMgrService::GetAllFormsInfo(std::vector<FormInfo> &formInfo)
+bool BundleMgrService::GetAllFormsInfo(std::vector<FormInfo>& formInfo)
 {
     FormInfo form;
     form.abilityName = FORM_PROVIDER_ABILITY_NAME;
@@ -99,12 +99,12 @@ bool BundleMgrService::GetAllFormsInfo(std::vector<FormInfo> &formInfo)
     form.scheduledUpdateTime = "06:06";
     form.jsComponentName = FORM_JS_COMPOMENT_NAME;
     form.formVisibleNotify = true;
-    form.supportDimensions = {1, 2};
+    form.supportDimensions = { 1, 2 };
     form.defaultDimension = 1;
     formInfo.emplace_back(form);
     return true;
 }
-bool BundleMgrService::GetFormsInfoByApp(const std::string &bundleName, std::vector<FormInfo> &formInfo)
+bool BundleMgrService::GetFormsInfoByApp(const std::string& bundleName, std::vector<FormInfo>& formInfo)
 {
     FormInfo form;
     form.bundleName = bundleName;
@@ -116,15 +116,15 @@ bool BundleMgrService::GetFormsInfoByApp(const std::string &bundleName, std::vec
     form.scheduledUpdateTime = "06:06";
     form.jsComponentName = FORM_JS_COMPOMENT_NAME;
     form.formVisibleNotify = true;
-    form.supportDimensions = {1, 2};
+    form.supportDimensions = { 1, 2 };
     form.defaultDimension = 1;
     formInfo.emplace_back(form);
     return true;
 }
 bool BundleMgrService::GetFormsInfoByModule(
-    const std::string &bundleName,
-    const std::string &moduleName,
-    std::vector<FormInfo> &formInfo)
+    const std::string& bundleName,
+    const std::string& moduleName,
+    std::vector<FormInfo>& formInfo)
 {
     FormInfo form;
     form.bundleName = bundleName;
@@ -136,7 +136,7 @@ bool BundleMgrService::GetFormsInfoByModule(
     form.scheduledUpdateTime = "06:06";
     form.jsComponentName = FORM_JS_COMPOMENT_NAME;
     form.formVisibleNotify = true;
-    form.supportDimensions = {1, 2};
+    form.supportDimensions = { 1, 2 };
     form.defaultDimension = 1;
     formInfo.emplace_back(form);
     return true;

test/mock/frameworks_kits_ability_native_test/include/mock_bundle_manager_form.h

@@ -32,17 +32,17 @@ const int32_t ERROR_USER_ID_U256 = 256;
 const int32_t USER_ID_U600 = 600;
 class BundleMgrProxy : public IRemoteProxy<IBundleMgr> {
 public:
-    explicit BundleMgrProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IBundleMgr>(impl)
+    explicit BundleMgrProxy(const sptr<IRemoteObject>& impl) : IRemoteProxy<IBundleMgr>(impl)
     {}
     virtual ~BundleMgrProxy()
     {}
 
-    std::string GetAppType(const std::string &bundleName) override
+    std::string GetAppType(const std::string& bundleName) override
     {
         return "system";
     }
 
-    int GetUidByBundleName(const std::string &bundleName, const int userId) override
+    int GetUidByBundleName(const std::string& bundleName, const int userId) override
     {
         if (bundleName.compare("com.form.host.app600") == 0) {
             return USER_ID_U600;
@@ -50,7 +50,7 @@ public:
         return 0;
     }
 
-    bool GetBundleNameForUid(const int uid, std::string &bundleName) override
+    bool GetBundleNameForUid(const int uid, std::string& bundleName) override
     {
         bundleName = "com.form.provider.service";
         return true;
@@ -65,31 +65,31 @@ public:
     }
 
     bool GetBundleInfo(
-        const std::string &bundleName, const BundleFlag flag, BundleInfo &bundleInfo, int32_t userId) override;
-    bool GetAllFormsInfo(std::vector<FormInfo> &formInfo) override;
-    bool GetFormsInfoByApp(const std::string &bundleName, std::vector<FormInfo> &formInfo) override;
+        const std::string& bundleName, const BundleFlag flag, BundleInfo& bundleInfo, int32_t userId) override;
+    bool GetAllFormsInfo(std::vector<FormInfo>& formInfo) override;
+    bool GetFormsInfoByApp(const std::string& bundleName, std::vector<FormInfo>& formInfo) override;
     bool GetFormsInfoByModule(
-        const std::string &bundleName,
-        const std::string &moduleName,
-        std::vector<FormInfo> &formInfo) override;
+        const std::string& bundleName,
+        const std::string& moduleName,
+        std::vector<FormInfo>& formInfo) override;
 };
 
 class BundleMgrStub : public IRemoteStub<IBundleMgr> {
 public:
     ~BundleMgrStub() = default;
     int OnRemoteRequest(
-        uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
+        uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override;
 };
 
 class BundleMgrService : public BundleMgrStub {
 public:
     ~BundleMgrService() = default;
 
-    std::string GetAppType(const std::string &bundleName) override;
-    int GetUidByBundleName(const std::string &bundleName, const int userId) override;
+    std::string GetAppType(const std::string& bundleName) override;
+    int GetUidByBundleName(const std::string& bundleName, const int userId) override;
     bool GetBundleInfo(
-        const std::string &bundleName, const BundleFlag flag, BundleInfo &bundleInfo, int32_t userId) override;
-    bool GetBundleNameForUid(const int uid, std::string &bundleName) override
+        const std::string& bundleName, const BundleFlag flag, BundleInfo& bundleInfo, int32_t userId) override;
+    bool GetBundleNameForUid(const int uid, std::string& bundleName) override
     {
         bundleName = "com.form.provider.service";
         return true;
@@ -102,12 +102,12 @@ public:
 
         return true;
     }
-    bool GetAllFormsInfo(std::vector<FormInfo> &formInfo) override;
-    bool GetFormsInfoByApp(const std::string &bundleName, std::vector<FormInfo> &formInfo) override;
+    bool GetAllFormsInfo(std::vector<FormInfo>& formInfo) override;
+    bool GetFormsInfoByApp(const std::string& bundleName, std::vector<FormInfo>& formInfo) override;
     bool GetFormsInfoByModule(
-        const std::string &bundleName,
-        const std::string &moduleName,
-        std::vector<FormInfo> &formInfo) override;
+        const std::string& bundleName,
+        const std::string& moduleName,
+        std::vector<FormInfo>& formInfo) override;
 };
 }  // namespace AppExecFwk
 }  // namespace OHOS

test/mock/frameworks_kits_ability_native_test/include/mock_continuation_ability.h

@@ -35,7 +35,7 @@ public:
         return true;
     }
 
-    bool OnSaveData(WantParams &saveData)
+    bool OnSaveData(WantParams& saveData)
     {
         GTEST_LOG_(INFO) << "MockContinuationAbility::OnSaveData called";
         return true;

test/mock/frameworks_kits_ability_native_test/include/mock_data_ability.h

@@ -34,50 +34,50 @@ public:
 
     enum Event { ON_ACTIVE = 0, ON_BACKGROUND, ON_FOREGROUND, ON_INACTIVE, ON_START, ON_STOP, UNDEFINED };
 
-    virtual int OpenFile(const Uri &uri, const std::string &mode)
+    virtual int OpenFile(const Uri& uri, const std::string& mode)
     {
         GTEST_LOG_(INFO) << "MockDataAbility::OpenFile called";
 
         return 1;
     }
 
-    virtual int Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
+    virtual int Insert(const Uri& uri, const NativeRdb::ValuesBucket& value)
     {
         GTEST_LOG_(INFO) << "MockDataAbility::Insert called";
 
         return 1;
     }
 
-    virtual int Update(const Uri &uri, const NativeRdb::ValuesBucket &value,
-        const NativeRdb::DataAbilityPredicates &predicates)
+    virtual int Update(const Uri& uri, const NativeRdb::ValuesBucket& value,
+        const NativeRdb::DataAbilityPredicates& predicates)
     {
         GTEST_LOG_(INFO) << "MockDataAbility::Update called";
 
         return 1;
     }
 
-    virtual int Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
+    virtual int Delete(const Uri& uri, const NativeRdb::DataAbilityPredicates& predicates)
     {
         GTEST_LOG_(INFO) << "MockDataAbility::Delete called";
 
         return 1;
     }
 
-    virtual int OpenRawFile(const Uri &uri, const std::string &mode)
+    virtual int OpenRawFile(const Uri& uri, const std::string& mode)
     {
         GTEST_LOG_(INFO) << "MockDataAbility::OpenRawFile called";
 
         return 1;
     }
 
-    virtual bool Reload(const Uri &uri, const PacMap &extras)
+    virtual bool Reload(const Uri& uri, const PacMap& extras)
     {
         GTEST_LOG_(INFO) << "MockDataAbility::Reload called";
 
         return 1;
     }
 
-    virtual int BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values)
+    virtual int BatchInsert(const Uri& uri, const std::vector<NativeRdb::ValuesBucket>& values)
     {
         GTEST_LOG_(INFO) << "MockDataAbility::BatchInsert called";
 
@@ -85,7 +85,7 @@ public:
     }
 
     virtual std::shared_ptr<NativeRdb::AbsSharedResultSet> Query(
-        const Uri &uri, const std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
+        const Uri& uri, const std::vector<std::string>& columns, const NativeRdb::DataAbilityPredicates& predicates)
     {
         GTEST_LOG_(INFO) << "MockDataAbility::Query called";
         std::shared_ptr<NativeRdb::AbsSharedResultSet> set = std::make_shared<NativeRdb::AbsSharedResultSet>(
@@ -93,14 +93,14 @@ public:
         return set;
     }
 
-    virtual std::vector<std::string> GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
+    virtual std::vector<std::string> GetFileTypes(const Uri& uri, const std::string& mimeTypeFilter)
     {
         GTEST_LOG_(INFO) << "MockDataAbility::GetFileTypes called";
         value.push_back(mimeTypeFilter);
         return value;
     }
 
-    virtual std::string GetType(const Uri &uri)
+    virtual std::string GetType(const Uri& uri)
     {
         GTEST_LOG_(INFO) << "MockDataAbility::GetType called";
         std::string value("Type1");

test/mock/frameworks_kits_ability_native_test/include/mock_data_ability_impl.cpp

@@ -27,12 +27,12 @@ const int returnValueDelete = 44;
 
 namespace OHOS {
 namespace AppExecFwk {
-void DataAbilityImpl::HandleAbilityTransaction(const Want &want, const AAFwk::LifeCycleStateInfo &targetState)
+void DataAbilityImpl::HandleAbilityTransaction(const Want& want, const AAFwk::LifeCycleStateInfo& targetState)
 {
     GTEST_LOG_(INFO) << "Mock DataAbilityImpl::HandleAbilityTransaction called";
 }
 
-std::vector<std::string> DataAbilityImpl::GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
+std::vector<std::string> DataAbilityImpl::GetFileTypes(const Uri& uri, const std::string& mimeTypeFilter)
 {
     GTEST_LOG_(INFO) << "Mock DataAbilityImpl::GetFileTypes called";
     std::vector<std::string> types;
@@ -42,33 +42,33 @@ std::vector<std::string> DataAbilityImpl::GetFileTypes(const Uri &uri, const std
     return types;
 }
 
-int DataAbilityImpl::OpenFile(const Uri &uri, const std::string &mode)
+int DataAbilityImpl::OpenFile(const Uri& uri, const std::string& mode)
 {
     GTEST_LOG_(INFO) << "Mock DataAbilityImpl::OpenFile called";
     return returnValueOpenfile;
 }
 
-int DataAbilityImpl::Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
+int DataAbilityImpl::Insert(const Uri& uri, const NativeRdb::ValuesBucket& value)
 {
     GTEST_LOG_(INFO) << "Mock DataAbilityImpl::Insert called";
     return returnValueInsert;
 }
 
-int DataAbilityImpl::Update(const Uri &uri,
-    const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates)
+int DataAbilityImpl::Update(const Uri& uri,
+    const NativeRdb::ValuesBucket& value, const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "Mock DataAbilityImpl::Update called";
     return returnValueUpdate;
 }
 
-int DataAbilityImpl::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
+int DataAbilityImpl::Delete(const Uri& uri, const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "Mock DataAbilityImpl::Delete called";
     return returnValueDelete;
 }
 
 std::shared_ptr<NativeRdb::AbsSharedResultSet> DataAbilityImpl::Query(
-    const Uri &uri, std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
+    const Uri& uri, std::vector<std::string>& columns, const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "Mock DataAbilityImpl::Query called";
     std::shared_ptr<NativeRdb::AbsSharedResultSet> resultSet = std::make_shared<NativeRdb::AbsSharedResultSet>(
@@ -76,7 +76,7 @@ std::shared_ptr<NativeRdb::AbsSharedResultSet> DataAbilityImpl::Query(
     return resultSet;
 }
 
-std::string DataAbilityImpl::GetType(const Uri &uri)
+std::string DataAbilityImpl::GetType(const Uri& uri)
 {
     GTEST_LOG_(INFO) << "Mock DataAbilityImpl::GetType called";
     std::string type("type");

test/mock/frameworks_kits_ability_native_test/include/mock_form_mgr_service.h

@@ -65,7 +65,7 @@ public:
      * @param formInfo Form info.
      * @return Returns ERR_OK on success, others on failure.
      */
-    int AddForm(const int64_t formId, const Want &want, const sptr<IRemoteObject> &callerToken, FormJsInfo &formInfo)
+    int AddForm(const int64_t formId, const Want& want, const sptr<IRemoteObject>& callerToken, FormJsInfo& formInfo)
     {
         if (formId == 300L) {
             formInfo.formId = formId;
@@ -79,7 +79,7 @@ public:
      * @param callerToken Caller ability token.
      * @return Returns ERR_OK on success, others on failure.
      */
-    int DeleteForm(const int64_t formId, const sptr<IRemoteObject> &callerToken)
+    int DeleteForm(const int64_t formId, const sptr<IRemoteObject>& callerToken)
     {
         return 0;
     }
@@ -91,7 +91,7 @@ public:
      * @param delCache Delete Cache or not.
      * @return Returns ERR_OK on success, others on failure.
      */
-    int ReleaseForm(const int64_t formId, const sptr<IRemoteObject> &callerToken, const bool delCache)
+    int ReleaseForm(const int64_t formId, const sptr<IRemoteObject>& callerToken, const bool delCache)
     {
         return 0;
     }
@@ -117,7 +117,7 @@ public:
      * @param want The want of the form to add.
      * @return Returns ERR_OK on success, others on failure.
      */
-    int RequestForm(const int64_t formId, const sptr<IRemoteObject> &callerToken, const Want &want)
+    int RequestForm(const int64_t formId, const sptr<IRemoteObject>& callerToken, const Want& want)
     {
         return 0;
     }
@@ -129,8 +129,8 @@ public:
      * @return Returns ERR_OK on success, others on failure.
      */
     int NotifyWhetherVisibleForms(
-        const std::vector<int64_t> &formIds,
-        const sptr<IRemoteObject> &callerToken,
+        const std::vector<int64_t>& formIds,
+        const sptr<IRemoteObject>& callerToken,
         const int32_t formVisibleType)
     {
         if (formIds.size() == 1) {
@@ -145,7 +145,7 @@ public:
      * @param callerToken Caller ability token.
      * @return Returns ERR_OK on success, others on failure.
      */
-    int CastTempForm(const int64_t formId, const sptr<IRemoteObject> &callerToken)
+    int CastTempForm(const int64_t formId, const sptr<IRemoteObject>& callerToken)
     {
         if (formId == 175L)return 0;
         return 1;
@@ -167,7 +167,7 @@ public:
      * @param formInfos Form infos.
      * @return Returns ERR_OK on success, others on failure.
      */
-    int DumpFormInfoByBundleName(const std::string &bundleName, std::string &formInfos)
+    int DumpFormInfoByBundleName(const std::string& bundleName, std::string& formInfos)
     {
         return 0;
     }
@@ -178,7 +178,7 @@ public:
      * @param formInfo Form info.
      * @return Returns ERR_OK on success, others on failure.
      */
-    int DumpFormInfoByFormId(const std::int64_t formId, std::string &formInfo)
+    int DumpFormInfoByFormId(const std::int64_t formId, std::string& formInfo)
     {
         return 0;
     }
@@ -206,8 +206,8 @@ public:
      * @return Returns ERR_OK on success, others on failure.
      */
     int LifecycleUpdate(
-        const std::vector<int64_t> &formIds,
-        const sptr<IRemoteObject> &callerToken,
+        const std::vector<int64_t>& formIds,
+        const sptr<IRemoteObject>& callerToken,
         const int32_t updateType)
     {
         if (formIds.size() == 0) {
@@ -223,7 +223,7 @@ public:
      * @param callerToken Caller ability token.
      * @return Returns true if execute success, false otherwise.
      */
-    int MessageEvent(const int64_t formId, const Want &want, const sptr<IRemoteObject> &callerToken)
+    int MessageEvent(const int64_t formId, const Want& want, const sptr<IRemoteObject>& callerToken)
     {
         return 0;
     }

test/mock/frameworks_kits_ability_native_test/include/mock_form_supply_callback.cpp

@@ -38,7 +38,7 @@ sptr<MockFormSupplyCallback> MockFormSupplyCallback::GetInstance()
  * @param formInfo Form Provider Info.
  * @param want data
  */
-int MockFormSupplyCallback::OnAcquire(const FormProviderInfo &formProviderInfo, const Want& want)
+int MockFormSupplyCallback::OnAcquire(const FormProviderInfo& formProviderInfo, const Want& want)
 {
     HILOG_INFO("MockFormSupplyCallback::OnAcquire called.");
     return 1;
@@ -64,15 +64,15 @@ int MockFormSupplyCallback::OnEventHandle(const Want& want)
  * @param wantArg The want of onAcquireFormState.
  * @param want input data
  */
-int MockFormSupplyCallback::OnAcquireStateResult(FormState state, const std::string &provider, const Want &wantArg,
-                                                 const Want &want)
+int MockFormSupplyCallback::OnAcquireStateResult(FormState state, const std::string& provider, const Want& wantArg,
+    const Want& want)
 {
     HILOG_INFO("MockFormSupplyCallback::OnAcquireStateResult called.");
     return 1;
 }
 
-void MockFormSupplyCallback::OnShareAcquire(int64_t formId, const std::string &remoteDeviceId,
-    const AAFwk::WantParams &wantParams, int64_t requestCode, const bool &result)
+void MockFormSupplyCallback::OnShareAcquire(int64_t formId, const std::string& remoteDeviceId,
+    const AAFwk::WantParams& wantParams, int64_t requestCode, const bool& result)
 {
     HILOG_INFO("MockFormSupplyCallback::OnShareAcquire called.");
 }

test/mock/frameworks_kits_ability_native_test/include/mock_form_supply_callback.h

@@ -36,7 +36,7 @@ public:
      * @param providerFormInfo providerFormInfo
      * @param want data
      */
-    int OnAcquire(const FormProviderInfo &formInfo, const Want& want) override;
+    int OnAcquire(const FormProviderInfo& formInfo, const Want& want) override;
 
     /**
      * onEventHandle
@@ -53,11 +53,11 @@ public:
      * @param wantArg The want of onAcquireFormState.
      * @param want input data
      */
-    int OnAcquireStateResult(FormState state, const std::string &provider, const Want &wantArg,
-                                     const Want &want) override;
+    int OnAcquireStateResult(FormState state, const std::string& provider, const Want& wantArg,
+        const Want& want) override;
 
-    void OnShareAcquire(int64_t formId, const std::string &remoteDeviceId,
-        const AAFwk::WantParams &wantParams, int64_t requestCode, const bool &result) override;
+    void OnShareAcquire(int64_t formId, const std::string& remoteDeviceId,
+        const AAFwk::WantParams& wantParams, int64_t requestCode, const bool& result) override;
 
 private:
     static std::mutex mutex;

test/mock/frameworks_kits_ability_native_test/include/mock_lifecycle_observer.h

@@ -59,7 +59,7 @@ public:
      *
      * @param want Indicates the startup information.
      */
-    virtual void OnStart(const Want &want)
+    virtual void OnStart(const Want& want)
     {
         (void)want;
         GTEST_LOG_(INFO) << "MockLifecycleObserver::OnStart called";
@@ -83,7 +83,7 @@ public:
      * @param event Indicates the lifecycle event.
      * @param want Indicates the state change information.
      */
-    virtual void OnStateChanged(LifeCycle::Event event, const Want &want)
+    virtual void OnStateChanged(LifeCycle::Event event, const Want& want)
     {
         (void)event;
         (void)want;
@@ -123,7 +123,7 @@ public:
      *
      * @param want Indicates the information for the ability or ability slice to go back to the ACTIVE state.
      */
-    virtual void OnForeground(const Want &want)
+    virtual void OnForeground(const Want& want)
     {
         (void)want;
         GTEST_LOG_(INFO) << "MockLifecycleObserver::OnForeground called";

test/mock/frameworks_kits_ability_native_test/include/mock_new_ability.h

@@ -28,13 +28,13 @@ public:
     MockNewAbility() = default;
     virtual ~MockNewAbility() = default;
 
-    void OnNewWant(const Want &want)
+    void OnNewWant(const Want& want)
     {
         GTEST_LOG_(INFO) << "MockNewAbility::OnNewWant called";
         onNewWantCalled_ = true;
     }
 
-    void ContinuationRestore(const Want &want)
+    void ContinuationRestore(const Want& want)
     {
         GTEST_LOG_(INFO) << "Mock Ability::ContinuationRestore called";
         continueRestoreCalled_ = true;

test/mock/frameworks_kits_ability_native_test/include/mock_page_ability.h

@@ -45,19 +45,19 @@ public:
         GTEST_LOG_(INFO) << "MockPageAbility::OnTouchEvent called";
     }
 
-    void OnAbilityResult(int requestCode, int resultCode, const AAFwk::Want &resultData)
+    void OnAbilityResult(int requestCode, int resultCode, const AAFwk::Want& resultData)
     {
         GTEST_LOG_(INFO) << "MockPageAbility::OnAbilityResult called";
         state_ = ON_ACTIVE;
     }
 
-    void OnNewWant(const Want &want)
+    void OnNewWant(const Want& want)
     {
         onNewWantCalled_ = true;
         GTEST_LOG_(INFO) << "MockPageAbility::OnNewWant called";
     }
 
-    void OnStart(const Want &want)
+    void OnStart(const Want& want)
     {
         GTEST_LOG_(INFO) << "MockPageAbility::OnStart called";
         state_ = ON_START;
@@ -81,7 +81,7 @@ public:
         state_ = ON_INACTIVE;
     }
 
-    void OnForeground(const Want &want)
+    void OnForeground(const Want& want)
     {
         GTEST_LOG_(INFO) << "MockPageAbility::OnForeground called";
         state_ = ON_FOREGROUND;
@@ -93,41 +93,41 @@ public:
         state_ = ON_BACKGROUND;
     }
 
-    sptr<IRemoteObject> OnConnect(const Want &want)
+    sptr<IRemoteObject> OnConnect(const Want& want)
     {
         GTEST_LOG_(INFO) << "MockPageAbility::OnConnect called";
         state_ = ON_ACTIVE;
         return nullptr;
     }
 
-    void OnCommand(const AAFwk::Want &want, bool restart, int startId)
+    void OnCommand(const AAFwk::Want& want, bool restart, int startId)
     {
         GTEST_LOG_(INFO) << "MockPageAbility::OnBackground called";
         state_ = ON_ACTIVE;
     }
 
-    int OpenFile(const Uri &uri, const std::string &mode)
+    int OpenFile(const Uri& uri, const std::string& mode)
     {
         GTEST_LOG_(INFO) << "MockPageAbility::OpenFile called";
         state_ = ON_ACTIVE;
         return 1;
     }
 
-    int Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
+    int Insert(const Uri& uri, const NativeRdb::ValuesBucket& value)
     {
         GTEST_LOG_(INFO) << "MockPageAbility::Insert called";
         state_ = ON_ACTIVE;
         return -1;
     }
 
-    int Update(const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates)
+    int Update(const Uri& uri, const NativeRdb::ValuesBucket& value, const NativeRdb::DataAbilityPredicates& predicates)
     {
         GTEST_LOG_(INFO) << "MockPageAbility::Update called";
         state_ = ON_ACTIVE;
         return -1;
     }
 
-    int Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
+    int Delete(const Uri& uri, const NativeRdb::DataAbilityPredicates& predicates)
     {
         GTEST_LOG_(INFO) << "MockPageAbility::Delete called";
         state_ = ON_ACTIVE;
@@ -135,14 +135,14 @@ public:
     }
 
     std::shared_ptr<NativeRdb::AbsSharedResultSet> Query(
-        const Uri &uri, const std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
+        const Uri& uri, const std::vector<std::string>& columns, const NativeRdb::DataAbilityPredicates& predicates)
     {
         GTEST_LOG_(INFO) << "MockPageAbility::Query called";
         state_ = ON_ACTIVE;
         return nullptr;
     }
 
-    std::vector<std::string> GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
+    std::vector<std::string> GetFileTypes(const Uri& uri, const std::string& mimeTypeFilter)
     {
         GTEST_LOG_(INFO) << "MockPageAbility::GetFileTypes called";
 
@@ -150,23 +150,23 @@ public:
         return value;
     }
 
-    void OnRestoreAbilityState(const PacMap &inState)
+    void OnRestoreAbilityState(const PacMap& inState)
     {
         GTEST_LOG_(INFO) << "Mock Ability::OnRestoreAbilityState called";
     }
 
-    void OnSaveAbilityState(PacMap &outState)
+    void OnSaveAbilityState(PacMap& outState)
     {
         GTEST_LOG_(INFO) << "Mock Ability::OnSaveAbilityState called";
     }
 
-    void OnConfigurationUpdated(const Configuration &config)
+    void OnConfigurationUpdated(const Configuration& config)
     {
         GTEST_LOG_(INFO) << "Mock Ability::OnConfigurationUpdated called";
         OnConfigurationUpdated_++;
     }
 
-    void ContinuationRestore(const Want &want)
+    void ContinuationRestore(const Want& want)
     {
         GTEST_LOG_(INFO) << "Mock Ability::ContinuationRestore called";
         continueRestoreCalled_ = true;

test/mock/frameworks_kits_ability_native_test/include/mock_replace_ability_impl.cpp

@@ -21,9 +21,9 @@
 
 namespace OHOS {
 namespace AppExecFwk {
-void AbilityImpl::Init(std::shared_ptr<OHOSApplication> &application, const std::shared_ptr<AbilityLocalRecord> &record,
-    std::shared_ptr<Ability> &ability, std::shared_ptr<AbilityHandler> &handler, const sptr<IRemoteObject> &token,
-    std::shared_ptr<ContextDeal> &contextDeal)
+void AbilityImpl::Init(std::shared_ptr<OHOSApplication>& application, const std::shared_ptr<AbilityLocalRecord>& record,
+    std::shared_ptr<Ability>& ability, std::shared_ptr<AbilityHandler>& handler, const sptr<IRemoteObject>& token,
+    std::shared_ptr<ContextDeal>& contextDeal)
 {
     HILOG_INFO("AbilityImpl::init begin");
 
@@ -67,7 +67,7 @@ void AbilityImpl::Init(std::shared_ptr<OHOSApplication> &application, const std:
     HILOG_INFO("AbilityImpl::init end");
 }
 
-void AbilityImpl::Start(const Want &want)
+void AbilityImpl::Start(const Want& want)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::Start called";
 }
@@ -92,28 +92,28 @@ void AbilityImpl::DispatchSaveAbilityState()
     GTEST_LOG_(INFO) << "Mock AbilityImpl::DispatchSaveAbilityState called";
 }
 
-void AbilityImpl::DispatchRestoreAbilityState(const PacMap &inState)
+void AbilityImpl::DispatchRestoreAbilityState(const PacMap& inState)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::DispatchRestoreAbilityState called";
 }
 
-void AbilityImpl::HandleAbilityTransaction(const Want &want, const AAFwk::LifeCycleStateInfo &targetState)
+void AbilityImpl::HandleAbilityTransaction(const Want& want, const AAFwk::LifeCycleStateInfo& targetState)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::HandleAbilityTransaction called";
 }
 
-sptr<IRemoteObject> AbilityImpl::ConnectAbility(const Want &want)
+sptr<IRemoteObject> AbilityImpl::ConnectAbility(const Want& want)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::ConnectAbility called";
     return nullptr;
 }
 
-void AbilityImpl::DisconnectAbility(const Want &want)
+void AbilityImpl::DisconnectAbility(const Want& want)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::DisconnectAbility called";
 }
 
-void AbilityImpl::CommandAbility(const Want &want, bool restart, int startId)
+void AbilityImpl::CommandAbility(const Want& want, bool restart, int startId)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::CommandAbility called";
 }
@@ -123,12 +123,12 @@ int AbilityImpl::GetCurrentState()
     return lifecycleState_;
 }
 
-void AbilityImpl::SendResult(int requestCode, int resultCode, const Want &resultData)
+void AbilityImpl::SendResult(int requestCode, int resultCode, const Want& resultData)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::SendResult called";
 }
 
-void AbilityImpl::NewWant(const Want &want)
+void AbilityImpl::NewWant(const Want& want)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::NewWant called";
     if (ability_ == nullptr) {
@@ -142,7 +142,7 @@ void AbilityImpl::NewWant(const Want &want)
 #endif
 }
 
-std::vector<std::string> AbilityImpl::GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
+std::vector<std::string> AbilityImpl::GetFileTypes(const Uri& uri, const std::string& mimeTypeFilter)
 {
     std::vector<std::string> value;
     value.push_back(mimeTypeFilter);
@@ -150,46 +150,46 @@ std::vector<std::string> AbilityImpl::GetFileTypes(const Uri &uri, const std::st
     return value;
 }
 
-int AbilityImpl::OpenFile(const Uri &uri, const std::string &mode)
+int AbilityImpl::OpenFile(const Uri& uri, const std::string& mode)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::OpenFile called";
     return 1;
 }
 
-int AbilityImpl::Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
+int AbilityImpl::Insert(const Uri& uri, const NativeRdb::ValuesBucket& value)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::Insert called";
     return 1;
 }
 
-int AbilityImpl::Update(const Uri &uri, const NativeRdb::ValuesBucket &value,
-    const NativeRdb::DataAbilityPredicates &predicates)
+int AbilityImpl::Update(const Uri& uri, const NativeRdb::ValuesBucket& value,
+    const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::Update called";
     return 1;
 }
 
-int AbilityImpl::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
+int AbilityImpl::Delete(const Uri& uri, const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::Delete called";
     return 1;
 }
 
 std::shared_ptr<NativeRdb::AbsSharedResultSet> AbilityImpl::Query(
-    const Uri &uri, std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
+    const Uri& uri, std::vector<std::string>& columns, const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::Query called";
     return nullptr;
 }
 
-std::string AbilityImpl::GetType(const Uri &uri)
+std::string AbilityImpl::GetType(const Uri& uri)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::GetType called";
     return "";
 }
 
 #ifdef SUPPORT_GRAPHICS
-void AbilityImpl::Foreground(const Want &want)
+void AbilityImpl::Foreground(const Want& want)
 {
     GTEST_LOG_(INFO) << "Mock AbilityImpl::Foreground called";
 }

test/mock/frameworks_kits_ability_native_test/include/mock_resourceManager_interface1.cpp

@@ -31,19 +31,19 @@ public:
     ResourceManagerTestInstance() {};
     ~ResourceManagerTestInstance() override {};
 
-    bool AddResource(const char *path) override
+    bool AddResource(const char* path) override
     {
         return false;
     };
 
-    virtual RState UpdateResConfig(ResConfig &resConfig)
+    virtual RState UpdateResConfig(ResConfig& resConfig)
     {
         return ERROR;
     };
 
-    virtual void GetResConfig(ResConfig &resConfig) {};
+    virtual void GetResConfig(ResConfig& resConfig) {};
 
-    virtual RState GetStringById(uint32_t id, std::string &outValue)
+    virtual RState GetStringById(uint32_t id, std::string& outValue)
     {
         auto iter = StringById_.find(id);
         if (iter == StringById_.end()) {
@@ -52,7 +52,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    void SetStringById(uint32_t id, std::string &inValue) override
+    void SetStringById(uint32_t id, std::string& inValue) override
     {
         if (!StringById_.empty()) {
             StringById_.clear();
@@ -60,23 +60,23 @@ public:
         StringById_[id] = inValue;
     };
 
-    virtual RState GetStringByName(const char *name, std::string &outValue)
+    virtual RState GetStringByName(const char* name, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetStringFormatById(std::string &outValue, uint32_t id, ...)
+    virtual RState GetStringFormatById(std::string& outValue, uint32_t id, ...)
     {
         return ERROR;
     };
-    void SetStringFormatById(std::string &inValue, uint32_t id, ...) override {};
+    void SetStringFormatById(std::string& inValue, uint32_t id, ...) override {};
 
-    virtual RState GetStringFormatByName(std::string &outValue, const char *name, ...)
+    virtual RState GetStringFormatByName(std::string& outValue, const char* name, ...)
     {
         return ERROR;
     };
 
-    virtual RState GetStringArrayById(uint32_t id, std::vector<std::string> &outValue)
+    virtual RState GetStringArrayById(uint32_t id, std::vector<std::string>& outValue)
     {
         auto iter = StringArrayById_.find(id);
         if (iter == StringArrayById_.end()) {
@@ -85,7 +85,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    virtual void SetStringArrayById(uint32_t id, std::vector<std::string> &inValue)
+    virtual void SetStringArrayById(uint32_t id, std::vector<std::string>& inValue)
     {
         if (!StringArrayById_.empty()) {
             StringArrayById_.clear();
@@ -93,12 +93,12 @@ public:
         StringArrayById_[id] = inValue;
     };
 
-    virtual RState GetStringArrayByName(const char *name, std::vector<std::string> &outValue)
+    virtual RState GetStringArrayByName(const char* name, std::vector<std::string>& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetPatternById(uint32_t id, std::map<std::string, std::string> &outValue)
+    virtual RState GetPatternById(uint32_t id, std::map<std::string, std::string>& outValue)
     {
         auto iter = PatternById_.find(id);
         if (iter == PatternById_.end()) {
@@ -107,7 +107,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    virtual void SetPatternById(uint32_t id, std::map<std::string, std::string> &inValue)
+    virtual void SetPatternById(uint32_t id, std::map<std::string, std::string>& inValue)
     {
         if (!PatternById_.empty()) {
             PatternById_.clear();
@@ -115,32 +115,32 @@ public:
         PatternById_[id] = inValue;
     };
 
-    virtual RState GetPatternByName(const char *name, std::map<std::string, std::string> &outValue)
+    virtual RState GetPatternByName(const char* name, std::map<std::string, std::string>& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetPluralStringById(uint32_t id, int quantity, std::string &outValue)
+    virtual RState GetPluralStringById(uint32_t id, int quantity, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetPluralStringByName(const char *name, int quantity, std::string &outValue)
+    virtual RState GetPluralStringByName(const char* name, int quantity, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetPluralStringByIdFormat(std::string &outValue, uint32_t id, int quantity, ...)
+    virtual RState GetPluralStringByIdFormat(std::string& outValue, uint32_t id, int quantity, ...)
     {
         return ERROR;
     };
 
-    virtual RState GetPluralStringByNameFormat(std::string &outValue, const char *name, int quantity, ...)
+    virtual RState GetPluralStringByNameFormat(std::string& outValue, const char* name, int quantity, ...)
     {
         return ERROR;
     };
 
-    virtual RState GetThemeById(uint32_t id, std::map<std::string, std::string> &outValue)
+    virtual RState GetThemeById(uint32_t id, std::map<std::string, std::string>& outValue)
     {
         auto iter = ThemeById_.find(id);
         if (iter == ThemeById_.end()) {
@@ -149,7 +149,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    virtual void SetThemeById(uint32_t id, std::map<std::string, std::string> &inValue)
+    virtual void SetThemeById(uint32_t id, std::map<std::string, std::string>& inValue)
     {
         if (!ThemeById_.empty()) {
             ThemeById_.clear();
@@ -157,42 +157,42 @@ public:
         ThemeById_[id] = inValue;
     };
 
-    virtual RState GetThemeByName(const char *name, std::map<std::string, std::string> &outValue)
+    virtual RState GetThemeByName(const char* name, std::map<std::string, std::string>& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetBooleanById(uint32_t id, bool &outValue)
+    virtual RState GetBooleanById(uint32_t id, bool& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetBooleanByName(const char *name, bool &outValue)
+    virtual RState GetBooleanByName(const char* name, bool& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetIntegerById(uint32_t id, int &outValue)
+    virtual RState GetIntegerById(uint32_t id, int& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetIntegerByName(const char *name, int &outValue)
+    virtual RState GetIntegerByName(const char* name, int& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetFloatById(uint32_t id, float &outValue)
+    virtual RState GetFloatById(uint32_t id, float& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetFloatByName(const char *name, float &outValue)
+    virtual RState GetFloatByName(const char* name, float& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetIntArrayById(uint32_t id, std::vector<int> &outValue)
+    virtual RState GetIntArrayById(uint32_t id, std::vector<int>& outValue)
     {
         auto iter = IntArrayById_.find(id);
         if (iter == IntArrayById_.end()) {
@@ -201,7 +201,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    virtual void SetIntArrayById(uint32_t id, std::vector<int> &inValue)
+    virtual void SetIntArrayById(uint32_t id, std::vector<int>& inValue)
     {
         if (!IntArrayById_.empty()) {
             IntArrayById_.clear();
@@ -209,12 +209,12 @@ public:
         IntArrayById_[id] = inValue;
     };
 
-    virtual RState GetIntArrayByName(const char *name, std::vector<int> &outValue)
+    virtual RState GetIntArrayByName(const char* name, std::vector<int>& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetColorById(uint32_t id, uint32_t &outValue)
+    virtual RState GetColorById(uint32_t id, uint32_t& outValue)
     {
         auto iter = ColorById_.find(id);
         if (iter == ColorById_.end()) {
@@ -223,7 +223,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    void SetColorById(uint32_t id, uint32_t &inValue) override
+    void SetColorById(uint32_t id, uint32_t& inValue) override
     {
         if (!ColorById_.empty()) {
             ColorById_.clear();
@@ -231,27 +231,27 @@ public:
         ColorById_[id] = inValue;
     };
 
-    virtual RState GetColorByName(const char *name, uint32_t &outValue)
+    virtual RState GetColorByName(const char* name, uint32_t& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetProfileById(uint32_t id, std::string &outValue)
+    virtual RState GetProfileById(uint32_t id, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetProfileByName(const char *name, std::string &outValue)
+    virtual RState GetProfileByName(const char* name, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetMediaById(uint32_t id, std::string &outValue)
+    virtual RState GetMediaById(uint32_t id, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetMediaByName(const char *name, std::string &outValue)
+    virtual RState GetMediaByName(const char* name, std::string& outValue)
     {
         return ERROR;
     };

test/mock/frameworks_kits_ability_native_test/include/mock_resourceManager_interface1.h

@@ -30,74 +30,74 @@ public:
     ResourceManager2() {};
     virtual ~ResourceManager2() {};
 
-    virtual bool AddResource(const char *path) = 0;
+    virtual bool AddResource(const char* path) = 0;
 
-    virtual RState UpdateResConfig(ResConfig &resConfig) = 0;
+    virtual RState UpdateResConfig(ResConfig& resConfig) = 0;
 
-    virtual void GetResConfig(ResConfig &resConfig) = 0;
+    virtual void GetResConfig(ResConfig& resConfig) = 0;
 
-    virtual RState GetStringById(uint32_t id, std::string &outValue) = 0;
-    virtual void SetStringById(uint32_t id, std::string &outValue) = 0;
+    virtual RState GetStringById(uint32_t id, std::string& outValue) = 0;
+    virtual void SetStringById(uint32_t id, std::string& outValue) = 0;
 
-    virtual RState GetStringByName(const char *name, std::string &outValue) = 0;
+    virtual RState GetStringByName(const char* name, std::string& outValue) = 0;
 
-    virtual RState GetStringFormatById(std::string &outValue, uint32_t id, ...) = 0;
-    virtual void SetStringFormatById(std::string &outValue, uint32_t id, ...) = 0;
+    virtual RState GetStringFormatById(std::string& outValue, uint32_t id, ...) = 0;
+    virtual void SetStringFormatById(std::string& outValue, uint32_t id, ...) = 0;
 
-    virtual RState GetStringFormatByName(std::string &outValue, const char *name, ...) = 0;
+    virtual RState GetStringFormatByName(std::string& outValue, const char* name, ...) = 0;
 
-    virtual RState GetStringArrayById(uint32_t id, std::vector<std::string> &outValue) = 0;
-    virtual void SetStringArrayById(uint32_t id, std::vector<std::string> &outValue) = 0;
+    virtual RState GetStringArrayById(uint32_t id, std::vector<std::string>& outValue) = 0;
+    virtual void SetStringArrayById(uint32_t id, std::vector<std::string>& outValue) = 0;
 
-    virtual RState GetStringArrayByName(const char *name, std::vector<std::string> &outValue) = 0;
+    virtual RState GetStringArrayByName(const char* name, std::vector<std::string>& outValue) = 0;
 
-    virtual RState GetPatternById(uint32_t id, std::map<std::string, std::string> &outValue) = 0;
-    virtual void SetPatternById(uint32_t id, std::map<std::string, std::string> &outValue) = 0;
+    virtual RState GetPatternById(uint32_t id, std::map<std::string, std::string>& outValue) = 0;
+    virtual void SetPatternById(uint32_t id, std::map<std::string, std::string>& outValue) = 0;
 
-    virtual RState GetPatternByName(const char *name, std::map<std::string, std::string> &outValue) = 0;
+    virtual RState GetPatternByName(const char* name, std::map<std::string, std::string>& outValue) = 0;
 
-    virtual RState GetPluralStringById(uint32_t id, int quantity, std::string &outValue) = 0;
+    virtual RState GetPluralStringById(uint32_t id, int quantity, std::string& outValue) = 0;
 
-    virtual RState GetPluralStringByName(const char *name, int quantity, std::string &outValue) = 0;
+    virtual RState GetPluralStringByName(const char* name, int quantity, std::string& outValue) = 0;
 
-    virtual RState GetPluralStringByIdFormat(std::string &outValue, uint32_t id, int quantity, ...) = 0;
+    virtual RState GetPluralStringByIdFormat(std::string& outValue, uint32_t id, int quantity, ...) = 0;
 
-    virtual RState GetPluralStringByNameFormat(std::string &outValue, const char *name, int quantity, ...) = 0;
+    virtual RState GetPluralStringByNameFormat(std::string& outValue, const char* name, int quantity, ...) = 0;
 
-    virtual RState GetThemeById(uint32_t id, std::map<std::string, std::string> &outValue) = 0;
-    virtual void SetThemeById(uint32_t id, std::map<std::string, std::string> &outValue) = 0;
+    virtual RState GetThemeById(uint32_t id, std::map<std::string, std::string>& outValue) = 0;
+    virtual void SetThemeById(uint32_t id, std::map<std::string, std::string>& outValue) = 0;
 
-    virtual RState GetThemeByName(const char *name, std::map<std::string, std::string> &outValue) = 0;
+    virtual RState GetThemeByName(const char* name, std::map<std::string, std::string>& outValue) = 0;
 
-    virtual RState GetBooleanById(uint32_t id, bool &outValue) = 0;
+    virtual RState GetBooleanById(uint32_t id, bool& outValue) = 0;
 
-    virtual RState GetBooleanByName(const char *name, bool &outValue) = 0;
+    virtual RState GetBooleanByName(const char* name, bool& outValue) = 0;
 
-    virtual RState GetIntegerById(uint32_t id, int &outValue) = 0;
+    virtual RState GetIntegerById(uint32_t id, int& outValue) = 0;
 
-    virtual RState GetIntegerByName(const char *name, int &outValue) = 0;
+    virtual RState GetIntegerByName(const char* name, int& outValue) = 0;
 
-    virtual RState GetFloatById(uint32_t id, float &outValue) = 0;
+    virtual RState GetFloatById(uint32_t id, float& outValue) = 0;
 
-    virtual RState GetFloatByName(const char *name, float &outValue) = 0;
+    virtual RState GetFloatByName(const char* name, float& outValue) = 0;
 
-    virtual RState GetIntArrayById(uint32_t id, std::vector<int> &outValue) = 0;
-    virtual void SetIntArrayById(uint32_t id, std::vector<int> &outValue) = 0;
+    virtual RState GetIntArrayById(uint32_t id, std::vector<int>& outValue) = 0;
+    virtual void SetIntArrayById(uint32_t id, std::vector<int>& outValue) = 0;
 
-    virtual RState GetIntArrayByName(const char *name, std::vector<int> &outValue) = 0;
+    virtual RState GetIntArrayByName(const char* name, std::vector<int>& outValue) = 0;
 
-    virtual RState GetColorById(uint32_t id, uint32_t &outValue) = 0;
-    virtual void SetColorById(uint32_t id, uint32_t &outValue) = 0;
+    virtual RState GetColorById(uint32_t id, uint32_t& outValue) = 0;
+    virtual void SetColorById(uint32_t id, uint32_t& outValue) = 0;
 
-    virtual RState GetColorByName(const char *name, uint32_t &outValue) = 0;
+    virtual RState GetColorByName(const char* name, uint32_t& outValue) = 0;
 
-    virtual RState GetProfileById(uint32_t id, std::string &outValue) = 0;
+    virtual RState GetProfileById(uint32_t id, std::string& outValue) = 0;
 
-    virtual RState GetProfileByName(const char *name, std::string &outValue) = 0;
+    virtual RState GetProfileByName(const char* name, std::string& outValue) = 0;
 
-    virtual RState GetMediaById(uint32_t id, std::string &outValue) = 0;
+    virtual RState GetMediaById(uint32_t id, std::string& outValue) = 0;
 
-    virtual RState GetMediaByName(const char *name, std::string &outValue) = 0;
+    virtual RState GetMediaByName(const char* name, std::string& outValue) = 0;
 };
 
 std::shared_ptr<ResourceManager2> CreateResourceManager2();

test/mock/frameworks_kits_ability_native_test/include/mock_service_ability.h

@@ -43,12 +43,12 @@ public:
         GTEST_LOG_(INFO) << "MockServiceAbility::OnTouchEvent called";
     }
 
-    void OnAbilityResult(int requestCode, int resultCode, const AAFwk::Want &resultData)
+    void OnAbilityResult(int requestCode, int resultCode, const AAFwk::Want& resultData)
     {
         GTEST_LOG_(INFO) << "MockServiceAbility::OnAbilityResult called";
     }
 
-    void OnNewWant(const Want &want)
+    void OnNewWant(const Want& want)
     {
         GTEST_LOG_(INFO) << "MockServiceAbility::OnNewWant called";
     }
@@ -63,7 +63,7 @@ public:
         GTEST_LOG_(INFO) << "MockServiceAbility::OnStop called";
     }
 
-    void OnStart(const Want &want)
+    void OnStart(const Want& want)
     {
         GTEST_LOG_(INFO) << "MockServiceAbility::OnStart called";
     }

test/mock/frameworks_kits_appkit_native_test/ability_delegator/mock_ability_delegator_stub.cpp

@@ -26,28 +26,28 @@ bool MockAbilityDelegatorStub::finishFlag_ = false;
 MockAbilityDelegatorStub::MockAbilityDelegatorStub()
 {}
 
-int MockAbilityDelegatorStub::StartAbility(const Want &want, int32_t userId, int requestCode)
+int MockAbilityDelegatorStub::StartAbility(const Want& want, int32_t userId, int requestCode)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub::CloseAbility(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+int MockAbilityDelegatorStub::CloseAbility(const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub::StartAbility(const Want &want, const StartOptions &startOptions,
-    const sptr<IRemoteObject> &callerToken, int requestCode, int32_t userId)
+int MockAbilityDelegatorStub::StartAbility(const Want& want, const StartOptions& startOptions,
+    const sptr<IRemoteObject>& callerToken, int requestCode, int32_t userId)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub::MinimizeAbility(const sptr<IRemoteObject> &token, bool fromUser)
+int MockAbilityDelegatorStub::MinimizeAbility(const sptr<IRemoteObject>& token, bool fromUser)
 {
     return 0;
 }
 
-void MockAbilityDelegatorStub::DumpState(const std::string &args, std::vector<std::string> &state)
+void MockAbilityDelegatorStub::DumpState(const std::string& args, std::vector<std::string>& state)
 {
     return;
 }
@@ -57,7 +57,7 @@ int MockAbilityDelegatorStub::StartUser(int userId)
     return 0;
 }
 
-int MockAbilityDelegatorStub::StopUser(int userId, const sptr<IStopUserCallback> &callback)
+int MockAbilityDelegatorStub::StopUser(int userId, const sptr<IStopUserCallback>& callback)
 {
     return 0;
 }
@@ -72,26 +72,26 @@ int MockAbilityDelegatorStub::StopSyncRemoteMissions(const std::string& devId)
     return 0;
 }
 
-int MockAbilityDelegatorStub::RegisterMissionListener(const std::string &deviceId,
-    const sptr<IRemoteMissionListener> &listener)
+int MockAbilityDelegatorStub::RegisterMissionListener(const std::string& deviceId,
+    const sptr<IRemoteMissionListener>& listener)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub::UnRegisterMissionListener(const std::string &deviceId,
-    const sptr<IRemoteMissionListener> &listener)
+int MockAbilityDelegatorStub::UnRegisterMissionListener(const std::string& deviceId,
+    const sptr<IRemoteMissionListener>& listener)
 {
     return 0;
 }
 
 int MockAbilityDelegatorStub::StartAbilityByCall(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub::ReleaseCall(const sptr<IAbilityConnection> &connect,
-    const AppExecFwk::ElementName &element)
+int MockAbilityDelegatorStub::ReleaseCall(const sptr<IAbilityConnection>& connect,
+    const AppExecFwk::ElementName& element)
 {
     return 0;
 }
@@ -117,7 +117,7 @@ int MockAbilityDelegatorStub::SendANRProcessID(int pid)
     return 0;
 }
 
-int MockAbilityDelegatorStub::SetAbilityController(const sptr<AppExecFwk::IAbilityController> &abilityController,
+int MockAbilityDelegatorStub::SetAbilityController(const sptr<AppExecFwk::IAbilityController>& abilityController,
     bool imAStabilityTest)
 {
     return 0;
@@ -134,7 +134,7 @@ void MockAbilityDelegatorStub::DumpSysState(
     return;
 }
 
-int MockAbilityDelegatorStub::StartUserTest(const Want &want, const sptr<IRemoteObject> &observer)
+int MockAbilityDelegatorStub::StartUserTest(const Want& want, const sptr<IRemoteObject>& observer)
 {
     if (want.GetStringParam("-p") == STRING_BUNDLENAME_EX) {
         return ERR_INVALID_VALUE;
@@ -142,49 +142,49 @@ int MockAbilityDelegatorStub::StartUserTest(const Want &want, const sptr<IRemote
     return OHOS::ERR_OK;
 }
 
-int MockAbilityDelegatorStub::StopServiceAbility(const Want &want, int32_t userId)
+int MockAbilityDelegatorStub::StopServiceAbility(const Want& want, int32_t userId)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub::GetTopAbility(sptr<IRemoteObject> &token)
+int MockAbilityDelegatorStub::GetTopAbility(sptr<IRemoteObject>& token)
 {
     HILOG_INFO("MockAbilityDelegatorStub::GetTopAbility is called");
     token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
     return OHOS::ERR_OK;
 }
 
-int MockAbilityDelegatorStub::DelegatorDoAbilityForeground(const sptr<IRemoteObject> &token)
+int MockAbilityDelegatorStub::DelegatorDoAbilityForeground(const sptr<IRemoteObject>& token)
 {
     HILOG_INFO("MockAbilityDelegatorStub::DelegatorDoAbilityForeground is called");
     return OHOS::ERR_OK;
 }
 
-int MockAbilityDelegatorStub::DelegatorDoAbilityBackground(const sptr<IRemoteObject> &token)
+int MockAbilityDelegatorStub::DelegatorDoAbilityBackground(const sptr<IRemoteObject>& token)
 {
     HILOG_INFO("MockAbilityDelegatorStub::DelegatorDoAbilityBackground is called");
     return OHOS::ERR_OK;
 }
 
-int MockAbilityDelegatorStub::FinishUserTest(const std::string &msg,
-    const int64_t &resultCode, const std::string &bundleName)
+int MockAbilityDelegatorStub::FinishUserTest(const std::string& msg,
+    const int64_t& resultCode, const std::string& bundleName)
 {
     HILOG_INFO("MockAbilityDelegatorStub::FinishUserTest is called");
     finishFlag_ = true;
     return OHOS::ERR_OK;
 }
 
-int MockAbilityDelegatorStub::DoAbilityForeground(const sptr<IRemoteObject> &token, uint32_t flag)
+int MockAbilityDelegatorStub::DoAbilityForeground(const sptr<IRemoteObject>& token, uint32_t flag)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub::DoAbilityBackground(const sptr<IRemoteObject> &token, uint32_t flag)
+int MockAbilityDelegatorStub::DoAbilityBackground(const sptr<IRemoteObject>& token, uint32_t flag)
 {
     return 0;
 }
 
-int32_t MockAbilityDelegatorStub::GetMissionIdByToken(const sptr<IRemoteObject> &token)
+int32_t MockAbilityDelegatorStub::GetMissionIdByToken(const sptr<IRemoteObject>& token)
 {
     return 0;
 }
@@ -209,33 +209,33 @@ bool MockAbilityDelegatorStub2::finishFlag_ = false;
 MockAbilityDelegatorStub2::MockAbilityDelegatorStub2()
 {}
 
-int MockAbilityDelegatorStub2::StartAbility(const Want &want, int32_t userId, int requestCode)
+int MockAbilityDelegatorStub2::StartAbility(const Want& want, int32_t userId, int requestCode)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub2::StartAbility(const Want &want, const StartOptions &startOptions,
-    const sptr<IRemoteObject> &callerToken, int requestCode, int32_t userId)
+int MockAbilityDelegatorStub2::StartAbility(const Want& want, const StartOptions& startOptions,
+    const sptr<IRemoteObject>& callerToken, int requestCode, int32_t userId)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub2::CloseAbility(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+int MockAbilityDelegatorStub2::CloseAbility(const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub2::MinimizeAbility(const sptr<IRemoteObject> &token, bool fromUser)
+int MockAbilityDelegatorStub2::MinimizeAbility(const sptr<IRemoteObject>& token, bool fromUser)
 {
     return 0;
 }
 
-void MockAbilityDelegatorStub2::DumpState(const std::string &args, std::vector<std::string> &state)
+void MockAbilityDelegatorStub2::DumpState(const std::string& args, std::vector<std::string>& state)
 {
     return;
 }
 
-int MockAbilityDelegatorStub2::StopServiceAbility(const Want &want, int32_t userId)
+int MockAbilityDelegatorStub2::StopServiceAbility(const Want& want, int32_t userId)
 {
     return 0;
 }
@@ -245,7 +245,7 @@ int MockAbilityDelegatorStub2::StartUser(int userId)
     return 0;
 }
 
-int MockAbilityDelegatorStub2::StopUser(int userId, const sptr<IStopUserCallback> &callback)
+int MockAbilityDelegatorStub2::StopUser(int userId, const sptr<IStopUserCallback>& callback)
 {
     return 0;
 }
@@ -260,25 +260,25 @@ int MockAbilityDelegatorStub2::StopSyncRemoteMissions(const std::string& devId)
     return 0;
 }
 
-int MockAbilityDelegatorStub2::RegisterMissionListener(const std::string &deviceId,
-    const sptr<IRemoteMissionListener> &listener)
+int MockAbilityDelegatorStub2::RegisterMissionListener(const std::string& deviceId,
+    const sptr<IRemoteMissionListener>& listener)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub2::UnRegisterMissionListener(const std::string &deviceId,
-    const sptr<IRemoteMissionListener> &listener)
+int MockAbilityDelegatorStub2::UnRegisterMissionListener(const std::string& deviceId,
+    const sptr<IRemoteMissionListener>& listener)
 {
     return 0;
 }
 
 int MockAbilityDelegatorStub2::StartAbilityByCall(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken)
 {
     return 0;
 }
-int MockAbilityDelegatorStub2::ReleaseCall(const sptr<IAbilityConnection> &connect,
-    const AppExecFwk::ElementName &element)
+int MockAbilityDelegatorStub2::ReleaseCall(const sptr<IAbilityConnection>& connect,
+    const AppExecFwk::ElementName& element)
 {
     return 0;
 }
@@ -304,7 +304,7 @@ int MockAbilityDelegatorStub2::SendANRProcessID(int pid)
     return 0;
 }
 
-int MockAbilityDelegatorStub2::SetAbilityController(const sptr<AppExecFwk::IAbilityController> &abilityController,
+int MockAbilityDelegatorStub2::SetAbilityController(const sptr<AppExecFwk::IAbilityController>& abilityController,
     bool imAStabilityTest)
 {
     return 0;
@@ -321,7 +321,7 @@ void MockAbilityDelegatorStub2::DumpSysState(
     return;
 }
 
-int MockAbilityDelegatorStub2::StartUserTest(const Want &want, const sptr<IRemoteObject> &observer)
+int MockAbilityDelegatorStub2::StartUserTest(const Want& want, const sptr<IRemoteObject>& observer)
 {
     if (want.GetStringParam("-p") == STRING_BUNDLENAME_EX) {
         return ERR_INVALID_VALUE;
@@ -329,43 +329,43 @@ int MockAbilityDelegatorStub2::StartUserTest(const Want &want, const sptr<IRemot
     return OHOS::ERR_OK;
 }
 
-int MockAbilityDelegatorStub2::GetTopAbility(sptr<IRemoteObject> &token)
+int MockAbilityDelegatorStub2::GetTopAbility(sptr<IRemoteObject>& token)
 {
     HILOG_INFO("MockAbilityDelegatorStub2::GetTopAbility is called");
     return OHOS::ERR_INVALID_VALUE;
 }
 
-int MockAbilityDelegatorStub2::DelegatorDoAbilityForeground(const sptr<IRemoteObject> &token)
+int MockAbilityDelegatorStub2::DelegatorDoAbilityForeground(const sptr<IRemoteObject>& token)
 {
     HILOG_INFO("MockAbilityDelegatorStub2::DelegatorDoAbilityForeground is called");
     return OHOS::ERR_INVALID_VALUE;
 }
 
-int MockAbilityDelegatorStub2::DelegatorDoAbilityBackground(const sptr<IRemoteObject> &token)
+int MockAbilityDelegatorStub2::DelegatorDoAbilityBackground(const sptr<IRemoteObject>& token)
 {
     HILOG_INFO("MockAbilityDelegatorStub2::DelegatorDoAbilityBackground is called");
     return OHOS::ERR_INVALID_VALUE;
 }
 
-int MockAbilityDelegatorStub2::FinishUserTest(const std::string &msg,
-    const int64_t &resultCode, const std::string &bundleName)
+int MockAbilityDelegatorStub2::FinishUserTest(const std::string& msg,
+    const int64_t& resultCode, const std::string& bundleName)
 {
     HILOG_INFO("MockAbilityDelegatorStub2::FinishUserTest is called");
     finishFlag_ = false;
     return OHOS::ERR_INVALID_VALUE;
 }
 
-int MockAbilityDelegatorStub2::DoAbilityForeground(const sptr<IRemoteObject> &token, uint32_t flag)
+int MockAbilityDelegatorStub2::DoAbilityForeground(const sptr<IRemoteObject>& token, uint32_t flag)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub2::DoAbilityBackground(const sptr<IRemoteObject> &token, uint32_t flag)
+int MockAbilityDelegatorStub2::DoAbilityBackground(const sptr<IRemoteObject>& token, uint32_t flag)
 {
     return 0;
 }
 
-int32_t MockAbilityDelegatorStub2::GetMissionIdByToken(const sptr<IRemoteObject> &token)
+int32_t MockAbilityDelegatorStub2::GetMissionIdByToken(const sptr<IRemoteObject>& token)
 {
     return 0;
 }
@@ -386,12 +386,12 @@ int MockAbilityDelegatorStub2::BlockAppService()
 }
 
 #ifdef ABILITY_COMMAND_FOR_TEST
-int MockAbilityDelegatorStub::ForceTimeoutForTest(const std::string &abilityName, const std::string &state)
+int MockAbilityDelegatorStub::ForceTimeoutForTest(const std::string& abilityName, const std::string& state)
 {
     return 0;
 }
 
-int MockAbilityDelegatorStub2::ForceTimeoutForTest(const std::string &abilityName, const std::string &state)
+int MockAbilityDelegatorStub2::ForceTimeoutForTest(const std::string& abilityName, const std::string& state)
 {
     return 0;
 }
@@ -399,7 +399,7 @@ int MockAbilityDelegatorStub2::ForceTimeoutForTest(const std::string &abilityNam
 
 #ifdef SUPPORT_GRAPHICS
 int MockAbilityDelegatorStub::SetMissionIcon(
-    const sptr<IRemoteObject> &token, const std::shared_ptr<OHOS::Media::PixelMap> &icon)
+    const sptr<IRemoteObject>& token, const std::shared_ptr<OHOS::Media::PixelMap>& icon)
 {
     return 0;
 }
@@ -410,7 +410,7 @@ int MockAbilityDelegatorStub::RegisterWindowManagerServiceHandler(const sptr<IWi
 }
 
 int MockAbilityDelegatorStub2::SetMissionIcon(
-    const sptr<IRemoteObject> &token, const std::shared_ptr<OHOS::Media::PixelMap> &icon)
+    const sptr<IRemoteObject>& token, const std::shared_ptr<OHOS::Media::PixelMap>& icon)
 {
     return 0;
 }

test/mock/frameworks_kits_appkit_native_test/ability_delegator/mock_ability_delegator_stub.h

@@ -28,133 +28,133 @@ namespace AAFwk {
 class MockAbilityDelegatorStub : public AbilityManagerStub {
 public:
     MockAbilityDelegatorStub();
-    int StartAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE,
+    int StartAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE,
         int requestCode = DEFAULT_INVAL_VALUE) override;
-    MOCK_METHOD4(StartAbility, int(const Want &want, const sptr<IRemoteObject> &callerToken,
+    MOCK_METHOD4(StartAbility, int(const Want& want, const sptr<IRemoteObject>& callerToken,
         int32_t userId, int requestCode));
-    MOCK_METHOD5(StartAbility, int(const Want &want, const AbilityStartSetting &abilityStartSetting,
-        const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode));
-    int StartAbility(const Want &want, const StartOptions &startOptions,
-        const sptr<IRemoteObject> &callerToken, int requestCode = DEFAULT_INVAL_VALUE,
+    MOCK_METHOD5(StartAbility, int(const Want& want, const AbilityStartSetting& abilityStartSetting,
+        const sptr<IRemoteObject>& callerToken, int32_t userId, int requestCode));
+    int StartAbility(const Want& want, const StartOptions& startOptions,
+        const sptr<IRemoteObject>& callerToken, int requestCode = DEFAULT_INVAL_VALUE,
         int32_t userId = DEFAULT_INVAL_VALUE) override;
-    MOCK_METHOD3(TerminateAbility, int(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant));
-    MOCK_METHOD2(TerminateAbility, int(const sptr<IRemoteObject> &callerToken, int requestCode));
-    int CloseAbility(const sptr<IRemoteObject> &token, int resultCode = DEFAULT_INVAL_VALUE,
-        const Want *resultWant = nullptr) override;
-    int MinimizeAbility(const sptr<IRemoteObject> &token, bool fromUser = false) override;
-    MOCK_METHOD4(ConnectAbility, int(const Want &want, const sptr<IAbilityConnection> &connect,
-        const sptr<IRemoteObject> &callerToken, int32_t userId));
-    MOCK_METHOD1(DisconnectAbility, int(const sptr<IAbilityConnection> &connect));
+    MOCK_METHOD3(TerminateAbility, int(const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant));
+    MOCK_METHOD2(TerminateAbility, int(const sptr<IRemoteObject>& callerToken, int requestCode));
+    int CloseAbility(const sptr<IRemoteObject>& token, int resultCode = DEFAULT_INVAL_VALUE,
+        const Want* resultWant = nullptr) override;
+    int MinimizeAbility(const sptr<IRemoteObject>& token, bool fromUser = false) override;
+    MOCK_METHOD4(ConnectAbility, int(const Want& want, const sptr<IAbilityConnection>& connect,
+        const sptr<IRemoteObject>& callerToken, int32_t userId));
+    MOCK_METHOD1(DisconnectAbility, int(const sptr<IAbilityConnection>& connect));
     MOCK_METHOD3(AcquireDataAbility,
-        sptr<IAbilityScheduler>(const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken));
+        sptr<IAbilityScheduler>(const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken));
     MOCK_METHOD2(
-        ReleaseDataAbility, int(sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken));
-    MOCK_METHOD2(AddWindowInfo, void(const sptr<IRemoteObject> &token, int32_t windowToken));
-    MOCK_METHOD2(AttachAbilityThread, int(const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token));
-    MOCK_METHOD3(AbilityTransitionDone, int(const sptr<IRemoteObject> &token, int state, const PacMap &));
+        ReleaseDataAbility, int(sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken));
+    MOCK_METHOD2(AddWindowInfo, void(const sptr<IRemoteObject>& token, int32_t windowToken));
+    MOCK_METHOD2(AttachAbilityThread, int(const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token));
+    MOCK_METHOD3(AbilityTransitionDone, int(const sptr<IRemoteObject>& token, int state, const PacMap&));
     MOCK_METHOD2(
-        ScheduleConnectAbilityDone, int(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject));
-    MOCK_METHOD1(ScheduleDisconnectAbilityDone, int(const sptr<IRemoteObject> &token));
-    MOCK_METHOD1(ScheduleCommandAbilityDone, int(const sptr<IRemoteObject> &token));
-    void DumpState(const std::string &args, std::vector<std::string> &state) override;
-    MOCK_METHOD2(TerminateAbilityResult, int(const sptr<IRemoteObject> &token, int startId));
-    int StopServiceAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE) override;
-    MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr<IRemoteObject> &callerToken, int requestCode));
+        ScheduleConnectAbilityDone, int(const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject));
+    MOCK_METHOD1(ScheduleDisconnectAbilityDone, int(const sptr<IRemoteObject>& token));
+    MOCK_METHOD1(ScheduleCommandAbilityDone, int(const sptr<IRemoteObject>& token));
+    void DumpState(const std::string& args, std::vector<std::string>& state) override;
+    MOCK_METHOD2(TerminateAbilityResult, int(const sptr<IRemoteObject>& token, int startId));
+    int StopServiceAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE) override;
+    MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr<IRemoteObject>& callerToken, int requestCode));
     MOCK_METHOD1(MoveMissionToTop, int(int32_t missionId));
     MOCK_METHOD1(RemoveMission, int(int id));
     MOCK_METHOD1(RemoveStack, int(int id));
-    MOCK_METHOD1(KillProcess, int(const std::string &bundleName));
-    MOCK_METHOD2(UninstallApp, int(const std::string &bundleName, int32_t uid));
-    MOCK_METHOD2(MoveMissionToEnd, int(const sptr<IRemoteObject> &token, const bool nonFirst));
-    MOCK_METHOD1(IsFirstInMission, bool(const sptr<IRemoteObject> &token));
-    MOCK_METHOD4(CompelVerifyPermission, int(const std::string &permission, int pid, int uid, std::string &message));
+    MOCK_METHOD1(KillProcess, int(const std::string& bundleName));
+    MOCK_METHOD2(UninstallApp, int(const std::string& bundleName, int32_t uid));
+    MOCK_METHOD2(MoveMissionToEnd, int(const sptr<IRemoteObject>& token, const bool nonFirst));
+    MOCK_METHOD1(IsFirstInMission, bool(const sptr<IRemoteObject>& token));
+    MOCK_METHOD4(CompelVerifyPermission, int(const std::string& permission, int pid, int uid, std::string& message));
     MOCK_METHOD2(
-        GetWantSender, sptr<IWantSender>(const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken));
-    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender> &target, const SenderInfo &senderInfo));
-    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender> &sender));
-    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender> &target));
-    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender> &target, std::shared_ptr<Want> &want));
+        GetWantSender, sptr<IWantSender>(const WantSenderInfo& wantSenderInfo, const sptr<IRemoteObject>& callerToken));
+    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender>& target, const SenderInfo& senderInfo));
+    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender>& sender));
+    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender>& target));
+    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender>& target, std::shared_ptr<Want>& want));
     MOCK_METHOD1(LockMission, int(int));
     MOCK_METHOD1(UnlockMission, int(int));
     MOCK_METHOD0(GetMissionLockModeState, int());
     MOCK_METHOD2(
-        ChangeFocusAbility, int(const sptr<IRemoteObject> &lostFocusToken, const sptr<IRemoteObject> &getFocusToken));
+        ChangeFocusAbility, int(const sptr<IRemoteObject>& lostFocusToken, const sptr<IRemoteObject>& getFocusToken));
     MOCK_METHOD1(MinimizeMultiWindow, int(int missionId));
     MOCK_METHOD1(MaximizeMultiWindow, int(int missionId));
     MOCK_METHOD1(CloseMultiWindow, int(int missionId));
     MOCK_METHOD1(GetPendinTerminateAbilityTestgRequestWant, void(int id));
     MOCK_METHOD1(SetShowOnLockScreen, int(bool isAllow));
-    MOCK_METHOD3(StartContinuation, int(const Want &want, const sptr<IRemoteObject> &abilityToken, int32_t status));
+    MOCK_METHOD3(StartContinuation, int(const Want& want, const sptr<IRemoteObject>& abilityToken, int32_t status));
     MOCK_METHOD2(NotifyContinuationResult, int(int32_t missionId, int32_t result));
-    MOCK_METHOD5(ContinueMission, int(const std::string &srcDeviceId, const std::string &dstDeviceId,
-        int32_t missionId, const sptr<IRemoteObject> &callBack, AAFwk::WantParams &wantParams));
-    MOCK_METHOD3(ContinueAbility, int(const std::string &deviceId, int32_t missionId, uint32_t versionCode));
-    MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string &deviceId, int32_t sessionId, bool isSuccess));
+    MOCK_METHOD5(ContinueMission, int(const std::string& srcDeviceId, const std::string& dstDeviceId,
+        int32_t missionId, const sptr<IRemoteObject>& callBack, AAFwk::WantParams& wantParams));
+    MOCK_METHOD3(ContinueAbility, int(const std::string& deviceId, int32_t missionId, uint32_t versionCode));
+    MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string& deviceId, int32_t sessionId, bool isSuccess));
     MOCK_METHOD1(LockMissionForCleanup, int(int32_t missionId));
     MOCK_METHOD1(UnlockMissionForCleanup, int(int32_t missionId));
-    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener> &listener));
-    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener> &listener));
+    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener>& listener));
+    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener>& listener));
     MOCK_METHOD3(
-        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo> &missionInfos));
-    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo &missionInfo));
+        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo>& missionInfos));
+    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo& missionInfo));
     MOCK_METHOD1(CleanMission, int(int32_t missionId));
     MOCK_METHOD0(CleanAllMissions, int());
     MOCK_METHOD1(MoveMissionToFront, int(int32_t missionId));
-    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions &startOptions));
-    MOCK_METHOD1(ClearUpApplicationData, int(const std::string &));
-    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo> &info));
-    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo> &info));
-    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo> &info));
-    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender> &target, std::shared_ptr<WantSenderInfo> &info));
+    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions& startOptions));
+    MOCK_METHOD1(ClearUpApplicationData, int(const std::string&));
+    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo>& info));
+    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo>& info));
+    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo>& info));
+    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender>& target, std::shared_ptr<WantSenderInfo>& info));
     int StartUser(int userId) override;
-    int StopUser(int userId, const sptr<IStopUserCallback> &callback) override;
+    int StopUser(int userId, const sptr<IStopUserCallback>& callback) override;
     int StartSyncRemoteMissions(const std::string& devId, bool fixConflict, int64_t tag) override;
     int StopSyncRemoteMissions(const std::string& devId) override;
-    int RegisterMissionListener(const std::string &deviceId,
-        const sptr<IRemoteMissionListener> &listener) override;
-    int UnRegisterMissionListener(const std::string &deviceId,
-        const sptr<IRemoteMissionListener> &listener) override;
+    int RegisterMissionListener(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener) override;
+    int UnRegisterMissionListener(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener) override;
     int StartAbilityByCall(
-        const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken) override;
-    int ReleaseCall(const sptr<IAbilityConnection> &connect,
-        const AppExecFwk::ElementName &element) override;
+        const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken) override;
+    int ReleaseCall(const sptr<IAbilityConnection>& connect,
+        const AppExecFwk::ElementName& element) override;
     int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
         MissionSnapshot& snapshot, bool isLowResolution) override;
     void UpdateMissionSnapShot(const sptr<IRemoteObject>& token) override;
     int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler) override;
     int SendANRProcessID(int pid) override;
-    int SetAbilityController(const sptr<AppExecFwk::IAbilityController> &abilityController,
+    int SetAbilityController(const sptr<AppExecFwk::IAbilityController>& abilityController,
         bool imAStabilityTest) override;
     bool IsRunningInStabilityTest() override;
     void DumpSysState(
         const std::string& args, std::vector<std::string>& info, bool isClient, bool isUserID, int UserID) override;
-    int StartUserTest(const Want &want, const sptr<IRemoteObject> &observer) override;
+    int StartUserTest(const Want& want, const sptr<IRemoteObject>& observer) override;
     int FinishUserTest(
-        const std::string &msg, const int64_t &resultCode, const std::string &bundleName) override;
-    int GetTopAbility(sptr<IRemoteObject> &token) override;
-    int DelegatorDoAbilityForeground(const sptr<IRemoteObject> &token) override;
-    int DelegatorDoAbilityBackground(const sptr<IRemoteObject> &token) override;
-    int DoAbilityForeground(const sptr<IRemoteObject> &token, uint32_t flag);
-    int DoAbilityBackground(const sptr<IRemoteObject> &token, uint32_t flag);
-    int32_t GetMissionIdByToken(const sptr<IRemoteObject> &token);
+        const std::string& msg, const int64_t& resultCode, const std::string& bundleName) override;
+    int GetTopAbility(sptr<IRemoteObject>& token) override;
+    int DelegatorDoAbilityForeground(const sptr<IRemoteObject>& token) override;
+    int DelegatorDoAbilityBackground(const sptr<IRemoteObject>& token) override;
+    int DoAbilityForeground(const sptr<IRemoteObject>& token, uint32_t flag);
+    int DoAbilityBackground(const sptr<IRemoteObject>& token, uint32_t flag);
+    int32_t GetMissionIdByToken(const sptr<IRemoteObject>& token);
     int BlockAmsService();
     int BlockAbility(int32_t abilityRecordId);
     int BlockAppService();
 #ifdef ABILITY_COMMAND_FOR_TEST
-    int ForceTimeoutForTest(const std::string &abilityName, const std::string &state) override;
+    int ForceTimeoutForTest(const std::string& abilityName, const std::string& state) override;
 #endif
 #ifdef SUPPORT_GRAPHICS
-    MOCK_METHOD2(SetMissionLabel, int(const sptr<IRemoteObject> &token, const std::string &label));
+    MOCK_METHOD2(SetMissionLabel, int(const sptr<IRemoteObject>& token, const std::string& label));
     int SetMissionIcon(
-        const sptr<IRemoteObject> &token, const std::shared_ptr<OHOS::Media::PixelMap> &icon) override;
+        const sptr<IRemoteObject>& token, const std::shared_ptr<OHOS::Media::PixelMap>& icon) override;
     int RegisterWindowManagerServiceHandler(const sptr<IWindowManagerServiceHandler>& handler);
-    void CompleteFirstFrameDrawing(const sptr<IRemoteObject> &abilityToken) override {}
+    void CompleteFirstFrameDrawing(const sptr<IRemoteObject>& abilityToken) override {}
 #endif
 
 public:
@@ -165,132 +165,132 @@ public:
 class MockAbilityDelegatorStub2 : public AbilityManagerStub {
 public:
     MockAbilityDelegatorStub2();
-    int StartAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = -1) override;
-    MOCK_METHOD4(StartAbility, int(const Want &want, const sptr<IRemoteObject> &callerToken,
+    int StartAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = -1) override;
+    MOCK_METHOD4(StartAbility, int(const Want& want, const sptr<IRemoteObject>& callerToken,
         int32_t userId, int requestCode));
-    MOCK_METHOD5(StartAbility, int(const Want &want, const AbilityStartSetting &abilityStartSetting,
-        const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode));
-    int StartAbility(const Want &want, const StartOptions &startOptions,
-        const sptr<IRemoteObject> &callerToken, int requestCode = DEFAULT_INVAL_VALUE,
+    MOCK_METHOD5(StartAbility, int(const Want& want, const AbilityStartSetting& abilityStartSetting,
+        const sptr<IRemoteObject>& callerToken, int32_t userId, int requestCode));
+    int StartAbility(const Want& want, const StartOptions& startOptions,
+        const sptr<IRemoteObject>& callerToken, int requestCode = DEFAULT_INVAL_VALUE,
         int32_t userId = DEFAULT_INVAL_VALUE) override;
-    MOCK_METHOD3(TerminateAbility, int(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant));
-    MOCK_METHOD2(TerminateAbility, int(const sptr<IRemoteObject> &callerToken, int requestCode));
-    int CloseAbility(const sptr<IRemoteObject> &token, int resultCode = DEFAULT_INVAL_VALUE,
-        const Want *resultWant = nullptr) override;
-    int MinimizeAbility(const sptr<IRemoteObject> &token, bool fromUser = false) override;
-    MOCK_METHOD4(ConnectAbility, int(const Want &want, const sptr<IAbilityConnection> &connect,
-        const sptr<IRemoteObject> &callerToken, int32_t userId));
-    MOCK_METHOD1(DisconnectAbility, int(const sptr<IAbilityConnection> &connect));
+    MOCK_METHOD3(TerminateAbility, int(const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant));
+    MOCK_METHOD2(TerminateAbility, int(const sptr<IRemoteObject>& callerToken, int requestCode));
+    int CloseAbility(const sptr<IRemoteObject>& token, int resultCode = DEFAULT_INVAL_VALUE,
+        const Want* resultWant = nullptr) override;
+    int MinimizeAbility(const sptr<IRemoteObject>& token, bool fromUser = false) override;
+    MOCK_METHOD4(ConnectAbility, int(const Want& want, const sptr<IAbilityConnection>& connect,
+        const sptr<IRemoteObject>& callerToken, int32_t userId));
+    MOCK_METHOD1(DisconnectAbility, int(const sptr<IAbilityConnection>& connect));
     MOCK_METHOD3(AcquireDataAbility,
-        sptr<IAbilityScheduler>(const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken));
+        sptr<IAbilityScheduler>(const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken));
     MOCK_METHOD2(
-        ReleaseDataAbility, int(sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken));
-    MOCK_METHOD2(AddWindowInfo, void(const sptr<IRemoteObject> &token, int32_t windowToken));
-    MOCK_METHOD2(AttachAbilityThread, int(const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token));
-    MOCK_METHOD3(AbilityTransitionDone, int(const sptr<IRemoteObject> &token, int state, const PacMap &));
+        ReleaseDataAbility, int(sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken));
+    MOCK_METHOD2(AddWindowInfo, void(const sptr<IRemoteObject>& token, int32_t windowToken));
+    MOCK_METHOD2(AttachAbilityThread, int(const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token));
+    MOCK_METHOD3(AbilityTransitionDone, int(const sptr<IRemoteObject>& token, int state, const PacMap&));
     MOCK_METHOD2(
-        ScheduleConnectAbilityDone, int(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject));
-    MOCK_METHOD1(ScheduleDisconnectAbilityDone, int(const sptr<IRemoteObject> &token));
-    MOCK_METHOD1(ScheduleCommandAbilityDone, int(const sptr<IRemoteObject> &token));
-    void DumpState(const std::string &args, std::vector<std::string> &state) override;
-    MOCK_METHOD2(TerminateAbilityResult, int(const sptr<IRemoteObject> &token, int startId));
-    int StopServiceAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE) override;
-    MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr<IRemoteObject> &callerToken, int requestCode));
+        ScheduleConnectAbilityDone, int(const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject));
+    MOCK_METHOD1(ScheduleDisconnectAbilityDone, int(const sptr<IRemoteObject>& token));
+    MOCK_METHOD1(ScheduleCommandAbilityDone, int(const sptr<IRemoteObject>& token));
+    void DumpState(const std::string& args, std::vector<std::string>& state) override;
+    MOCK_METHOD2(TerminateAbilityResult, int(const sptr<IRemoteObject>& token, int startId));
+    int StopServiceAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE) override;
+    MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr<IRemoteObject>& callerToken, int requestCode));
     MOCK_METHOD1(MoveMissionToTop, int(int32_t missionId));
     MOCK_METHOD1(RemoveMission, int(int id));
     MOCK_METHOD1(RemoveStack, int(int id));
-    MOCK_METHOD1(KillProcess, int(const std::string &bundleName));
-    MOCK_METHOD2(UninstallApp, int(const std::string &bundleName, int32_t uid));
-    MOCK_METHOD2(MoveMissionToEnd, int(const sptr<IRemoteObject> &token, const bool nonFirst));
-    MOCK_METHOD1(IsFirstInMission, bool(const sptr<IRemoteObject> &token));
-    MOCK_METHOD4(CompelVerifyPermission, int(const std::string &permission, int pid, int uid, std::string &message));
+    MOCK_METHOD1(KillProcess, int(const std::string& bundleName));
+    MOCK_METHOD2(UninstallApp, int(const std::string& bundleName, int32_t uid));
+    MOCK_METHOD2(MoveMissionToEnd, int(const sptr<IRemoteObject>& token, const bool nonFirst));
+    MOCK_METHOD1(IsFirstInMission, bool(const sptr<IRemoteObject>& token));
+    MOCK_METHOD4(CompelVerifyPermission, int(const std::string& permission, int pid, int uid, std::string& message));
     MOCK_METHOD2(
-        GetWantSender, sptr<IWantSender>(const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken));
-    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender> &target, const SenderInfo &senderInfo));
-    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender> &sender));
-    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender> &target));
-    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender> &target, std::shared_ptr<Want> &want));
+        GetWantSender, sptr<IWantSender>(const WantSenderInfo& wantSenderInfo, const sptr<IRemoteObject>& callerToken));
+    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender>& target, const SenderInfo& senderInfo));
+    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender>& sender));
+    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender>& target));
+    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender>& target, std::shared_ptr<Want>& want));
     MOCK_METHOD1(LockMission, int(int));
     MOCK_METHOD1(UnlockMission, int(int));
     MOCK_METHOD0(GetMissionLockModeState, int());
     MOCK_METHOD2(
-        ChangeFocusAbility, int(const sptr<IRemoteObject> &lostFocusToken, const sptr<IRemoteObject> &getFocusToken));
+        ChangeFocusAbility, int(const sptr<IRemoteObject>& lostFocusToken, const sptr<IRemoteObject>& getFocusToken));
     MOCK_METHOD1(MinimizeMultiWindow, int(int missionId));
     MOCK_METHOD1(MaximizeMultiWindow, int(int missionId));
     MOCK_METHOD1(CloseMultiWindow, int(int missionId));
     MOCK_METHOD1(GetPendinTerminateAbilityTestgRequestWant, void(int id));
     MOCK_METHOD1(SetShowOnLockScreen, int(bool isAllow));
-    MOCK_METHOD3(StartContinuation, int(const Want &want, const sptr<IRemoteObject> &abilityToken, int32_t status));
+    MOCK_METHOD3(StartContinuation, int(const Want& want, const sptr<IRemoteObject>& abilityToken, int32_t status));
     MOCK_METHOD2(NotifyContinuationResult, int(int32_t missionId, int32_t result));
-    MOCK_METHOD5(ContinueMission, int(const std::string &srcDeviceId, const std::string &dstDeviceId,
-        int32_t missionId, const sptr<IRemoteObject> &callBack, AAFwk::WantParams &wantParams));
-    MOCK_METHOD3(ContinueAbility, int(const std::string &deviceId, int32_t missionId, uint32_t versionCode));
-    MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string &deviceId, int32_t sessionId, bool isSuccess));
+    MOCK_METHOD5(ContinueMission, int(const std::string& srcDeviceId, const std::string& dstDeviceId,
+        int32_t missionId, const sptr<IRemoteObject>& callBack, AAFwk::WantParams& wantParams));
+    MOCK_METHOD3(ContinueAbility, int(const std::string& deviceId, int32_t missionId, uint32_t versionCode));
+    MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string& deviceId, int32_t sessionId, bool isSuccess));
     MOCK_METHOD1(LockMissionForCleanup, int(int32_t missionId));
     MOCK_METHOD1(UnlockMissionForCleanup, int(int32_t missionId));
-    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener> &listener));
-    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener> &listener));
+    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener>& listener));
+    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener>& listener));
     MOCK_METHOD3(
-        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo> &missionInfos));
-    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo &missionInfo));
+        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo>& missionInfos));
+    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo& missionInfo));
     MOCK_METHOD1(CleanMission, int(int32_t missionId));
     MOCK_METHOD0(CleanAllMissions, int());
     MOCK_METHOD1(MoveMissionToFront, int(int32_t missionId));
-    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions &startOptions));
-    MOCK_METHOD1(ClearUpApplicationData, int(const std::string &));
-    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo> &info));
-    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo> &info));
-    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo> &info));
-    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender> &target, std::shared_ptr<WantSenderInfo> &info));
+    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions& startOptions));
+    MOCK_METHOD1(ClearUpApplicationData, int(const std::string&));
+    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo>& info));
+    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo>& info));
+    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo>& info));
+    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender>& target, std::shared_ptr<WantSenderInfo>& info));
     int StartUser(int userId) override;
-    int StopUser(int userId, const sptr<IStopUserCallback> &callback) override;
+    int StopUser(int userId, const sptr<IStopUserCallback>& callback) override;
     int StartSyncRemoteMissions(const std::string& devId, bool fixConflict, int64_t tag) override;
     int StopSyncRemoteMissions(const std::string& devId) override;
-    int RegisterMissionListener(const std::string &deviceId,
-        const sptr<IRemoteMissionListener> &listener) override;
-    int UnRegisterMissionListener(const std::string &deviceId,
-        const sptr<IRemoteMissionListener> &listener) override;
+    int RegisterMissionListener(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener) override;
+    int UnRegisterMissionListener(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener) override;
     int StartAbilityByCall(
-        const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken) override;
-    int ReleaseCall(const sptr<IAbilityConnection> &connect,
-        const AppExecFwk::ElementName &element) override;
+        const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken) override;
+    int ReleaseCall(const sptr<IAbilityConnection>& connect,
+        const AppExecFwk::ElementName& element) override;
     int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
         MissionSnapshot& snapshot, bool isLowResolution) override;
     void UpdateMissionSnapShot(const sptr<IRemoteObject>& token) override;
     int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler) override;
     int SendANRProcessID(int pid) override;
-    int SetAbilityController(const sptr<AppExecFwk::IAbilityController> &abilityController,
+    int SetAbilityController(const sptr<AppExecFwk::IAbilityController>& abilityController,
         bool imAStabilityTest) override;
     bool IsRunningInStabilityTest() override;
     void DumpSysState(
         const std::string& args, std::vector<std::string>& info, bool isClient, bool isUserID, int UserID) override;
-    int StartUserTest(const Want &want, const sptr<IRemoteObject> &observer) override;
+    int StartUserTest(const Want& want, const sptr<IRemoteObject>& observer) override;
     int FinishUserTest(
-        const std::string &msg, const int64_t &resultCode, const std::string &bundleName) override;
-    int GetTopAbility(sptr<IRemoteObject> &token) override;
-    int DelegatorDoAbilityForeground(const sptr<IRemoteObject> &token) override;
-    int DelegatorDoAbilityBackground(const sptr<IRemoteObject> &token) override;
-    int DoAbilityForeground(const sptr<IRemoteObject> &token, uint32_t flag);
-    int DoAbilityBackground(const sptr<IRemoteObject> &token, uint32_t flag);
-    int32_t GetMissionIdByToken(const sptr<IRemoteObject> &token);
+        const std::string& msg, const int64_t& resultCode, const std::string& bundleName) override;
+    int GetTopAbility(sptr<IRemoteObject>& token) override;
+    int DelegatorDoAbilityForeground(const sptr<IRemoteObject>& token) override;
+    int DelegatorDoAbilityBackground(const sptr<IRemoteObject>& token) override;
+    int DoAbilityForeground(const sptr<IRemoteObject>& token, uint32_t flag);
+    int DoAbilityBackground(const sptr<IRemoteObject>& token, uint32_t flag);
+    int32_t GetMissionIdByToken(const sptr<IRemoteObject>& token);
     int BlockAmsService();
     int BlockAbility(int32_t abilityRecordId);
     int BlockAppService();
 #ifdef ABILITY_COMMAND_FOR_TEST
-    int ForceTimeoutForTest(const std::string &abilityName, const std::string &state) override;
+    int ForceTimeoutForTest(const std::string& abilityName, const std::string& state) override;
 #endif
 #ifdef SUPPORT_GRAPHICS
-    MOCK_METHOD2(SetMissionLabel, int(const sptr<IRemoteObject> &token, const std::string &label));
+    MOCK_METHOD2(SetMissionLabel, int(const sptr<IRemoteObject>& token, const std::string& label));
     int SetMissionIcon(
-        const sptr<IRemoteObject> &token, const std::shared_ptr<OHOS::Media::PixelMap> &icon) override;
+        const sptr<IRemoteObject>& token, const std::shared_ptr<OHOS::Media::PixelMap>& icon) override;
     int RegisterWindowManagerServiceHandler(const sptr<IWindowManagerServiceHandler>& handler);
-    void CompleteFirstFrameDrawing(const sptr<IRemoteObject> &abilityToken) override {}
+    void CompleteFirstFrameDrawing(const sptr<IRemoteObject>& abilityToken) override {}
 #endif
 
 public:

test/mock/frameworks_kits_appkit_native_test/ability_delegator/mock_iability_monitor.cpp

@@ -22,7 +22,7 @@ const std::string ABILITY_NAME = "com.example.myapplication.MainAbility";
 
 namespace OHOS {
 namespace AppExecFwk {
-MockIabilityMonitor::MockIabilityMonitor(const std::string &abilityName) : IAbilityMonitor(abilityName)
+MockIabilityMonitor::MockIabilityMonitor(const std::string& abilityName) : IAbilityMonitor(abilityName)
 {
     start_ = false;
     foreground_ = false;
@@ -33,49 +33,49 @@ MockIabilityMonitor::MockIabilityMonitor(const std::string &abilityName) : IAbil
     windowStageDestroy_ = false;
 }
 
-void MockIabilityMonitor::OnAbilityStart(const std::weak_ptr<NativeReference> &abilityObj)
+void MockIabilityMonitor::OnAbilityStart(const std::weak_ptr<NativeReference>& abilityObj)
 {
     HILOG_INFO("MockIabilityMonitor::OnAbilityStart is called");
     start_ = true;
 }
 
-void MockIabilityMonitor::OnAbilityForeground(const std::weak_ptr<NativeReference> &abilityObj)
+void MockIabilityMonitor::OnAbilityForeground(const std::weak_ptr<NativeReference>& abilityObj)
 {
     HILOG_INFO("MockIabilityMonitor::OnAbilityForeground is called");
     foreground_ = true;
 }
 
-void MockIabilityMonitor::OnAbilityBackground(const std::weak_ptr<NativeReference> &abilityObj)
+void MockIabilityMonitor::OnAbilityBackground(const std::weak_ptr<NativeReference>& abilityObj)
 {
     HILOG_INFO("MockIabilityMonitor::OnAbilityBackground is called");
     background_ = true;
 }
 
-void MockIabilityMonitor::OnAbilityStop(const std::weak_ptr<NativeReference> &abilityObj)
+void MockIabilityMonitor::OnAbilityStop(const std::weak_ptr<NativeReference>& abilityObj)
 {
     HILOG_INFO("MockIabilityMonitor::OnAbilityStop is called");
     stop_ = true;
 }
 
-void MockIabilityMonitor::OnWindowStageCreate(const std::weak_ptr<NativeReference> &abilityObj)
+void MockIabilityMonitor::OnWindowStageCreate(const std::weak_ptr<NativeReference>& abilityObj)
 {
     HILOG_INFO("MockIabilityMonitor::OnWindowStageCreate is called");
     windowStageCreate_ = true;
 }
 
-void MockIabilityMonitor::OnWindowStageRestore(const std::weak_ptr<NativeReference> &abilityObj)
+void MockIabilityMonitor::OnWindowStageRestore(const std::weak_ptr<NativeReference>& abilityObj)
 {
     HILOG_INFO("MockIabilityMonitor::OnWindowStageRestore is called");
     windowStageRestore_ = true;
 }
 
-void MockIabilityMonitor::OnWindowStageDestroy(const std::weak_ptr<NativeReference> &abilityObj)
+void MockIabilityMonitor::OnWindowStageDestroy(const std::weak_ptr<NativeReference>& abilityObj)
 {
     HILOG_INFO("MockIabilityMonitor::OnWindowStageDestroy is called");
     windowStageDestroy_ = true;
 }
 
-bool MockIabilityMonitor::Match(const std::shared_ptr<ADelegatorAbilityProperty> &ability, bool isNotify)
+bool MockIabilityMonitor::Match(const std::shared_ptr<ADelegatorAbilityProperty>& ability, bool isNotify)
 {
     HILOG_INFO("MockIabilityMonitor::Match is called");
 

test/mock/frameworks_kits_appkit_native_test/ability_delegator/mock_iability_monitor.h

@@ -25,10 +25,10 @@ namespace AppExecFwk {
 class MockIabilityMonitor : public IAbilityMonitor {
 public:
 
-    explicit MockIabilityMonitor(const std::string &abilityName);
+    explicit MockIabilityMonitor(const std::string& abilityName);
     virtual ~MockIabilityMonitor() = default;
 
-    virtual bool Match(const std::shared_ptr<ADelegatorAbilityProperty> &ability, bool isNotify = false);
+    virtual bool Match(const std::shared_ptr<ADelegatorAbilityProperty>& ability, bool isNotify = false);
 
     std::shared_ptr<ADelegatorAbilityProperty> waitForAbility()
     {
@@ -39,14 +39,14 @@ public:
         return std::make_shared<ADelegatorAbilityProperty>();
     };
 
-    void OnAbilityStart(const std::weak_ptr<NativeReference> &abilityObj) override;
-    void OnAbilityForeground(const std::weak_ptr<NativeReference> &abilityObj) override;
-    void OnAbilityBackground(const std::weak_ptr<NativeReference> &abilityObj) override;
-    void OnAbilityStop(const std::weak_ptr<NativeReference> &abilityObj) override;
+    void OnAbilityStart(const std::weak_ptr<NativeReference>& abilityObj) override;
+    void OnAbilityForeground(const std::weak_ptr<NativeReference>& abilityObj) override;
+    void OnAbilityBackground(const std::weak_ptr<NativeReference>& abilityObj) override;
+    void OnAbilityStop(const std::weak_ptr<NativeReference>& abilityObj) override;
 
-    void OnWindowStageCreate(const std::weak_ptr<NativeReference> &abilityObj) override;
-    void OnWindowStageRestore(const std::weak_ptr<NativeReference> &abilityObj) override;
-    void OnWindowStageDestroy(const std::weak_ptr<NativeReference> &abilityObj) override;
+    void OnWindowStageCreate(const std::weak_ptr<NativeReference>& abilityObj) override;
+    void OnWindowStageRestore(const std::weak_ptr<NativeReference>& abilityObj) override;
+    void OnWindowStageDestroy(const std::weak_ptr<NativeReference>& abilityObj) override;
 
     bool start_;
     bool foreground_;

test/mock/frameworks_kits_appkit_native_test/ability_delegator/mock_test_observer_stub.cpp

@@ -22,23 +22,23 @@ MockTestObserverStub::~MockTestObserverStub()
 {}
 
 int MockTestObserverStub::OnRemoteRequest(
-    uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
+    uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
 {
     return 0;
 }
 
-void MockTestObserverStub::TestStatus(const std::string &msg, const int64_t &resultCode)
+void MockTestObserverStub::TestStatus(const std::string& msg, const int64_t& resultCode)
 {
     HILOG_INFO("MockTestObserverStub::TestStatus is called");
 
     testStatusFlag = true;
 }
 
-void MockTestObserverStub::TestFinished(const std::string &msg, const int64_t &resultCode)
+void MockTestObserverStub::TestFinished(const std::string& msg, const int64_t& resultCode)
 {}
 
 ShellCommandResult MockTestObserverStub::ExecuteShellCommand(
-    const std::string &cmd, const int64_t timeoutMs)
+    const std::string& cmd, const int64_t timeoutMs)
 {
     return ShellCommandResult();
 }

test/mock/frameworks_kits_appkit_native_test/ability_delegator/mock_test_observer_stub.h

@@ -27,13 +27,13 @@ public:
     MockTestObserverStub() = default;
     ~MockTestObserverStub() override;
     int OnRemoteRequest(
-        uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
-    void TestStatus(const std::string &msg, const int64_t &resultCode) override;
-    void TestFinished(const std::string &msg, const int64_t &resultCode) override;
+        uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override;
+    void TestStatus(const std::string& msg, const int64_t& resultCode) override;
+    void TestFinished(const std::string& msg, const int64_t& resultCode) override;
     ShellCommandResult ExecuteShellCommand(
-        const std::string &cmd, const int64_t timeoutMs) override;
+        const std::string& cmd, const int64_t timeoutMs) override;
 public:
-    bool testStatusFlag {false};
+    bool testStatusFlag{ false };
 };
 }  // namespace AAFwk
 }  // namespace OHOS

test/mock/frameworks_kits_appkit_native_test/include/mock_ability_lifecycle_callbacks.h

@@ -34,7 +34,7 @@ public:
      *
      * @param Ability Indicates the ability object that calls the onStart() method.
      */
-    virtual void OnAbilityStart(const std::shared_ptr<Ability> &ability)
+    virtual void OnAbilityStart(const std::shared_ptr<Ability>& ability)
     {
         GTEST_LOG_(INFO) << "MockAbilityLifecycleCallbacks::OnAbilityStart called";
     }
@@ -45,7 +45,7 @@ public:
      *
      * @param Ability Indicates the Ability object that calls the onInactive() method.
      */
-    virtual void OnAbilityInactive(const std::shared_ptr<Ability> &ability)
+    virtual void OnAbilityInactive(const std::shared_ptr<Ability>& ability)
     {
         GTEST_LOG_(INFO) << "MockAbilityLifecycleCallbacks::OnAbilityInactive called";
     }
@@ -56,7 +56,7 @@ public:
      *
      * @param Ability Indicates the Ability object that calls the onBackground() method.
      */
-    virtual void OnAbilityBackground(const std::shared_ptr<Ability> &ability)
+    virtual void OnAbilityBackground(const std::shared_ptr<Ability>& ability)
     {
         GTEST_LOG_(INFO) << "MockAbilityLifecycleCallbacks::OnAbilityBackground called";
     }
@@ -67,7 +67,7 @@ public:
      *
      * @param Ability Indicates the Ability object that calls the onForeground() method.
      */
-    virtual void OnAbilityForeground(const std::shared_ptr<Ability> &ability)
+    virtual void OnAbilityForeground(const std::shared_ptr<Ability>& ability)
     {
         GTEST_LOG_(INFO) << "MockAbilityLifecycleCallbacks::OnAbilityForeground called";
     }
@@ -78,7 +78,7 @@ public:
      *
      * @param Ability Indicates the Ability object that calls the onActive() method.
      */
-    virtual void OnAbilityActive(const std::shared_ptr<Ability> &ability)
+    virtual void OnAbilityActive(const std::shared_ptr<Ability>& ability)
     {
         GTEST_LOG_(INFO) << "MockAbilityLifecycleCallbacks::OnAbilityActive called";
     }
@@ -89,7 +89,7 @@ public:
      *
      * @param Ability Indicates the Ability object that calls the onStop() method.
      */
-    virtual void OnAbilityStop(const std::shared_ptr<Ability> &ability)
+    virtual void OnAbilityStop(const std::shared_ptr<Ability>& ability)
     {
         GTEST_LOG_(INFO) << "MockAbilityLifecycleCallbacks::OnAbilityStop called";
     }
@@ -100,7 +100,7 @@ public:
      *
      * @param outState Indicates the PacMap object passed to the onSaveAbilityState() callback.
      */
-    virtual void OnAbilitySaveState(const PacMap &outState)
+    virtual void OnAbilitySaveState(const PacMap& outState)
     {
         GTEST_LOG_(INFO) << "MockAbilityLifecycleCallbacks::OnAbilityStop called";
     }

test/mock/frameworks_kits_appkit_native_test/include/mock_ability_manager_client_interface1.cpp

@@ -68,61 +68,61 @@ AbilityManagerClient::~AbilityManagerClient()
 {}
 
 ErrCode AbilityManagerClient::AttachAbilityThread(
-    const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
+    const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject> &token, int state)
+ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject>& token, int state)
 {
     return ERR_OK;
 }
 
 ErrCode AbilityManagerClient::ScheduleConnectAbilityDone(
-    const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
+    const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     return ERR_OK;
 }
 
 ErrCode AbilityManagerClient::ConnectAbility(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection> &connect)
+ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection>& connect)
 {
     return ERR_OK;
 }
 
 sptr<IAbilityScheduler> AbilityManagerClient::AcquireDataAbility(
-    const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken)
+    const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken)
 {
     return nullptr;
 }
 
 ErrCode AbilityManagerClient::ReleaseDataAbility(
-    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken)
+    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::DumpState(const std::string &args, std::vector<std::string> &state)
+ErrCode AbilityManagerClient::DumpState(const std::string& args, std::vector<std::string>& state)
 {
     return ERR_OK;
 }
@@ -132,33 +132,33 @@ ErrCode AbilityManagerClient::Connect()
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::StopServiceAbility(const Want &want, const sptr<IRemoteObject> &callerToken)
+ErrCode AbilityManagerClient::StopServiceAbility(const Want& want, const sptr<IRemoteObject>& callerToken)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::KillProcess(const std::string &bundleName)
+ErrCode AbilityManagerClient::KillProcess(const std::string& bundleName)
 {
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::StartAbility(const Want &want, int requestCode)
+ErrCode AbilityManagerClient::StartAbility(const Want& want, int requestCode)
 {
     return MockAbilityManagerClient::GetInstance()->GetStartAbility();
 }
 
-ErrCode AbilityManagerClient::StartAbility(const Want &want, const sptr<IRemoteObject> &callerToken, int requestCode)
+ErrCode AbilityManagerClient::StartAbility(const Want& want, const sptr<IRemoteObject>& callerToken, int requestCode)
 {
     return MockAbilityManagerClient::GetInstance()->GetStartAbility();
 }
 
-ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &callerToken, int requestCode)
+ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject>& callerToken, int requestCode)
 {
     MockAbilityManagerClient::GetInstance()->SetTerminateAbilityValue(requestCode);
     return MockAbilityManagerClient::GetInstance()->GetTerminateAbility();
 }
 
-ErrCode AbilityManagerClient::TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId)
+ErrCode AbilityManagerClient::TerminateAbilityResult(const sptr<IRemoteObject>& token, int startId)
 {
     return MockAbilityManagerClient::GetInstance()->GetTerminateAbilityResult();
 }

test/mock/frameworks_kits_appkit_native_test/include/mock_application.h

@@ -53,7 +53,7 @@ public:
         state_ = APP_STATE_BACKGROUND;
     }
 
-    virtual void OnConfigurationUpdated(const Configuration &config)
+    virtual void OnConfigurationUpdated(const Configuration& config)
     {
         GTEST_LOG_(INFO) << "MockApplication::OnConfigurationUpdated called";
         onConfigurationUpdatedCalled_ = true;

test/mock/frameworks_kits_appkit_native_test/include/mock_element_callback.h

@@ -33,7 +33,7 @@ public:
      * @param config Indicates the new Configuration object.
      * @param ability Indicates the new Ability object.
      */
-    virtual void OnConfigurationUpdated(const std::shared_ptr<Ability> &ability, const Configuration &config)
+    virtual void OnConfigurationUpdated(const std::shared_ptr<Ability>& ability, const Configuration& config)
     {
         GTEST_LOG_(INFO) << "MockElementsCallback::OnConfigurationUpdated called";
     }

test/mock/frameworks_kits_appkit_native_test/include/mock_resourceManager_interface1.cpp

@@ -31,19 +31,19 @@ public:
     ResourceManagerTestInstance() {};
     ~ResourceManagerTestInstance() override {};
 
-    virtual bool AddResource(const char *path)
+    virtual bool AddResource(const char* path)
     {
         return false;
     };
 
-    virtual RState UpdateResConfig(ResConfig &resConfig)
+    virtual RState UpdateResConfig(ResConfig& resConfig)
     {
         return ERROR;
     };
 
-    virtual void GetResConfig(ResConfig &resConfig) {};
+    virtual void GetResConfig(ResConfig& resConfig) {};
 
-    virtual RState GetStringById(uint32_t id, std::string &outValue)
+    virtual RState GetStringById(uint32_t id, std::string& outValue)
     {
         auto iter = StringById_.find(id);
         if (iter == StringById_.end()) {
@@ -52,7 +52,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    virtual void SetStringById(uint32_t id, std::string &inValue)
+    virtual void SetStringById(uint32_t id, std::string& inValue)
     {
         if (!StringById_.empty()) {
             StringById_.clear();
@@ -60,23 +60,23 @@ public:
         StringById_[id] = inValue;
     };
 
-    virtual RState GetStringByName(const char *name, std::string &outValue)
+    virtual RState GetStringByName(const char* name, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetStringFormatById(std::string &outValue, uint32_t id, ...)
+    virtual RState GetStringFormatById(std::string& outValue, uint32_t id, ...)
     {
         return ERROR;
     };
-    void SetStringFormatById(std::string &inValue, uint32_t id, ...) override {};
+    void SetStringFormatById(std::string& inValue, uint32_t id, ...) override {};
 
-    virtual RState GetStringFormatByName(std::string &outValue, const char *name, ...)
+    virtual RState GetStringFormatByName(std::string& outValue, const char* name, ...)
     {
         return ERROR;
     };
 
-    virtual RState GetStringArrayById(uint32_t id, std::vector<std::string> &outValue)
+    virtual RState GetStringArrayById(uint32_t id, std::vector<std::string>& outValue)
     {
         auto iter = StringArrayById_.find(id);
         if (iter == StringArrayById_.end()) {
@@ -85,7 +85,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    virtual void SetStringArrayById(uint32_t id, std::vector<std::string> &inValue)
+    virtual void SetStringArrayById(uint32_t id, std::vector<std::string>& inValue)
     {
         if (!StringArrayById_.empty()) {
             StringArrayById_.clear();
@@ -93,12 +93,12 @@ public:
         StringArrayById_[id] = inValue;
     };
 
-    virtual RState GetStringArrayByName(const char *name, std::vector<std::string> &outValue)
+    virtual RState GetStringArrayByName(const char* name, std::vector<std::string>& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetPatternById(uint32_t id, std::map<std::string, std::string> &outValue)
+    virtual RState GetPatternById(uint32_t id, std::map<std::string, std::string>& outValue)
     {
         auto iter = PatternById_.find(id);
         if (iter == PatternById_.end()) {
@@ -107,7 +107,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    virtual void SetPatternById(uint32_t id, std::map<std::string, std::string> &inValue)
+    virtual void SetPatternById(uint32_t id, std::map<std::string, std::string>& inValue)
     {
         if (!PatternById_.empty()) {
             PatternById_.clear();
@@ -115,32 +115,32 @@ public:
         PatternById_[id] = inValue;
     };
 
-    virtual RState GetPatternByName(const char *name, std::map<std::string, std::string> &outValue)
+    virtual RState GetPatternByName(const char* name, std::map<std::string, std::string>& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetPluralStringById(uint32_t id, int quantity, std::string &outValue)
+    virtual RState GetPluralStringById(uint32_t id, int quantity, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetPluralStringByName(const char *name, int quantity, std::string &outValue)
+    virtual RState GetPluralStringByName(const char* name, int quantity, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetPluralStringByIdFormat(std::string &outValue, uint32_t id, int quantity, ...)
+    virtual RState GetPluralStringByIdFormat(std::string& outValue, uint32_t id, int quantity, ...)
     {
         return ERROR;
     };
 
-    virtual RState GetPluralStringByNameFormat(std::string &outValue, const char *name, int quantity, ...)
+    virtual RState GetPluralStringByNameFormat(std::string& outValue, const char* name, int quantity, ...)
     {
         return ERROR;
     };
 
-    virtual RState GetThemeById(uint32_t id, std::map<std::string, std::string> &outValue)
+    virtual RState GetThemeById(uint32_t id, std::map<std::string, std::string>& outValue)
     {
         auto iter = ThemeById_.find(id);
         if (iter == ThemeById_.end()) {
@@ -149,7 +149,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    virtual void SetThemeById(uint32_t id, std::map<std::string, std::string> &inValue)
+    virtual void SetThemeById(uint32_t id, std::map<std::string, std::string>& inValue)
     {
         if (!ThemeById_.empty()) {
             ThemeById_.clear();
@@ -157,42 +157,42 @@ public:
         ThemeById_[id] = inValue;
     };
 
-    virtual RState GetThemeByName(const char *name, std::map<std::string, std::string> &outValue)
+    virtual RState GetThemeByName(const char* name, std::map<std::string, std::string>& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetBooleanById(uint32_t id, bool &outValue)
+    virtual RState GetBooleanById(uint32_t id, bool& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetBooleanByName(const char *name, bool &outValue)
+    virtual RState GetBooleanByName(const char* name, bool& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetIntegerById(uint32_t id, int &outValue)
+    virtual RState GetIntegerById(uint32_t id, int& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetIntegerByName(const char *name, int &outValue)
+    virtual RState GetIntegerByName(const char* name, int& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetFloatById(uint32_t id, float &outValue)
+    virtual RState GetFloatById(uint32_t id, float& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetFloatByName(const char *name, float &outValue)
+    virtual RState GetFloatByName(const char* name, float& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetIntArrayById(uint32_t id, std::vector<int> &outValue)
+    virtual RState GetIntArrayById(uint32_t id, std::vector<int>& outValue)
     {
         auto iter = IntArrayById_.find(id);
         if (iter == IntArrayById_.end()) {
@@ -201,7 +201,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    virtual void SetIntArrayById(uint32_t id, std::vector<int> &inValue)
+    virtual void SetIntArrayById(uint32_t id, std::vector<int>& inValue)
     {
         if (!IntArrayById_.empty()) {
             IntArrayById_.clear();
@@ -209,12 +209,12 @@ public:
         IntArrayById_[id] = inValue;
     };
 
-    virtual RState GetIntArrayByName(const char *name, std::vector<int> &outValue)
+    virtual RState GetIntArrayByName(const char* name, std::vector<int>& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetColorById(uint32_t id, uint32_t &outValue)
+    virtual RState GetColorById(uint32_t id, uint32_t& outValue)
     {
         auto iter = ColorById_.find(id);
         if (iter == ColorById_.end()) {
@@ -223,7 +223,7 @@ public:
         outValue = iter->second;
         return SUCCESS;
     };
-    virtual void SetColorById(uint32_t id, uint32_t &inValue)
+    virtual void SetColorById(uint32_t id, uint32_t& inValue)
     {
         if (!ColorById_.empty()) {
             ColorById_.clear();
@@ -231,27 +231,27 @@ public:
         ColorById_[id] = inValue;
     };
 
-    virtual RState GetColorByName(const char *name, uint32_t &outValue)
+    virtual RState GetColorByName(const char* name, uint32_t& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetProfileById(uint32_t id, std::string &outValue)
+    virtual RState GetProfileById(uint32_t id, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetProfileByName(const char *name, std::string &outValue)
+    virtual RState GetProfileByName(const char* name, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetMediaById(uint32_t id, std::string &outValue)
+    virtual RState GetMediaById(uint32_t id, std::string& outValue)
     {
         return ERROR;
     };
 
-    virtual RState GetMediaByName(const char *name, std::string &outValue)
+    virtual RState GetMediaByName(const char* name, std::string& outValue)
     {
         return ERROR;
     };

test/mock/frameworks_kits_appkit_native_test/include/mock_resourceManager_interface1.h

@@ -30,74 +30,74 @@ public:
     ResourceManager2() {};
     virtual ~ResourceManager2() {};
 
-    virtual bool AddResource(const char *path) = 0;
+    virtual bool AddResource(const char* path) = 0;
 
-    virtual RState UpdateResConfig(ResConfig &resConfig) = 0;
+    virtual RState UpdateResConfig(ResConfig& resConfig) = 0;
 
-    virtual void GetResConfig(ResConfig &resConfig) = 0;
+    virtual void GetResConfig(ResConfig& resConfig) = 0;
 
-    virtual RState GetStringById(uint32_t id, std::string &outValue) = 0;
-    virtual void SetStringById(uint32_t id, std::string &outValue) = 0;
+    virtual RState GetStringById(uint32_t id, std::string& outValue) = 0;
+    virtual void SetStringById(uint32_t id, std::string& outValue) = 0;
 
-    virtual RState GetStringByName(const char *name, std::string &outValue) = 0;
+    virtual RState GetStringByName(const char* name, std::string& outValue) = 0;
 
-    virtual RState GetStringFormatById(std::string &outValue, uint32_t id, ...) = 0;
-    virtual void SetStringFormatById(std::string &outValue, uint32_t id, ...) = 0;
+    virtual RState GetStringFormatById(std::string& outValue, uint32_t id, ...) = 0;
+    virtual void SetStringFormatById(std::string& outValue, uint32_t id, ...) = 0;
 
-    virtual RState GetStringFormatByName(std::string &outValue, const char *name, ...) = 0;
+    virtual RState GetStringFormatByName(std::string& outValue, const char* name, ...) = 0;
 
-    virtual RState GetStringArrayById(uint32_t id, std::vector<std::string> &outValue) = 0;
-    virtual void SetStringArrayById(uint32_t id, std::vector<std::string> &outValue) = 0;
+    virtual RState GetStringArrayById(uint32_t id, std::vector<std::string>& outValue) = 0;
+    virtual void SetStringArrayById(uint32_t id, std::vector<std::string>& outValue) = 0;
 
-    virtual RState GetStringArrayByName(const char *name, std::vector<std::string> &outValue) = 0;
+    virtual RState GetStringArrayByName(const char* name, std::vector<std::string>& outValue) = 0;
 
-    virtual RState GetPatternById(uint32_t id, std::map<std::string, std::string> &outValue) = 0;
-    virtual void SetPatternById(uint32_t id, std::map<std::string, std::string> &outValue) = 0;
+    virtual RState GetPatternById(uint32_t id, std::map<std::string, std::string>& outValue) = 0;
+    virtual void SetPatternById(uint32_t id, std::map<std::string, std::string>& outValue) = 0;
 
-    virtual RState GetPatternByName(const char *name, std::map<std::string, std::string> &outValue) = 0;
+    virtual RState GetPatternByName(const char* name, std::map<std::string, std::string>& outValue) = 0;
 
-    virtual RState GetPluralStringById(uint32_t id, int quantity, std::string &outValue) = 0;
+    virtual RState GetPluralStringById(uint32_t id, int quantity, std::string& outValue) = 0;
 
-    virtual RState GetPluralStringByName(const char *name, int quantity, std::string &outValue) = 0;
+    virtual RState GetPluralStringByName(const char* name, int quantity, std::string& outValue) = 0;
 
-    virtual RState GetPluralStringByIdFormat(std::string &outValue, uint32_t id, int quantity, ...) = 0;
+    virtual RState GetPluralStringByIdFormat(std::string& outValue, uint32_t id, int quantity, ...) = 0;
 
-    virtual RState GetPluralStringByNameFormat(std::string &outValue, const char *name, int quantity, ...) = 0;
+    virtual RState GetPluralStringByNameFormat(std::string& outValue, const char* name, int quantity, ...) = 0;
 
-    virtual RState GetThemeById(uint32_t id, std::map<std::string, std::string> &outValue) = 0;
-    virtual void SetThemeById(uint32_t id, std::map<std::string, std::string> &outValue) = 0;
+    virtual RState GetThemeById(uint32_t id, std::map<std::string, std::string>& outValue) = 0;
+    virtual void SetThemeById(uint32_t id, std::map<std::string, std::string>& outValue) = 0;
 
-    virtual RState GetThemeByName(const char *name, std::map<std::string, std::string> &outValue) = 0;
+    virtual RState GetThemeByName(const char* name, std::map<std::string, std::string>& outValue) = 0;
 
-    virtual RState GetBooleanById(uint32_t id, bool &outValue) = 0;
+    virtual RState GetBooleanById(uint32_t id, bool& outValue) = 0;
 
-    virtual RState GetBooleanByName(const char *name, bool &outValue) = 0;
+    virtual RState GetBooleanByName(const char* name, bool& outValue) = 0;
 
-    virtual RState GetIntegerById(uint32_t id, int &outValue) = 0;
+    virtual RState GetIntegerById(uint32_t id, int& outValue) = 0;
 
-    virtual RState GetIntegerByName(const char *name, int &outValue) = 0;
+    virtual RState GetIntegerByName(const char* name, int& outValue) = 0;
 
-    virtual RState GetFloatById(uint32_t id, float &outValue) = 0;
+    virtual RState GetFloatById(uint32_t id, float& outValue) = 0;
 
-    virtual RState GetFloatByName(const char *name, float &outValue) = 0;
+    virtual RState GetFloatByName(const char* name, float& outValue) = 0;
 
-    virtual RState GetIntArrayById(uint32_t id, std::vector<int> &outValue) = 0;
-    virtual void SetIntArrayById(uint32_t id, std::vector<int> &outValue) = 0;
+    virtual RState GetIntArrayById(uint32_t id, std::vector<int>& outValue) = 0;
+    virtual void SetIntArrayById(uint32_t id, std::vector<int>& outValue) = 0;
 
-    virtual RState GetIntArrayByName(const char *name, std::vector<int> &outValue) = 0;
+    virtual RState GetIntArrayByName(const char* name, std::vector<int>& outValue) = 0;
 
-    virtual RState GetColorById(uint32_t id, uint32_t &outValue) = 0;
-    virtual void SetColorById(uint32_t id, uint32_t &outValue) = 0;
+    virtual RState GetColorById(uint32_t id, uint32_t& outValue) = 0;
+    virtual void SetColorById(uint32_t id, uint32_t& outValue) = 0;
 
-    virtual RState GetColorByName(const char *name, uint32_t &outValue) = 0;
+    virtual RState GetColorByName(const char* name, uint32_t& outValue) = 0;
 
-    virtual RState GetProfileById(uint32_t id, std::string &outValue) = 0;
+    virtual RState GetProfileById(uint32_t id, std::string& outValue) = 0;
 
-    virtual RState GetProfileByName(const char *name, std::string &outValue) = 0;
+    virtual RState GetProfileByName(const char* name, std::string& outValue) = 0;
 
-    virtual RState GetMediaById(uint32_t id, std::string &outValue) = 0;
+    virtual RState GetMediaById(uint32_t id, std::string& outValue) = 0;
 
-    virtual RState GetMediaByName(const char *name, std::string &outValue) = 0;
+    virtual RState GetMediaByName(const char* name, std::string& outValue) = 0;
 };
 
 std::shared_ptr<ResourceManager2> CreateResourceManager2();

test/mock/frameworks_kits_appkit_test/include/mock_ability_mgr_service.h

@@ -24,57 +24,57 @@ namespace OHOS {
 namespace AAFwk {
 class MockAbilityMgrService : public AbilityManagerStub {
 public:
-    MOCK_METHOD3(StartAbility, int(const Want &want, int32_t userId, int requestCode));
-    MOCK_METHOD4(StartAbility, int(const Want &want, const sptr<IRemoteObject> &callerToken, int32_t userId,
-         int requestCode));
-    MOCK_METHOD5(StartAbility, int(const Want &want, const AbilityStartSetting &abilityStartSetting,
-        const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode));
-    MOCK_METHOD3(TerminateAbility, int(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant));
-    MOCK_METHOD4(ConnectAbility, int(const Want &want, const sptr<IAbilityConnection> &connect,
-        const sptr<IRemoteObject> &callerToken, int32_t userId));
-    MOCK_METHOD1(DisconnectAbility, int(const sptr<IAbilityConnection> &connect));
-    MOCK_METHOD3(AcquireDataAbility, sptr<IAbilityScheduler>(const Uri &, bool, const sptr<IRemoteObject> &));
-    MOCK_METHOD2(ReleaseDataAbility, int(sptr<IAbilityScheduler>, const sptr<IRemoteObject> &));
-    MOCK_METHOD2(AttachAbilityThread, int(const sptr<IAbilityScheduler> &scheduler,
-        const sptr<IRemoteObject> &token));
-    MOCK_METHOD3(AbilityTransitionDone, int(const sptr<IRemoteObject> &token, int state, const PacMap &saveData));
+    MOCK_METHOD3(StartAbility, int(const Want& want, int32_t userId, int requestCode));
+    MOCK_METHOD4(StartAbility, int(const Want& want, const sptr<IRemoteObject>& callerToken, int32_t userId,
+        int requestCode));
+    MOCK_METHOD5(StartAbility, int(const Want& want, const AbilityStartSetting& abilityStartSetting,
+        const sptr<IRemoteObject>& callerToken, int32_t userId, int requestCode));
+    MOCK_METHOD3(TerminateAbility, int(const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant));
+    MOCK_METHOD4(ConnectAbility, int(const Want& want, const sptr<IAbilityConnection>& connect,
+        const sptr<IRemoteObject>& callerToken, int32_t userId));
+    MOCK_METHOD1(DisconnectAbility, int(const sptr<IAbilityConnection>& connect));
+    MOCK_METHOD3(AcquireDataAbility, sptr<IAbilityScheduler>(const Uri&, bool, const sptr<IRemoteObject>&));
+    MOCK_METHOD2(ReleaseDataAbility, int(sptr<IAbilityScheduler>, const sptr<IRemoteObject>&));
+    MOCK_METHOD2(AttachAbilityThread, int(const sptr<IAbilityScheduler>& scheduler,
+        const sptr<IRemoteObject>& token));
+    MOCK_METHOD3(AbilityTransitionDone, int(const sptr<IRemoteObject>& token, int state, const PacMap& saveData));
     MOCK_METHOD2(
-        ScheduleConnectAbilityDone, int(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject));
-    MOCK_METHOD1(ScheduleDisconnectAbilityDone, int(const sptr<IRemoteObject> &token));
-    MOCK_METHOD1(ScheduleCommandAbilityDone, int(const sptr<IRemoteObject> &token));
-    void DumpState(const std::string &args, std::vector<std::string> &state)
+        ScheduleConnectAbilityDone, int(const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject));
+    MOCK_METHOD1(ScheduleDisconnectAbilityDone, int(const sptr<IRemoteObject>& token));
+    MOCK_METHOD1(ScheduleCommandAbilityDone, int(const sptr<IRemoteObject>& token));
+    void DumpState(const std::string& args, std::vector<std::string>& state)
     {
         GTEST_LOG_(INFO) << "MockAbilityMgrService::DumpState called";
         DumpStateCalled_ = true;
         EXPECT_TRUE(DumpStateCalled_);
         return;
     }
-    MOCK_METHOD2(TerminateAbilityResult, int(const sptr<IRemoteObject> &, int startId));
-    MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr<IRemoteObject> &callerToken, int requestCode));
-    MOCK_METHOD2(StopServiceAbility, int(const Want &, int32_t userId));
-    MOCK_METHOD4(OnRemoteRequest, int(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option));
+    MOCK_METHOD2(TerminateAbilityResult, int(const sptr<IRemoteObject>&, int startId));
+    MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr<IRemoteObject>& callerToken, int requestCode));
+    MOCK_METHOD2(StopServiceAbility, int(const Want&, int32_t userId));
+    MOCK_METHOD4(OnRemoteRequest, int(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option));
 
-    MOCK_METHOD1(KillProcess, int(const std::string &bundleName));
-    MOCK_METHOD2(UninstallApp, int(const std::string &bundleName, int32_t uid));
+    MOCK_METHOD1(KillProcess, int(const std::string& bundleName));
+    MOCK_METHOD2(UninstallApp, int(const std::string& bundleName, int32_t uid));
     MOCK_METHOD1(TerminateAbilityByRecordId, int(const int64_t recordId));
 
     MOCK_METHOD1(LockMissionForCleanup, int(int32_t missionId));
     MOCK_METHOD1(UnlockMissionForCleanup, int(int32_t missionId));
-    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener> &listener));
-    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener> &listener));
+    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener>& listener));
+    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener>& listener));
     MOCK_METHOD3(
-        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo> &missionInfos));
-    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo &missionInfo));
+        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo>& missionInfos));
+    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo& missionInfo));
     MOCK_METHOD1(CleanMission, int(int32_t missionId));
     MOCK_METHOD0(CleanAllMissions, int());
     MOCK_METHOD1(MoveMissionToFront, int(int32_t missionId));
-    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions &startOptions));
-    MOCK_METHOD1(GetMissionIdByToken, int32_t(const sptr<IRemoteObject> &token));
+    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions& startOptions));
+    MOCK_METHOD1(GetMissionIdByToken, int32_t(const sptr<IRemoteObject>& token));
 
-    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo> &info));
-    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo> &info));
-    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo> &info));
-    virtual int SetAbilityController(const sptr<AppExecFwk::IAbilityController> &abilityController,
+    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo>& info));
+    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo>& info));
+    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo>& info));
+    virtual int SetAbilityController(const sptr<AppExecFwk::IAbilityController>& abilityController,
         bool imAStabilityTest) override
     {
         return 0;
@@ -101,12 +101,12 @@ public:
         sem_.Post();
     }
 
-    #ifdef ABILITY_COMMAND_FOR_TEST
-    virtual int ForceTimeoutForTest(const std::string &abilityName, const std::string &state) override
+#ifdef ABILITY_COMMAND_FOR_TEST
+    virtual int ForceTimeoutForTest(const std::string& abilityName, const std::string& state) override
     {
         return 0;
     }
-    #endif
+#endif
 
 private:
     bool DumpStateCalled_ = false;

test/mock/frameworks_kits_appkit_test/include/mock_ability_token.h

@@ -34,7 +34,7 @@ public:
     MockAbilityToken() = default;
     virtual ~MockAbilityToken() = default;
 
-    virtual int OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
+    virtual int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
     {
         return 0;
     }
@@ -45,7 +45,7 @@ private:
 
 class AbilityTokenProxy : public IRemoteProxy<IAbilityToken> {
 public:
-    explicit AbilityTokenProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IAbilityToken>(impl)
+    explicit AbilityTokenProxy(const sptr<IRemoteObject>& impl) : IRemoteProxy<IAbilityToken>(impl)
     {}
 
     virtual ~AbilityTokenProxy() = default;

test/mock/frameworks_kits_appkit_test/include/mock_app_mgr_service.h

@@ -28,44 +28,44 @@ namespace AppExecFwk {
 class MockAppMgrService : public AppMgrStub {
 public:
     MOCK_METHOD5(LoadAbility,
-        void(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &preToken,
-            const std::shared_ptr<AbilityInfo> &abilityInfo, const std::shared_ptr<ApplicationInfo> &appInfo,
-            const std::shared_ptr<AAFwk::Want> &want));
-    MOCK_METHOD2(TerminateAbility, void(const sptr<IRemoteObject> &token, bool isClearMissionFlag));
-    MOCK_METHOD2(UpdateAbilityState, void(const sptr<IRemoteObject> &token, const AbilityState state));
+        void(const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& preToken,
+            const std::shared_ptr<AbilityInfo>& abilityInfo, const std::shared_ptr<ApplicationInfo>& appInfo,
+            const std::shared_ptr<AAFwk::Want>& want));
+    MOCK_METHOD2(TerminateAbility, void(const sptr<IRemoteObject>& token, bool isClearMissionFlag));
+    MOCK_METHOD2(UpdateAbilityState, void(const sptr<IRemoteObject>& token, const AbilityState state));
     MOCK_METHOD1(SetAppFreezingTime, void(int time));
-    MOCK_METHOD1(GetAppFreezingTime, void(int &time));
+    MOCK_METHOD1(GetAppFreezingTime, void(int& time));
     MOCK_METHOD1(AddAbilityStageDone, void(const int32_t recordId));
-    MOCK_METHOD1(StartupResidentProcess, void(const std::vector<AppExecFwk::BundleInfo> &bundleInfos));
+    MOCK_METHOD1(StartupResidentProcess, void(const std::vector<AppExecFwk::BundleInfo>& bundleInfos));
     MOCK_METHOD1(NotifyMemoryLevel, int(int32_t level));
-    MOCK_METHOD2(GetProcessRunningInfosByUserId, int(std::vector<RunningProcessInfo> &info, int32_t userId));
-    MOCK_METHOD4(StartUserTestProcess, int(const AAFwk::Want &want, const sptr<IRemoteObject> &observer,
-        const BundleInfo &bundleInfo, int32_t userId));
-    MOCK_METHOD3(FinishUserTest, int(const std::string &msg, const int64_t &resultCode,
-        const std::string &bundleName));
-    MOCK_METHOD3(ScheduleAcceptWantDone, void(const int32_t recordId, const AAFwk::Want &want,
-        const std::string &flag));
-    MOCK_METHOD2(GetAbilityRecordsByProcessID, int(const int pid, std::vector<sptr<IRemoteObject>> &tokens));
-    #ifdef ABILITY_COMMAND_FOR_TEST
+    MOCK_METHOD2(GetProcessRunningInfosByUserId, int(std::vector<RunningProcessInfo>& info, int32_t userId));
+    MOCK_METHOD4(StartUserTestProcess, int(const AAFwk::Want& want, const sptr<IRemoteObject>& observer,
+        const BundleInfo& bundleInfo, int32_t userId));
+    MOCK_METHOD3(FinishUserTest, int(const std::string& msg, const int64_t& resultCode,
+        const std::string& bundleName));
+    MOCK_METHOD3(ScheduleAcceptWantDone, void(const int32_t recordId, const AAFwk::Want& want,
+        const std::string& flag));
+    MOCK_METHOD2(GetAbilityRecordsByProcessID, int(const int pid, std::vector<sptr<IRemoteObject>>& tokens));
+#ifdef ABILITY_COMMAND_FOR_TEST
     MOCK_METHOD0(BlockAppService, int());
-    #endif
+#endif
     MOCK_METHOD0(PreStartNWebSpawnProcess, int());
-    MOCK_METHOD4(StartRenderProcess, int(const std::string &renderParam, int32_t ipcFd,
-        int32_t sharedFd, pid_t &renderPid));
-    MOCK_METHOD1(AttachRenderProcess, void(const sptr<IRemoteObject> &renderScheduler));
-    MOCK_METHOD2(GetRenderProcessTerminationStatus, int(pid_t renderPid, int &status));
+    MOCK_METHOD4(StartRenderProcess, int(const std::string& renderParam, int32_t ipcFd,
+        int32_t sharedFd, pid_t& renderPid));
+    MOCK_METHOD1(AttachRenderProcess, void(const sptr<IRemoteObject>& renderScheduler));
+    MOCK_METHOD2(GetRenderProcessTerminationStatus, int(pid_t renderPid, int& status));
     MOCK_METHOD1(GetConfiguration, int32_t(Configuration& config));
-    MOCK_METHOD1(UpdateConfiguration, int32_t(const Configuration &config));
-    MOCK_METHOD1(RegisterConfigurationObserver, int32_t(const sptr<IConfigurationObserver> &observer));
-    MOCK_METHOD1(UnregisterConfigurationObserver, int32_t(const sptr<IConfigurationObserver> &observer));
-    MOCK_METHOD1(GetAppRunningStateByBundleName, bool(const std::string &bundleName));
-    MOCK_METHOD2(NotifyLoadRepairPatch, int32_t(const std::string &bundleName,
-        const sptr<IQuickFixCallback> &callback));
-    MOCK_METHOD2(NotifyHotReloadPage, int32_t(const std::string &bundleName, const sptr<IQuickFixCallback> &callback));
-    MOCK_METHOD2(NotifyUnLoadRepairPatch, int32_t(const std::string &bundleName,
-        const sptr<IQuickFixCallback> &callback));
+    MOCK_METHOD1(UpdateConfiguration, int32_t(const Configuration& config));
+    MOCK_METHOD1(RegisterConfigurationObserver, int32_t(const sptr<IConfigurationObserver>& observer));
+    MOCK_METHOD1(UnregisterConfigurationObserver, int32_t(const sptr<IConfigurationObserver>& observer));
+    MOCK_METHOD1(GetAppRunningStateByBundleName, bool(const std::string& bundleName));
+    MOCK_METHOD2(NotifyLoadRepairPatch, int32_t(const std::string& bundleName,
+        const sptr<IQuickFixCallback>& callback));
+    MOCK_METHOD2(NotifyHotReloadPage, int32_t(const std::string& bundleName, const sptr<IQuickFixCallback>& callback));
+    MOCK_METHOD2(NotifyUnLoadRepairPatch, int32_t(const std::string& bundleName,
+        const sptr<IQuickFixCallback>& callback));
 
-    void AttachApplication(const sptr<IRemoteObject> &app)
+    void AttachApplication(const sptr<IRemoteObject>& app)
     {
         GTEST_LOG_(INFO) << "MockAppMgrService::AttachApplication called";
         Attached_ = true;
@@ -93,53 +93,53 @@ public:
         Terminated_ = true;
         EXPECT_TRUE(Terminated_);
     }
-    MOCK_METHOD2(CheckPermission, int32_t(const int32_t recordId, const std::string &permission));
+    MOCK_METHOD2(CheckPermission, int32_t(const int32_t recordId, const std::string& permission));
 
-    virtual void AbilityCleaned(const sptr<IRemoteObject> &token)
+    virtual void AbilityCleaned(const sptr<IRemoteObject>& token)
     {
         GTEST_LOG_(INFO) << "MockAppMgrService::AbilityCleaned called";
         Cleaned_ = true;
         EXPECT_TRUE(Cleaned_);
     }
 
-    MOCK_METHOD1(KillApplication, int(const std::string &appName));
-    MOCK_METHOD2(KillApplicationByUid, int(const std::string &, const int uid));
+    MOCK_METHOD1(KillApplication, int(const std::string& appName));
+    MOCK_METHOD2(KillApplicationByUid, int(const std::string&, const int uid));
 
     virtual sptr<IAmsMgr> GetAmsMgr() override
     {
         return nullptr;
     };
-    virtual int32_t ClearUpApplicationData(const std::string &appName) override
+    virtual int32_t ClearUpApplicationData(const std::string& appName) override
     {
         return 0;
     }
 
-    int IsBackgroundRunningRestricted(const std::string &appName)
+    int IsBackgroundRunningRestricted(const std::string& appName)
     {
         return 0;
     };
-    virtual int GetAllRunningProcesses(std::vector<RunningProcessInfo> &info) override
+    virtual int GetAllRunningProcesses(std::vector<RunningProcessInfo>& info) override
     {
         return 0;
     };
 
-    virtual void RegisterAppStateCallback(const sptr<IAppStateCallback> &callback)
+    virtual void RegisterAppStateCallback(const sptr<IAppStateCallback>& callback)
     {
         callback_ = callback;
     }
 
-    int32_t CheckPermissionImpl([[maybe_unused]] const int32_t recordId, const std::string &data)
+    int32_t CheckPermissionImpl([[maybe_unused]] const int32_t recordId, const std::string& data)
     {
         data_ = data;
         return 0;
     }
 
-    void KillApplicationImpl(const std::string &data)
+    void KillApplicationImpl(const std::string& data)
     {
         data_ = data;
     }
 
-    const std::string &GetData() const
+    const std::string& GetData() const
     {
         return data_;
     }
@@ -165,7 +165,7 @@ public:
         callback_->OnAppStateChanged(processData);
     }
 
-    void Terminate(const sptr<IRemoteObject> &token) const
+    void Terminate(const sptr<IRemoteObject>& token) const
     {
         if (!callback_) {
             return;
@@ -181,7 +181,7 @@ public:
         }
     }
 
-    void ScheduleLaunchApplication(const AppLaunchData &lanchdata, const Configuration & config)
+    void ScheduleLaunchApplication(const AppLaunchData& lanchdata, const Configuration& config)
     {
         if (Appthread_ != nullptr) {
             Appthread_->ScheduleLaunchApplication(lanchdata, config);
@@ -216,29 +216,29 @@ public:
         }
     }
 
-    void ScheduleLaunchAbility(const AbilityInfo &abilityinf, const sptr<IRemoteObject> &token,
-        const std::shared_ptr<AAFwk::Want> &want)
+    void ScheduleLaunchAbility(const AbilityInfo& abilityinf, const sptr<IRemoteObject>& token,
+        const std::shared_ptr<AAFwk::Want>& want)
     {
         if (Appthread_ != nullptr) {
             Appthread_->ScheduleLaunchAbility(abilityinf, token, want);
         }
     }
 
-    void ScheduleCleanAbility(const sptr<IRemoteObject> &token)
+    void ScheduleCleanAbility(const sptr<IRemoteObject>& token)
     {
         if (Appthread_ != nullptr) {
             Appthread_->ScheduleCleanAbility(token);
         }
     }
 
-    void ScheduleProfileChanged(const Profile &profile)
+    void ScheduleProfileChanged(const Profile& profile)
     {
         if (Appthread_ != nullptr) {
             Appthread_->ScheduleProfileChanged(profile);
         }
     }
 
-    void ScheduleConfigurationUpdated(const Configuration &config)
+    void ScheduleConfigurationUpdated(const Configuration& config)
     {
         if (Appthread_ != nullptr) {
             Appthread_->ScheduleConfigurationUpdated(config);
@@ -280,7 +280,7 @@ public:
         Attached_ = false;
     }
 
-    bool AddDeathRecipient(const sptr<DeathRecipient> &recipient)
+    bool AddDeathRecipient(const sptr<DeathRecipient>& recipient)
     {
         return true;
     }

test/mock/frameworks_kits_appkit_test/include/mock_app_thread.cpp

@@ -17,10 +17,10 @@
 
 namespace OHOS {
 namespace AppExecFwk {
-MockHandler::MockHandler(const std::shared_ptr<EventRunner> &runner) : EventHandler(runner)
+MockHandler::MockHandler(const std::shared_ptr<EventRunner>& runner) : EventHandler(runner)
 {}
 
-void MockHandler::ProcessEvent([[maybe_unused]] const InnerEvent::Pointer &event)
+void MockHandler::ProcessEvent([[maybe_unused]] const InnerEvent::Pointer& event)
 {}
 }  // namespace AppExecFwk
 }  // namespace OHOS

test/mock/frameworks_kits_appkit_test/include/mock_app_thread.h

@@ -26,10 +26,10 @@ namespace OHOS {
 namespace AppExecFwk {
 class MockHandler : public EventHandler {
 public:
-    explicit MockHandler(const std::shared_ptr<EventRunner> &runner);
+    explicit MockHandler(const std::shared_ptr<EventRunner>& runner);
     ~MockHandler()
     {}
-    void ProcessEvent(const InnerEvent::Pointer &event) override;
+    void ProcessEvent(const InnerEvent::Pointer& event) override;
 };
 }  // namespace AppExecFwk
 }  // namespace OHOS

test/mock/frameworks_kits_appkit_test/include/mock_application.cpp

@@ -32,7 +32,7 @@ MockApplication::MockApplication()
     lifecycleCallBack_ = std::make_shared<MockModuleLifecycleCallbacks>();
 }
 
-void MockApplication::OnConfigurationUpdated(const Configuration &config)
+void MockApplication::OnConfigurationUpdated(const Configuration& config)
 {
     GTEST_LOG_(INFO) << "MockApplication::OnConfigurationUpdated called";
     bool iscalled = true;
@@ -141,7 +141,7 @@ void MockApplication::OnTerminate()
 }
 
 void MockModuleElementsCallback::OnConfigurationUpdated(
-    const std::shared_ptr<Ability> &ability, const Configuration &config)
+    const std::shared_ptr<Ability>& ability, const Configuration& config)
 {
     GTEST_LOG_(INFO) << "MockModuleElementsCallback::OnConfigurationUpdated called";
     EXPECT_STREQ(config.GetName().c_str(), "testConfig");
@@ -153,37 +153,37 @@ void MockModuleElementsCallback::OnMemoryLevel(int level)
     EXPECT_EQ(level, NUMBER);
 }
 
-void MockModuleLifecycleCallbacks::OnAbilityStart(const std::shared_ptr<Ability> &ability)
+void MockModuleLifecycleCallbacks::OnAbilityStart(const std::shared_ptr<Ability>& ability)
 {
     GTEST_LOG_(INFO) << "MockModuleLifecycleCallbacks::OnAbilityStart called";
 }
 
-void MockModuleLifecycleCallbacks::OnAbilityInactive(const std::shared_ptr<Ability> &ability)
+void MockModuleLifecycleCallbacks::OnAbilityInactive(const std::shared_ptr<Ability>& ability)
 {
     GTEST_LOG_(INFO) << "MockModuleLifecycleCallbacks::OnAbilityInactive called";
 }
 
-void MockModuleLifecycleCallbacks::OnAbilityBackground(const std::shared_ptr<Ability> &ability)
+void MockModuleLifecycleCallbacks::OnAbilityBackground(const std::shared_ptr<Ability>& ability)
 {
     GTEST_LOG_(INFO) << "MockModuleLifecycleCallbacks::OnAbilityBackground called";
 }
 
-void MockModuleLifecycleCallbacks::OnAbilityForeground(const std::shared_ptr<Ability> &ability)
+void MockModuleLifecycleCallbacks::OnAbilityForeground(const std::shared_ptr<Ability>& ability)
 {
     GTEST_LOG_(INFO) << "MockModuleLifecycleCallbacks::OnAbilityForeground called";
 }
 
-void MockModuleLifecycleCallbacks::OnAbilityActive(const std::shared_ptr<Ability> &ability)
+void MockModuleLifecycleCallbacks::OnAbilityActive(const std::shared_ptr<Ability>& ability)
 {
     GTEST_LOG_(INFO) << "MockModuleLifecycleCallbacks::OnAbilityActive called";
 }
 
-void MockModuleLifecycleCallbacks::OnAbilityStop(const std::shared_ptr<Ability> &ability)
+void MockModuleLifecycleCallbacks::OnAbilityStop(const std::shared_ptr<Ability>& ability)
 {
     GTEST_LOG_(INFO) << "MockModuleLifecycleCallbacks::OnAbilityStop called";
 }
 
-void MockModuleLifecycleCallbacks::OnAbilitySaveState(const PacMap &outState)
+void MockModuleLifecycleCallbacks::OnAbilitySaveState(const PacMap& outState)
 {
     GTEST_LOG_(INFO) << "MockModuleLifecycleCallbacks::OnAbilitySaveState called";
 }

test/mock/frameworks_kits_appkit_test/include/mock_application.h

@@ -26,13 +26,13 @@ public:
     MockModuleLifecycleCallbacks() = default;
     virtual ~MockModuleLifecycleCallbacks() = default;
 
-    void OnAbilityStart(const std::shared_ptr<Ability> &ability);
-    void OnAbilityInactive(const std::shared_ptr<Ability> &ability);
-    void OnAbilityBackground(const std::shared_ptr<Ability> &ability);
-    void OnAbilityForeground(const std::shared_ptr<Ability> &ability);
-    void OnAbilityActive(const std::shared_ptr<Ability> &ability);
-    void OnAbilityStop(const std::shared_ptr<Ability> &ability);
-    void OnAbilitySaveState(const PacMap &outState);
+    void OnAbilityStart(const std::shared_ptr<Ability>& ability);
+    void OnAbilityInactive(const std::shared_ptr<Ability>& ability);
+    void OnAbilityBackground(const std::shared_ptr<Ability>& ability);
+    void OnAbilityForeground(const std::shared_ptr<Ability>& ability);
+    void OnAbilityActive(const std::shared_ptr<Ability>& ability);
+    void OnAbilityStop(const std::shared_ptr<Ability>& ability);
+    void OnAbilitySaveState(const PacMap& outState);
 };
 
 class MockModuleElementsCallback : public ElementsCallback {
@@ -40,7 +40,7 @@ public:
     MockModuleElementsCallback() = default;
     virtual ~MockModuleElementsCallback() = default;
 
-    virtual void OnConfigurationUpdated(const std::shared_ptr<Ability> &ability, const Configuration &config);
+    virtual void OnConfigurationUpdated(const std::shared_ptr<Ability>& ability, const Configuration& config);
 
     virtual void OnMemoryLevel(int level);
 };
@@ -50,7 +50,7 @@ public:
     MockApplication();
     virtual ~MockApplication() = default;
 
-    virtual void OnConfigurationUpdated(const Configuration &config);
+    virtual void OnConfigurationUpdated(const Configuration& config);
     virtual void OnMemoryLevel(int level);
     virtual void OnForeground();
     virtual void OnBackground();

test/mock/frameworks_kits_appkit_test/include/mock_bundle_mgr_service.h

@@ -25,11 +25,11 @@ namespace AppExecFwk {
 class MockBundleMgrService : public BundleMgrHost {
 public:
     virtual bool GetBundleInfo(
-        const std::string &bundleName, const BundleFlag flag, BundleInfo &bundleInfo, int32_t userId) override
+        const std::string& bundleName, const BundleFlag flag, BundleInfo& bundleInfo, int32_t userId) override
     {
         return false;
     }
-    std::string GetAppType(const std::string &bundleName)
+    std::string GetAppType(const std::string& bundleName)
     {
         GTEST_LOG_(INFO) << "MockBundleMgrService::GetAppType called";
         return "ModuleTestType";

test/mock/frameworks_kits_test/AMS/mock_ability_manager_client.cpp

@@ -47,7 +47,7 @@ AbilityManagerClient::~AbilityManagerClient()
 {}
 
 ErrCode AbilityManagerClient::AttachAbilityThread(
-    const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
+    const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token)
 {
     HILOG_INFO("AbilityManagerClient::AttachAbilityThread start");
     ErrCode err = Connect();
@@ -59,7 +59,7 @@ ErrCode AbilityManagerClient::AttachAbilityThread(
     return abms->AttachAbilityThread(scheduler, token);
 }
 
-ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject> &token, int state, const PacMap &saveData)
+ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject>& token, int state, const PacMap& saveData)
 {
     if (remoteObject_ == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -69,7 +69,7 @@ ErrCode AbilityManagerClient::AbilityTransitionDone(const sptr<IRemoteObject> &t
 }
 
 ErrCode AbilityManagerClient::ScheduleConnectAbilityDone(
-    const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
+    const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject)
 {
     if (remoteObject_ == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -78,7 +78,7 @@ ErrCode AbilityManagerClient::ScheduleConnectAbilityDone(
     return abms->ScheduleConnectAbilityDone(token, remoteObject);
 }
 
-ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token)
 {
     if (remoteObject_ == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -87,7 +87,7 @@ ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(const sptr<IRemoteOb
     return abms->ScheduleDisconnectAbilityDone(token);
 }
 
-ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token)
+ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token)
 {
     if (remoteObject_ == nullptr) {
         HILOG_ERROR("%{private}s:ability service not command", __func__);
@@ -97,7 +97,7 @@ ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(const sptr<IRemoteObjec
     return abms->ScheduleCommandAbilityDone(token);
 }
 
-ErrCode AbilityManagerClient::StartAbility(const Want &want, int requestCode, int32_t userId)
+ErrCode AbilityManagerClient::StartAbility(const Want& want, int requestCode, int32_t userId)
 {
     if (remoteObject_ == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -106,7 +106,7 @@ ErrCode AbilityManagerClient::StartAbility(const Want &want, int requestCode, in
     return abms->StartAbility(want, userId, requestCode);
 }
 
-ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     HILOG_INFO("AbilityManagerClient::TerminateAbility start");
     if (remoteObject_ == nullptr) {
@@ -118,7 +118,7 @@ ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &token,
     return abms->TerminateAbility(token, resultCode, resultWant);
 }
 
-ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &callerToken, int requestCode)
+ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject>& callerToken, int requestCode)
 {
     if (remoteObject_ == nullptr) {
         HILOG_ERROR("%{private}s:ability service not connect", __func__);
@@ -129,7 +129,7 @@ ErrCode AbilityManagerClient::TerminateAbility(const sptr<IRemoteObject> &caller
 }
 
 ErrCode AbilityManagerClient::ConnectAbility(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken, int32_t userId)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken, int32_t userId)
 {
     if (remoteObject_ == nullptr) {
         remoteObject_ =
@@ -139,7 +139,7 @@ ErrCode AbilityManagerClient::ConnectAbility(
     return abms->ConnectAbility(want, connect, callerToken);
 }
 
-ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection> &connect)
+ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection>& connect)
 {
     if (remoteObject_ == nullptr) {
         remoteObject_ =
@@ -149,7 +149,7 @@ ErrCode AbilityManagerClient::DisconnectAbility(const sptr<IAbilityConnection> &
     return abms->DisconnectAbility(connect);
 }
 
-ErrCode AbilityManagerClient::DumpState(const std::string &args, std::vector<std::string> &state)
+ErrCode AbilityManagerClient::DumpState(const std::string& args, std::vector<std::string>& state)
 {
     if (remoteObject_ == nullptr) {
         return ABILITY_SERVICE_NOT_CONNECTED;
@@ -172,7 +172,7 @@ ErrCode AbilityManagerClient::Connect()
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::StopServiceAbility(const Want &want)
+ErrCode AbilityManagerClient::StopServiceAbility(const Want& want)
 {
     if (remoteObject_ == nullptr) {
         remoteObject_ =
@@ -183,7 +183,7 @@ ErrCode AbilityManagerClient::StopServiceAbility(const Want &want)
 }
 
 sptr<IAbilityScheduler> AbilityManagerClient::AcquireDataAbility(
-    const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken)
+    const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken)
 {
     remoteObject_ =
         OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
@@ -196,7 +196,7 @@ sptr<IAbilityScheduler> AbilityManagerClient::AcquireDataAbility(
 }
 
 ErrCode AbilityManagerClient::ReleaseDataAbility(
-    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken)
+    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken)
 {
     remoteObject_ =
         OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);

test/mock/frameworks_kits_test/AMS/mock_ability_manager_service.cpp

@@ -33,7 +33,7 @@ MockAbilityManagerService::MockAbilityManagerService() : abilityScheduler_(nullp
 MockAbilityManagerService::~MockAbilityManagerService()
 {}
 
-int MockAbilityManagerService::StartAbility(const Want &want, int32_t userId, int requestCode)
+int MockAbilityManagerService::StartAbility(const Want& want, int32_t userId, int requestCode)
 {
     GTEST_LOG_(INFO) << "MockAbilityManagerService::StartAbility called";
     curstate_ = AbilityLifeCycleState::ABILITY_STATE_INITIAL;
@@ -65,14 +65,14 @@ int MockAbilityManagerService::StartAbility(const Want &want, int32_t userId, in
     return 0;
 }
 
-int MockAbilityManagerService::StartAbility(const Want &want, const sptr<IRemoteObject> &callerToken,
+int MockAbilityManagerService::StartAbility(const Want& want, const sptr<IRemoteObject>& callerToken,
     int32_t userId, int requestCode)
 {
     return 0;
 }
 
 int MockAbilityManagerService::TerminateAbility(
-    const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+    const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     GTEST_LOG_(INFO) << "MockAbilityManagerService::TerminateAbility";
 
@@ -89,7 +89,7 @@ int MockAbilityManagerService::TerminateAbility(
 }
 
 int MockAbilityManagerService::ConnectAbility(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken, int32_t userId)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken, int32_t userId)
 {
     if (abilityScheduler_ != nullptr) {
         PacMap inState;
@@ -99,7 +99,7 @@ int MockAbilityManagerService::ConnectAbility(
     return 0;
 }
 
-int MockAbilityManagerService::DisconnectAbility(const sptr<IAbilityConnection> &connect)
+int MockAbilityManagerService::DisconnectAbility(const sptr<IAbilityConnection>& connect)
 {
     GTEST_LOG_(INFO) << "MockAbilityManagerService::DisconnectAbility";
     AbilityLifeCycleState lifeState = AbilityLifeCycleState::ABILITY_STATE_ACTIVE;
@@ -116,14 +116,14 @@ int MockAbilityManagerService::DisconnectAbility(const sptr<IAbilityConnection>
 }
 
 int MockAbilityManagerService::AttachAbilityThread(
-    const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
+    const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token)
 {
     abilityScheduler_ = scheduler;
     EXPECT_NE(nullptr, token);
     return 0;
 }
 
-void MockAbilityManagerService::DumpState(const std::string &args, std::vector<std::string> &info)
+void MockAbilityManagerService::DumpState(const std::string& args, std::vector<std::string>& info)
 {}
 
 void MockAbilityManagerService::DumpSysState(
@@ -131,45 +131,45 @@ void MockAbilityManagerService::DumpSysState(
 {}
 
 int MockAbilityManagerService::AbilityTransitionDone(
-    const sptr<IRemoteObject> &token, int state, const PacMap &saveData)
+    const sptr<IRemoteObject>& token, int state, const PacMap& saveData)
 {
     GTEST_LOG_(INFO) << "MockAbilityManagerService::AbilityTransitionDone called";
     return 0;
 }
 
 int MockAbilityManagerService::ScheduleConnectAbilityDone(
-    const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
+    const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject)
 {
     return 0;
 }
 
-int MockAbilityManagerService::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token)
+int MockAbilityManagerService::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token)
 {
     return 0;
 }
 
-int MockAbilityManagerService::ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token)
+int MockAbilityManagerService::ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token)
 {
     return 0;
 }
 
-int MockAbilityManagerService::TerminateAbilityByCaller(const sptr<IRemoteObject> &callerToken, int requestCode)
+int MockAbilityManagerService::TerminateAbilityByCaller(const sptr<IRemoteObject>& callerToken, int requestCode)
 {
     return 0;
 }
 
-int MockAbilityManagerService::TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId)
+int MockAbilityManagerService::TerminateAbilityResult(const sptr<IRemoteObject>& token, int startId)
 {
     return 0;
 }
 
-int MockAbilityManagerService::StopServiceAbility(const Want &want, int32_t userId)
+int MockAbilityManagerService::StopServiceAbility(const Want& want, int32_t userId)
 {
     return 0;
 }
 
 sptr<IAbilityScheduler> MockAbilityManagerService::AcquireDataAbility(
-    const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken)
+    const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken)
 {
     if (abilityScheduler_ != nullptr) {
         return abilityScheduler_;
@@ -178,7 +178,7 @@ sptr<IAbilityScheduler> MockAbilityManagerService::AcquireDataAbility(
 }
 
 ErrCode MockAbilityManagerService::ReleaseDataAbility(
-    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken)
+    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken)
 {
     if (abilityScheduler_ != nullptr) {
         abilityScheduler_ = nullptr;

test/mock/frameworks_kits_test/AMS/mock_ability_manager_service.h

@@ -31,111 +31,111 @@ namespace AAFwk {
 enum class ServiceRunningState { STATE_NOT_START, STATE_RUNNING };
 
 class MockAbilityManagerService : public AbilityManagerStub,
-                                  public std::enable_shared_from_this<MockAbilityManagerService> {
+    public std::enable_shared_from_this<MockAbilityManagerService> {
 public:
     MockAbilityManagerService();
     ~MockAbilityManagerService();
-    int StartAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = -1) override;
-    int StartAbility(const Want &want,
-        const sptr<IRemoteObject> &callerToken,
+    int StartAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = -1) override;
+    int StartAbility(const Want& want,
+        const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE,
         int requestCode = -1) override;
     int StartAbility(
-        const Want &want,
-        const StartOptions &startOptions,
-        const sptr<IRemoteObject> &callerToken,
+        const Want& want,
+        const StartOptions& startOptions,
+        const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE,
         int requestCode = DEFAULT_INVAL_VALUE) override
     {
         return 0;
     }
     int TerminateAbility(
-        const sptr<IRemoteObject> &token, int resultCode = -1, const Want *resultWant = nullptr) override;
-    int CloseAbility(const sptr<IRemoteObject> &token, int resultCode = DEFAULT_INVAL_VALUE,
-        const Want *resultWant = nullptr) override
+        const sptr<IRemoteObject>& token, int resultCode = -1, const Want* resultWant = nullptr) override;
+    int CloseAbility(const sptr<IRemoteObject>& token, int resultCode = DEFAULT_INVAL_VALUE,
+        const Want* resultWant = nullptr) override
     {
         return 0;
     }
-    int MinimizeAbility(const sptr<IRemoteObject> &token, bool fromUser) override
+    int MinimizeAbility(const sptr<IRemoteObject>& token, bool fromUser) override
     {
         return 0;
     }
     int ConnectAbility(
-        const Want &want,
-        const sptr<IAbilityConnection> &connect,
-        const sptr<IRemoteObject> &callerToken,
+        const Want& want,
+        const sptr<IAbilityConnection>& connect,
+        const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE) override;
-    int DisconnectAbility(const sptr<IAbilityConnection> &connect) override;
+    int DisconnectAbility(const sptr<IAbilityConnection>& connect) override;
 
-    sptr<IAbilityScheduler> AcquireDataAbility(const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken);
+    sptr<IAbilityScheduler> AcquireDataAbility(const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken);
 
-    ErrCode ReleaseDataAbility(sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken);
+    ErrCode ReleaseDataAbility(sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken);
 
-    int AttachAbilityThread(const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token) override;
+    int AttachAbilityThread(const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token) override;
 
-    int AbilityTransitionDone(const sptr<IRemoteObject> &token, int state, const PacMap &saveData) override;
-    int ScheduleConnectAbilityDone(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject) override;
-    int ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token) override;
-    int ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token) override;
+    int AbilityTransitionDone(const sptr<IRemoteObject>& token, int state, const PacMap& saveData) override;
+    int ScheduleConnectAbilityDone(const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject) override;
+    int ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token) override;
+    int ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token) override;
 
-    void DumpState(const std::string &args, std::vector<std::string> &info) override;
+    void DumpState(const std::string& args, std::vector<std::string>& info) override;
     void DumpSysState(
-        const std::string &args, std::vector<std::string> &state, bool isClient, bool isUserID, int UserID) override;
-    int TerminateAbilityByCaller(const sptr<IRemoteObject> &callerToken, int requestCode) override;
-    int TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId) override;
-    int StopServiceAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE) override;
+        const std::string& args, std::vector<std::string>& state, bool isClient, bool isUserID, int UserID) override;
+    int TerminateAbilityByCaller(const sptr<IRemoteObject>& callerToken, int requestCode) override;
+    int TerminateAbilityResult(const sptr<IRemoteObject>& token, int startId) override;
+    int StopServiceAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE) override;
 
-    MOCK_METHOD1(KillProcess, int(const std::string &bundleName));
-    MOCK_METHOD2(UninstallApp, int(const std::string &bundleName, int32_t uid));
+    MOCK_METHOD1(KillProcess, int(const std::string& bundleName));
+    MOCK_METHOD2(UninstallApp, int(const std::string& bundleName, int32_t uid));
     MOCK_METHOD2(
-        GetWantSender, sptr<IWantSender>(const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken));
-    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender> &target, const SenderInfo &senderInfo));
-    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender> &sender));
-    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender> &target));
-    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender> &target, std::shared_ptr<Want> &want));
-    MOCK_METHOD5(StartAbility, int(const Want &want, const AbilityStartSetting &abilityStartSetting,
-        const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode));
+        GetWantSender, sptr<IWantSender>(const WantSenderInfo& wantSenderInfo, const sptr<IRemoteObject>& callerToken));
+    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender>& target, const SenderInfo& senderInfo));
+    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender>& sender));
+    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender>& target));
+    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender>& target, std::shared_ptr<Want>& want));
+    MOCK_METHOD5(StartAbility, int(const Want& want, const AbilityStartSetting& abilityStartSetting,
+        const sptr<IRemoteObject>& callerToken, int32_t userId, int requestCode));
     MOCK_METHOD1(GetPendinTerminateAbilityTestgRequestWant, void(int id));
-    MOCK_METHOD3(StartContinuation, int(const Want &want, const sptr<IRemoteObject> &abilityToken, int32_t status));
+    MOCK_METHOD3(StartContinuation, int(const Want& want, const sptr<IRemoteObject>& abilityToken, int32_t status));
     MOCK_METHOD2(NotifyContinuationResult, int(int32_t missionId, int32_t result));
-    MOCK_METHOD5(ContinueMission, int(const std::string &srcDeviceId, const std::string &dstDeviceId,
-        int32_t missionId, const sptr<IRemoteObject> &callBack, AAFwk::WantParams &wantParams));
-    MOCK_METHOD3(ContinueAbility, int(const std::string &deviceId, int32_t missionId, uint32_t versionCode));
-    MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string &deviceId, int32_t sessionId, bool isSuccess));
+    MOCK_METHOD5(ContinueMission, int(const std::string& srcDeviceId, const std::string& dstDeviceId,
+        int32_t missionId, const sptr<IRemoteObject>& callBack, AAFwk::WantParams& wantParams));
+    MOCK_METHOD3(ContinueAbility, int(const std::string& deviceId, int32_t missionId, uint32_t versionCode));
+    MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string& deviceId, int32_t sessionId, bool isSuccess));
 
     MOCK_METHOD1(LockMissionForCleanup, int(int32_t missionId));
     MOCK_METHOD1(UnlockMissionForCleanup, int(int32_t missionId));
-    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener> &listener));
-    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener> &listener));
+    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener>& listener));
+    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener>& listener));
     MOCK_METHOD3(
-        GetMissionInfos, int(const std::string &deviceId, int32_t numMax, std::vector<MissionInfo> &missionInfos));
-    MOCK_METHOD3(GetMissionInfo, int(const std::string &deviceId, int32_t missionId, MissionInfo &missionInfo));
+        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo>& missionInfos));
+    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo& missionInfo));
     MOCK_METHOD1(CleanMission, int(int32_t missionId));
     MOCK_METHOD0(CleanAllMissions, int());
     MOCK_METHOD1(MoveMissionToFront, int(int32_t missionId));
-    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions &startOptions));
-    MOCK_METHOD2(SetMissionLabel, int(const sptr<IRemoteObject> &token, const std::string &label));
-    MOCK_METHOD2(SetMissionIcon, int(const sptr<IRemoteObject> &token,
-        const std::shared_ptr<OHOS::Media::PixelMap> &icon));
-    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender> &target, std::shared_ptr<WantSenderInfo> &info));
-    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo> &info));
-    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo> &info));
-    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo> &info));
-    MOCK_METHOD3(StartAbilityByCall, int(const Want &, const sptr<IAbilityConnection> &, const sptr<IRemoteObject> &));
-    MOCK_METHOD1(GetMissionIdByToken, int32_t(const sptr<IRemoteObject> &token));
-    #ifdef ABILITY_COMMAND_FOR_TEST
+    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions& startOptions));
+    MOCK_METHOD2(SetMissionLabel, int(const sptr<IRemoteObject>& token, const std::string& label));
+    MOCK_METHOD2(SetMissionIcon, int(const sptr<IRemoteObject>& token,
+        const std::shared_ptr<OHOS::Media::PixelMap>& icon));
+    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender>& target, std::shared_ptr<WantSenderInfo>& info));
+    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo>& info));
+    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo>& info));
+    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo>& info));
+    MOCK_METHOD3(StartAbilityByCall, int(const Want&, const sptr<IAbilityConnection>&, const sptr<IRemoteObject>&));
+    MOCK_METHOD1(GetMissionIdByToken, int32_t(const sptr<IRemoteObject>& token));
+#ifdef ABILITY_COMMAND_FOR_TEST
     MOCK_METHOD0(BlockAppService, int());
     MOCK_METHOD0(BlockAmsService, int());
     MOCK_METHOD1(BlockAbility, int(int32_t abilityRecordId));
-    #endif
+#endif
 
-    int ClearUpApplicationData(const std::string &bundleName) override
+    int ClearUpApplicationData(const std::string& bundleName) override
     {
         return 0;
     }
@@ -145,38 +145,38 @@ public:
         return 0;
     }
 
-    int StopUser(int userId, const sptr<IStopUserCallback> &callback) override
+    int StopUser(int userId, const sptr<IStopUserCallback>& callback) override
     {
         return 0;
     }
 
-    int StartSyncRemoteMissions(const std::string &devId, bool fixConflict, int64_t tag) override
+    int StartSyncRemoteMissions(const std::string& devId, bool fixConflict, int64_t tag) override
     {
         return 0;
     }
 
-    int StopSyncRemoteMissions(const std::string &devId) override
+    int StopSyncRemoteMissions(const std::string& devId) override
     {
         return 0;
     }
-    int RegisterMissionListener(const std::string &deviceId,
-        const sptr<IRemoteMissionListener> &listener) override
+    int RegisterMissionListener(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener) override
     {
         return 0;
     }
-    int UnRegisterMissionListener(const std::string &deviceId,
-        const sptr<IRemoteMissionListener> &listener) override
+    int UnRegisterMissionListener(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener) override
     {
         return 0;
     }
 
-    int ReleaseCall(const sptr<IAbilityConnection> &connect,
-        const AppExecFwk::ElementName &element) override
+    int ReleaseCall(const sptr<IAbilityConnection>& connect,
+        const AppExecFwk::ElementName& element) override
     {
         return 0;
     }
-    virtual int GetMissionSnapshot(const std::string &deviceId, int32_t missionId,
-        MissionSnapshot &snapshot, bool isLowResolution)
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution)
     {
         return 0;
     }
@@ -184,11 +184,11 @@ public:
     {
         return;
     }
-    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler> &handler)
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
     {
         return 0;
     }
-    int SetAbilityController(const sptr<AppExecFwk::IAbilityController> &abilityController,
+    int SetAbilityController(const sptr<AppExecFwk::IAbilityController>& abilityController,
         bool imAStabilityTest) override
     {
         return 0;
@@ -204,45 +204,45 @@ public:
         return 0;
     }
 
-    int StartUserTest(const Want &want, const sptr<IRemoteObject> &observer) override
+    int StartUserTest(const Want& want, const sptr<IRemoteObject>& observer) override
     {
         return 0;
     }
 
     int FinishUserTest(
-        const std::string &msg, const int64_t &resultCode, const std::string &bundleName) override
+        const std::string& msg, const int64_t& resultCode, const std::string& bundleName) override
     {
         return 0;
     }
 
-    int GetTopAbility(sptr<IRemoteObject> &token) override
+    int GetTopAbility(sptr<IRemoteObject>& token) override
     {
         return 0;
     }
 
-    int DelegatorDoAbilityForeground(const sptr<IRemoteObject> &token) override
+    int DelegatorDoAbilityForeground(const sptr<IRemoteObject>& token) override
     {
         return 0;
     }
 
-    int DelegatorDoAbilityBackground(const sptr<IRemoteObject> &token) override
+    int DelegatorDoAbilityBackground(const sptr<IRemoteObject>& token) override
     {
         return 0;
     }
 
-    int RegisterWindowManagerServiceHandler(const sptr<IWindowManagerServiceHandler> &handler) override
+    int RegisterWindowManagerServiceHandler(const sptr<IWindowManagerServiceHandler>& handler) override
     {
         return 0;
     }
 
-    void CompleteFirstFrameDrawing(const sptr<IRemoteObject> &abilityToken) override {}
+    void CompleteFirstFrameDrawing(const sptr<IRemoteObject>& abilityToken) override {}
 
-    #ifdef ABILITY_COMMAND_FOR_TEST
-    int ForceTimeoutForTest(const std::string &abilityName, const std::string &state) override
+#ifdef ABILITY_COMMAND_FOR_TEST
+    int ForceTimeoutForTest(const std::string& abilityName, const std::string& state) override
     {
         return 0;
     }
-    #endif
+#endif
 
     AbilityLifeCycleState curstate_ = AbilityLifeCycleState::ABILITY_STATE_INITIAL;
     sptr<IAbilityScheduler> abilityScheduler_;  // kit interface used to schedule ability life

test/mock/frameworks_kits_test/AMS/mock_serviceability_manager_service.cpp

@@ -31,7 +31,7 @@ MockServiceAbilityManagerService::MockServiceAbilityManagerService()
 MockServiceAbilityManagerService::~MockServiceAbilityManagerService()
 {}
 
-int MockServiceAbilityManagerService::StartAbility(const Want &want, int32_t userId, int requestCode)
+int MockServiceAbilityManagerService::StartAbility(const Want& want, int32_t userId, int requestCode)
 {
     GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::StartAbility";
     if (abilityScheduler_ != nullptr) {
@@ -46,13 +46,13 @@ int MockServiceAbilityManagerService::StartAbility(const Want &want, int32_t use
 }
 
 int MockServiceAbilityManagerService::StartAbility(
-    const Want &want, const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode)
+    const Want& want, const sptr<IRemoteObject>& callerToken, int32_t userId, int requestCode)
 {
     return 0;
 }
 
 int MockServiceAbilityManagerService::TerminateAbility(
-    const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
+    const sptr<IRemoteObject>& token, int resultCode, const Want* resultWant)
 {
     GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::TerminateAbility";
     if (abilityScheduler_ != nullptr) {
@@ -67,7 +67,7 @@ int MockServiceAbilityManagerService::TerminateAbility(
 }
 
 int MockServiceAbilityManagerService::ConnectAbility(
-    const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken, int32_t userId)
+    const Want& want, const sptr<IAbilityConnection>& connect, const sptr<IRemoteObject>& callerToken, int32_t userId)
 {
     GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::connectAbility";
     if (abilityScheduler_ != nullptr) {
@@ -81,7 +81,7 @@ int MockServiceAbilityManagerService::ConnectAbility(
     return -1;
 }
 
-int MockServiceAbilityManagerService::DisconnectAbility(const sptr<IAbilityConnection> &connect)
+int MockServiceAbilityManagerService::DisconnectAbility(const sptr<IAbilityConnection>& connect)
 {
     GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::DisconnectAbility";
     if (abilityScheduler_ != nullptr) {
@@ -94,14 +94,14 @@ int MockServiceAbilityManagerService::DisconnectAbility(const sptr<IAbilityConne
 }
 
 int MockServiceAbilityManagerService::AttachAbilityThread(
-    const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
+    const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token)
 {
     abilityScheduler_ = scheduler;
     EXPECT_NE(nullptr, token);
     return 0;
 }
 
-void MockServiceAbilityManagerService::DumpState(const std::string &args, std::vector<std::string> &info)
+void MockServiceAbilityManagerService::DumpState(const std::string& args, std::vector<std::string>& info)
 {}
 
 void MockServiceAbilityManagerService::DumpSysState(
@@ -109,7 +109,7 @@ void MockServiceAbilityManagerService::DumpSysState(
 {}
 
 int MockServiceAbilityManagerService::AbilityTransitionDone(
-    const sptr<IRemoteObject> &token, int state, const PacMap &saveData)
+    const sptr<IRemoteObject>& token, int state, const PacMap& saveData)
 {
     GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::AbilityTransitionDone startAbility is " << startAbility;
     want_.SetElementName("BundleName", "abilityName");
@@ -125,13 +125,13 @@ int MockServiceAbilityManagerService::AbilityTransitionDone(
 }
 
 int MockServiceAbilityManagerService::ScheduleConnectAbilityDone(
-    const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
+    const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject)
 {
     GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::ScheduleConnectAbilityDone";
     return 0;
 }
 
-int MockServiceAbilityManagerService::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token)
+int MockServiceAbilityManagerService::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token)
 {
     GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::ScheduleDisconnectAbilityDone";
 
@@ -144,22 +144,22 @@ int MockServiceAbilityManagerService::ScheduleDisconnectAbilityDone(const sptr<I
     return 0;
 }
 
-int MockServiceAbilityManagerService::ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token)
+int MockServiceAbilityManagerService::ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token)
 {
     return 0;
 }
 
-int MockServiceAbilityManagerService::TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId)
+int MockServiceAbilityManagerService::TerminateAbilityResult(const sptr<IRemoteObject>& token, int startId)
 {
     return 0;
 }
 
-int MockServiceAbilityManagerService::TerminateAbilityByCaller(const sptr<IRemoteObject> &callerToken, int requestCode)
+int MockServiceAbilityManagerService::TerminateAbilityByCaller(const sptr<IRemoteObject>& callerToken, int requestCode)
 {
     return 0;
 }
 
-int MockServiceAbilityManagerService::StopServiceAbility(const Want &want, int32_t userId)
+int MockServiceAbilityManagerService::StopServiceAbility(const Want& want, int32_t userId)
 {
     GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::StopServiceAbility";
     if (abilityScheduler_ != nullptr) {

test/mock/frameworks_kits_test/AMS/mock_serviceability_manager_service.h

@@ -30,126 +30,126 @@ namespace OHOS {
 namespace AAFwk {
 enum class ServiceRunningState { STATE_NOT_START, STATE_RUNNING };
 class MockServiceAbilityManagerService : public AbilityManagerStub,
-                                         public std::enable_shared_from_this<MockServiceAbilityManagerService> {
+    public std::enable_shared_from_this<MockServiceAbilityManagerService> {
 public:
     MockServiceAbilityManagerService();
     ~MockServiceAbilityManagerService();
     int StartAbility(
-        const Want &want,
+        const Want& want,
         int32_t userId = DEFAULT_INVAL_VALUE,
         int requestCode = DEFAULT_INVAL_VALUE) override;
     int StartAbility(
-        const Want &want,
-        const sptr<IRemoteObject> &callerToken,
+        const Want& want,
+        const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE,
         int requestCode = DEFAULT_INVAL_VALUE) override;
     int StartAbility(
-        const Want &want,
-        const StartOptions &startOptions,
-        const sptr<IRemoteObject> &callerToken,
+        const Want& want,
+        const StartOptions& startOptions,
+        const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE,
         int requestCode = DEFAULT_INVAL_VALUE) override
     {
         return 0;
     }
     int TerminateAbility(
-        const sptr<IRemoteObject> &token, int resultCode = -1, const Want *resultWant = nullptr) override;
-    int CloseAbility(const sptr<IRemoteObject> &token, int resultCode = DEFAULT_INVAL_VALUE,
-        const Want *resultWant = nullptr) override
+        const sptr<IRemoteObject>& token, int resultCode = -1, const Want* resultWant = nullptr) override;
+    int CloseAbility(const sptr<IRemoteObject>& token, int resultCode = DEFAULT_INVAL_VALUE,
+        const Want* resultWant = nullptr) override
     {
         return 0;
     }
-    int MinimizeAbility(const sptr<IRemoteObject> &token, bool fromUser) override
+    int MinimizeAbility(const sptr<IRemoteObject>& token, bool fromUser) override
     {
         return 0;
     }
     int ConnectAbility(
-        const Want &want,
-        const sptr<IAbilityConnection> &connect,
-        const sptr<IRemoteObject> &callerToken,
+        const Want& want,
+        const sptr<IAbilityConnection>& connect,
+        const sptr<IRemoteObject>& callerToken,
         int32_t userId = DEFAULT_INVAL_VALUE) override;
-    int DisconnectAbility(const sptr<IAbilityConnection> &connect) override;
+    int DisconnectAbility(const sptr<IAbilityConnection>& connect) override;
 
-    int AttachAbilityThread(const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token) override;
+    int AttachAbilityThread(const sptr<IAbilityScheduler>& scheduler, const sptr<IRemoteObject>& token) override;
 
-    int AbilityTransitionDone(const sptr<IRemoteObject> &token, int state, const PacMap &saveData) override;
-    int ScheduleConnectAbilityDone(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject) override;
-    int ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token) override;
-    int ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token) override;
+    int AbilityTransitionDone(const sptr<IRemoteObject>& token, int state, const PacMap& saveData) override;
+    int ScheduleConnectAbilityDone(const sptr<IRemoteObject>& token, const sptr<IRemoteObject>& remoteObject) override;
+    int ScheduleDisconnectAbilityDone(const sptr<IRemoteObject>& token) override;
+    int ScheduleCommandAbilityDone(const sptr<IRemoteObject>& token) override;
 
-    void DumpState(const std::string &args, std::vector<std::string> &info) override;
+    void DumpState(const std::string& args, std::vector<std::string>& info) override;
     void DumpSysState(
         const std::string& args, std::vector<std::string>& state, bool isClient, bool isUserID, int UserID) override;
 
-    int TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId) override;
-    int StopServiceAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE) override;
+    int TerminateAbilityResult(const sptr<IRemoteObject>& token, int startId) override;
+    int StopServiceAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE) override;
 
-    int TerminateAbilityByCaller(const sptr<IRemoteObject> &callerToken, int requestCode) override;
+    int TerminateAbilityByCaller(const sptr<IRemoteObject>& callerToken, int requestCode) override;
 
-    MOCK_METHOD1(KillProcess, int(const std::string &bundleName));
-    MOCK_METHOD2(UninstallApp, int(const std::string &bundleName, int32_t uid));
+    MOCK_METHOD1(KillProcess, int(const std::string& bundleName));
+    MOCK_METHOD2(UninstallApp, int(const std::string& bundleName, int32_t uid));
     MOCK_METHOD2(
-        GetWantSender, sptr<IWantSender>(const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken));
-    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender> &target, const SenderInfo &senderInfo));
-    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender> &sender));
-    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender> &target));
-    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender> &target, std::shared_ptr<Want> &want));
-    MOCK_METHOD5(StartAbility, int(const Want &want, const AbilityStartSetting &abilityStartSetting,
-        const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode));
+        GetWantSender, sptr<IWantSender>(const WantSenderInfo& wantSenderInfo, const sptr<IRemoteObject>& callerToken));
+    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender>& target, const SenderInfo& senderInfo));
+    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender>& sender));
+    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender>& target));
+    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender>& target));
+    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender>& sender, const sptr<IWantReceiver>& receiver));
+    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender>& target, std::shared_ptr<Want>& want));
+    MOCK_METHOD5(StartAbility, int(const Want& want, const AbilityStartSetting& abilityStartSetting,
+        const sptr<IRemoteObject>& callerToken, int32_t userId, int requestCode));
     MOCK_METHOD1(GetPendinTerminateAbilityTestgRequestWant, void(int id));
-    MOCK_METHOD3(StartContinuation, int(const Want &want, const sptr<IRemoteObject> &abilityToken, int32_t status));
+    MOCK_METHOD3(StartContinuation, int(const Want& want, const sptr<IRemoteObject>& abilityToken, int32_t status));
     MOCK_METHOD2(NotifyContinuationResult, int(int32_t missionId, int32_t result));
-    MOCK_METHOD5(ContinueMission, int(const std::string &srcDeviceId, const std::string &dstDeviceId,
-        int32_t missionId, const sptr<IRemoteObject> &callBack, AAFwk::WantParams &wantParams));
-    MOCK_METHOD3(ContinueAbility, int(const std::string &deviceId, int32_t missionId, uint32_t versionCode));
-    MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string &deviceId, int32_t sessionId, bool isSuccess));
+    MOCK_METHOD5(ContinueMission, int(const std::string& srcDeviceId, const std::string& dstDeviceId,
+        int32_t missionId, const sptr<IRemoteObject>& callBack, AAFwk::WantParams& wantParams));
+    MOCK_METHOD3(ContinueAbility, int(const std::string& deviceId, int32_t missionId, uint32_t versionCode));
+    MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string& deviceId, int32_t sessionId, bool isSuccess));
 
     MOCK_METHOD1(LockMissionForCleanup, int(int32_t missionId));
     MOCK_METHOD1(UnlockMissionForCleanup, int(int32_t missionId));
-    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener> &listener));
-    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener> &listener));
+    MOCK_METHOD1(RegisterMissionListener, int(const sptr<IMissionListener>& listener));
+    MOCK_METHOD1(UnRegisterMissionListener, int(const sptr<IMissionListener>& listener));
     MOCK_METHOD3(
-        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo> &missionInfos));
-    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo &missionInfo));
-    MOCK_METHOD1(GetMissionIdByToken, int32_t(const sptr<IRemoteObject> &token));
+        GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector<MissionInfo>& missionInfos));
+    MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo& missionInfo));
+    MOCK_METHOD1(GetMissionIdByToken, int32_t(const sptr<IRemoteObject>& token));
     MOCK_METHOD1(CleanMission, int(int32_t missionId));
     MOCK_METHOD0(CleanAllMissions, int());
     MOCK_METHOD1(MoveMissionToFront, int(int32_t missionId));
-    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions &startOptions));
-    MOCK_METHOD2(SetMissionLabel, int(const sptr<IRemoteObject> &token, const std::string &label));
-    MOCK_METHOD2(SetMissionIcon, int(const sptr<IRemoteObject> &token,
-        const std::shared_ptr<OHOS::Media::PixelMap> &icon));
-    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender> &target, std::shared_ptr<WantSenderInfo> &info));
-    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo> &info));
-    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo> &info));
-    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo> &info));
-    MOCK_METHOD3(StartAbilityByCall, int(const Want &, const sptr<IAbilityConnection> &, const sptr<IRemoteObject> &));
+    MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions& startOptions));
+    MOCK_METHOD2(SetMissionLabel, int(const sptr<IRemoteObject>& token, const std::string& label));
+    MOCK_METHOD2(SetMissionIcon, int(const sptr<IRemoteObject>& token,
+        const std::shared_ptr<OHOS::Media::PixelMap>& icon));
+    MOCK_METHOD2(GetWantSenderInfo, int(const sptr<IWantSender>& target, std::shared_ptr<WantSenderInfo>& info));
+    MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector<AbilityRunningInfo>& info));
+    MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector<ExtensionRunningInfo>& info));
+    MOCK_METHOD1(GetProcessRunningInfos, int(std::vector<AppExecFwk::RunningProcessInfo>& info));
+    MOCK_METHOD3(StartAbilityByCall, int(const Want&, const sptr<IAbilityConnection>&, const sptr<IRemoteObject>&));
 
-    #ifdef ABILITY_COMMAND_FOR_TEST
+#ifdef ABILITY_COMMAND_FOR_TEST
     MOCK_METHOD0(BlockAppService, int());
     MOCK_METHOD0(BlockAmsService, int());
     MOCK_METHOD1(BlockAbility, int(int32_t abilityRecordId));
-    #endif
+#endif
 
     sptr<IAbilityScheduler> AcquireDataAbility(
-        const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken) override
+        const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken) override
     {
         return nullptr;
     }
 
     int ReleaseDataAbility(
-        sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken) override
+        sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken) override
     {
         return 0;
     }
 
-    int ClearUpApplicationData(const std::string &bundleName) override
+    int ClearUpApplicationData(const std::string& bundleName) override
     {
         return 0;
     }
@@ -159,7 +159,7 @@ public:
         return 0;
     }
 
-    int StopUser(int userId, const sptr<IStopUserCallback> &callback) override
+    int StopUser(int userId, const sptr<IStopUserCallback>& callback) override
     {
         return 0;
     }
@@ -171,18 +171,18 @@ public:
     {
         return 0;
     }
-    int RegisterMissionListener(const std::string &deviceId,
-        const sptr<IRemoteMissionListener> &listener) override
+    int RegisterMissionListener(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener) override
     {
         return 0;
     }
-    int UnRegisterMissionListener(const std::string &deviceId,
-        const sptr<IRemoteMissionListener> &listener) override
+    int UnRegisterMissionListener(const std::string& deviceId,
+        const sptr<IRemoteMissionListener>& listener) override
     {
         return 0;
     }
-    int ReleaseCall(const sptr<IAbilityConnection> &connect,
-        const AppExecFwk::ElementName &element) override
+    int ReleaseCall(const sptr<IAbilityConnection>& connect,
+        const AppExecFwk::ElementName& element) override
     {
         return 0;
     }
@@ -203,7 +203,7 @@ public:
         return 0;
     }
 
-    int SetAbilityController(const sptr<AppExecFwk::IAbilityController> &abilityController,
+    int SetAbilityController(const sptr<AppExecFwk::IAbilityController>& abilityController,
         bool imAStabilityTest) override
     {
         return 0;
@@ -219,28 +219,28 @@ public:
         return 0;
     }
 
-    int StartUserTest(const Want &want, const sptr<IRemoteObject> &observer) override
+    int StartUserTest(const Want& want, const sptr<IRemoteObject>& observer) override
     {
         return 0;
     }
 
     int FinishUserTest(
-        const std::string &msg, const int64_t &resultCode, const std::string &bundleName) override
+        const std::string& msg, const int64_t& resultCode, const std::string& bundleName) override
     {
         return 0;
     }
 
-    int GetTopAbility(sptr<IRemoteObject> &token) override
+    int GetTopAbility(sptr<IRemoteObject>& token) override
     {
         return 0;
     }
 
-    int DelegatorDoAbilityForeground(const sptr<IRemoteObject> &token) override
+    int DelegatorDoAbilityForeground(const sptr<IRemoteObject>& token) override
     {
         return 0;
     }
 
-    int DelegatorDoAbilityBackground(const sptr<IRemoteObject> &token) override
+    int DelegatorDoAbilityBackground(const sptr<IRemoteObject>& token) override
     {
         return 0;
     }
@@ -250,14 +250,14 @@ public:
         return 0;
     }
 
-    void CompleteFirstFrameDrawing(const sptr<IRemoteObject> &abilityToken) override {}
+    void CompleteFirstFrameDrawing(const sptr<IRemoteObject>& abilityToken) override {}
 
-    #ifdef ABILITY_COMMAND_FOR_TEST
-    int ForceTimeoutForTest(const std::string &abilityName, const std::string &state) override
+#ifdef ABILITY_COMMAND_FOR_TEST
+    int ForceTimeoutForTest(const std::string& abilityName, const std::string& state) override
     {
         return 0;
     }
-    #endif
+#endif
 
     sptr<IAbilityScheduler> abilityScheduler_ = nullptr;  // kit interface used to schedule ability life
     Want want_;

test/mock/frameworks_kits_test/DemoAbility/demo_ability_test.cpp

@@ -33,7 +33,7 @@ const int resultCodeCompare = 1992;
 
 namespace OHOS {
 namespace AppExecFwk {
-void DemoAbility::OnStart(const Want &want)
+void DemoAbility::OnStart(const Want& want)
 {
     GTEST_LOG_(INFO) << "DemoAbility::OnStart called";
     std::shared_ptr<MockLifecycleObserver> observer = std::make_shared<MockLifecycleObserver>();
@@ -66,23 +66,23 @@ void DemoAbility::OnBackground()
     Ability::OnBackground();
 }
 
-void DemoAbility::OnForeground(const Want &want)
+void DemoAbility::OnForeground(const Want& want)
 {
     GTEST_LOG_(INFO) << "DemoAbility::OnForeground called";
     Ability::OnForeground(want);
 }
 
-void DemoAbility::OnNewWant(const Want &want)
+void DemoAbility::OnNewWant(const Want& want)
 {
     GTEST_LOG_(INFO) << "DemoAbility::OnNewWant called";
 }
 
-void DemoAbility::OnRestoreAbilityState(const PacMap &inState)
+void DemoAbility::OnRestoreAbilityState(const PacMap& inState)
 {
     GTEST_LOG_(INFO) << "DemoAbility::OnRestoreAbilityState called";
 }
 
-void DemoAbility::OnSaveAbilityState(PacMap &outState)
+void DemoAbility::OnSaveAbilityState(PacMap& outState)
 {
     std::shared_ptr<ApplicationInfo> appInfo = GetApplicationInfo();
     std::shared_ptr<AbilityInfo> abilityInfo = GetAbilityInfo();
@@ -107,13 +107,13 @@ void DemoAbility::OnSaveAbilityState(PacMap &outState)
     GTEST_LOG_(INFO) << "DemoAbility::OnSaveAbilityState called";
 }
 
-void DemoAbility::OnAbilityResult(int requestCode, int resultCode, const Want &resultData)
+void DemoAbility::OnAbilityResult(int requestCode, int resultCode, const Want& resultData)
 {
     GTEST_LOG_(INFO) << "DemoAbility::OnAbilityResult called";
     EXPECT_EQ(resultCodeCompare, resultCode);
 }
 
-sptr<IRemoteObject> DemoAbility::OnConnect(const Want &want)
+sptr<IRemoteObject> DemoAbility::OnConnect(const Want& want)
 {
     GTEST_LOG_(INFO) << "DemoAbility::OnConnect called";
     Ability::OnConnect(want);
@@ -121,21 +121,21 @@ sptr<IRemoteObject> DemoAbility::OnConnect(const Want &want)
     return nullptr;
 }
 
-void DemoAbility::OnDisconnect(const Want &want)
+void DemoAbility::OnDisconnect(const Want& want)
 {
     GTEST_LOG_(INFO) << "DemoAbility::OnDisconnect called";
     Ability::OnDisconnect(want);
     EXPECT_STREQ(std::string("abilityName").c_str(), want.GetElement().GetAbilityName().c_str());
 }
 
-void DemoAbility::OnCommand(const AAFwk::Want &want, bool restart, int startId)
+void DemoAbility::OnCommand(const AAFwk::Want& want, bool restart, int startId)
 {
     GTEST_LOG_(INFO) << "DemoAbility::OnCommand called";
     EXPECT_STREQ(std::string("abilityName").c_str(), want.GetElement().GetAbilityName().c_str());
     Ability::OnCommand(want, restart, startId);
 }
 
-std::vector<std::string> DemoAbility::GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
+std::vector<std::string> DemoAbility::GetFileTypes(const Uri& uri, const std::string& mimeTypeFilter)
 {
     GTEST_LOG_(INFO) << "DemoAbility::GetFileTypes called";
     std::vector<std::string> types;
@@ -145,50 +145,50 @@ std::vector<std::string> DemoAbility::GetFileTypes(const Uri &uri, const std::st
     return types;
 }
 
-int DemoAbility::OpenFile(const Uri &uri, const std::string &mode)
+int DemoAbility::OpenFile(const Uri& uri, const std::string& mode)
 {
     GTEST_LOG_(INFO) << "DemoAbility::OpenFile called";
     return openfileValue;
 }
 
-int DemoAbility::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
+int DemoAbility::Delete(const Uri& uri, const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "DemoAbility::Delete called";
     return deleteValue;
 }
 
-int DemoAbility::Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
+int DemoAbility::Insert(const Uri& uri, const NativeRdb::ValuesBucket& value)
 {
     GTEST_LOG_(INFO) << "DemoAbility::Insert called";
     return insertValue;
 }
 
 int DemoAbility::Update(
-    const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates)
+    const Uri& uri, const NativeRdb::ValuesBucket& value, const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "DemoAbility::Update called";
     return updateValue;
 }
 
-int DemoAbility::OpenRawFile(const Uri &uri, const std::string &mode)
+int DemoAbility::OpenRawFile(const Uri& uri, const std::string& mode)
 {
     GTEST_LOG_(INFO) << "DemoAbility::OpenRawFile called";
     return openRawFileValue;
 }
 
-bool DemoAbility::Reload(const Uri &uri, const PacMap &extras)
+bool DemoAbility::Reload(const Uri& uri, const PacMap& extras)
 {
     GTEST_LOG_(INFO) << "DemoAbility::Reload called";
     return true;
 }
 
-int DemoAbility::BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values)
+int DemoAbility::BatchInsert(const Uri& uri, const std::vector<NativeRdb::ValuesBucket>& values)
 {
     GTEST_LOG_(INFO) << "DemoAbility::BatchInsert called";
     return batchInsertValue;
 }
 
-std::string DemoAbility::GetType(const Uri &uri)
+std::string DemoAbility::GetType(const Uri& uri)
 {
     GTEST_LOG_(INFO) << "DemoAbility::GetType called";
     std::string type("Type1");
@@ -196,7 +196,7 @@ std::string DemoAbility::GetType(const Uri &uri)
 }
 
 std::shared_ptr<NativeRdb::AbsSharedResultSet> DemoAbility::Query(
-    const Uri &uri, const std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
+    const Uri& uri, const std::vector<std::string>& columns, const NativeRdb::DataAbilityPredicates& predicates)
 {
     GTEST_LOG_(INFO) << "DemoAbility::Query called";
     std::shared_ptr<NativeRdb::AbsSharedResultSet> resultset = std::make_shared<NativeRdb::AbsSharedResultSet>(

test/mock/frameworks_kits_test/DemoAbility/demo_ability_test.h

@@ -23,33 +23,33 @@ namespace OHOS {
 namespace AppExecFwk {
 class DemoAbility : public Ability {
 protected:
-    void OnStart(const Want &want) override;
+    void OnStart(const Want& want) override;
     void OnStop() override;
     void OnActive() override;
     void OnInactive() override;
     void OnBackground() override;
-    void OnForeground(const Want &want) override;
-    void OnNewWant(const Want &want) override;
-    sptr<IRemoteObject> OnConnect(const Want &want) override;
-    void OnDisconnect(const Want &want) override;
-    void OnCommand(const AAFwk::Want &want, bool restart, int startId) override;
+    void OnForeground(const Want& want) override;
+    void OnNewWant(const Want& want) override;
+    sptr<IRemoteObject> OnConnect(const Want& want) override;
+    void OnDisconnect(const Want& want) override;
+    void OnCommand(const AAFwk::Want& want, bool restart, int startId) override;
 
-    void OnRestoreAbilityState(const PacMap &inState);
-    void OnSaveAbilityState(PacMap &outState);
-    void OnAbilityResult(int requestCode, int resultCode, const Want &resultData);
+    void OnRestoreAbilityState(const PacMap& inState);
+    void OnSaveAbilityState(PacMap& outState);
+    void OnAbilityResult(int requestCode, int resultCode, const Want& resultData);
 
-    std::vector<std::string> GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter);
-    int OpenFile(const Uri &uri, const std::string &mode);
-    int Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates);
-    int Insert(const Uri &uri, const NativeRdb::ValuesBucket &value);
+    std::vector<std::string> GetFileTypes(const Uri& uri, const std::string& mimeTypeFilter);
+    int OpenFile(const Uri& uri, const std::string& mode);
+    int Delete(const Uri& uri, const NativeRdb::DataAbilityPredicates& predicates);
+    int Insert(const Uri& uri, const NativeRdb::ValuesBucket& value);
     int Update(
-        const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates);
-    int OpenRawFile(const Uri &uri, const std::string &mode);
-    bool Reload(const Uri &uri, const PacMap &extras);
-    int BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values);
-    std::string GetType(const Uri &uri);
+        const Uri& uri, const NativeRdb::ValuesBucket& value, const NativeRdb::DataAbilityPredicates& predicates);
+    int OpenRawFile(const Uri& uri, const std::string& mode);
+    bool Reload(const Uri& uri, const PacMap& extras);
+    int BatchInsert(const Uri& uri, const std::vector<NativeRdb::ValuesBucket>& values);
+    std::string GetType(const Uri& uri);
     std::shared_ptr<NativeRdb::AbsSharedResultSet> Query(
-        const Uri &uri, const std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates);
+        const Uri& uri, const std::vector<std::string>& columns, const NativeRdb::DataAbilityPredicates& predicates);
 };
 }  // namespace AppExecFwk
 }  // namespace OHOS

test/mock/frameworks_kits_test/DemoAbility/mock_ability_test.h

@@ -33,18 +33,18 @@ namespace AppExecFwk {
 class MockAbilityTest : public Ability {
 public:
 
-    int Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
+    int Insert(const Uri& uri, const NativeRdb::ValuesBucket& value)
     {
         GTEST_LOG_(INFO) << "MockAbilityTest::Insert called";
         return INSERT;
     }
-    int Update(const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates)
+    int Update(const Uri& uri, const NativeRdb::ValuesBucket& value, const NativeRdb::DataAbilityPredicates& predicates)
     {
         GTEST_LOG_(INFO) << "MockAbilityTest::Update called";
         return UPDATE;
     }
 
-    std::vector<std::string> GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
+    std::vector<std::string> GetFileTypes(const Uri& uri, const std::string& mimeTypeFilter)
     {
         std::vector<std::string> result;
         result.push_back("Type1");
@@ -53,11 +53,11 @@ public:
         return result;
     }
 
-    int OpenFile(const Uri &uri, const std::string &mode)
+    int OpenFile(const Uri& uri, const std::string& mode)
     {
         int fd;
         GTEST_LOG_(INFO) << "MockAbilityTest::OpenFile called";
-        FILE *fd1 = fopen("/dataability_openfile_test.txt", "w+");
+        FILE* fd1 = fopen("/dataability_openfile_test.txt", "w+");
         if (fd1 == nullptr) {
             GTEST_LOG_(INFO) << "MockAbilityTest::OpenFile fd1 == nullptr";
             return -1;
@@ -65,7 +65,7 @@ public:
         fputs("123456", fd1);
         fclose(fd1);
 
-        FILE *fd2 = fopen("/dataability_openfile_test.txt", "r");
+        FILE* fd2 = fopen("/dataability_openfile_test.txt", "r");
         if (fd2 == nullptr) {
             GTEST_LOG_(INFO) << "MockAbilityTest::OpenFile fd2 == nullptr";
             return -1;
@@ -75,32 +75,32 @@ public:
         return fd;
     }
 
-    int OpenRawFile(const Uri &uri, const std::string &mode)
+    int OpenRawFile(const Uri& uri, const std::string& mode)
     {
         GTEST_LOG_(INFO) << "MockAbilityTest::OpenRawFile called";
 
         return OPENRAWFILE;
     }
 
-    int BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values)
+    int BatchInsert(const Uri& uri, const std::vector<NativeRdb::ValuesBucket>& values)
     {
         GTEST_LOG_(INFO) << "MockAbilityTest::BatchInsert called";
         return BATCHINSERT;
     }
 
-    bool Reload(const Uri &uri, const PacMap &extras)
+    bool Reload(const Uri& uri, const PacMap& extras)
     {
         GTEST_LOG_(INFO) << "MockAbilityTest::Reload called";
         return true;
     }
 
-    int Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
+    int Delete(const Uri& uri, const NativeRdb::DataAbilityPredicates& predicates)
     {
         GTEST_LOG_(INFO) << "MockAbilityTest::Delete called";
         return DELETE;
     }
 
-    std::string GetType(const Uri &uri)
+    std::string GetType(const Uri& uri)
     {
         GTEST_LOG_(INFO) << "MockAbilityTest::GetType called";
         std::string type("Type1");
@@ -108,7 +108,7 @@ public:
     }
 
     std::shared_ptr<NativeRdb::AbsSharedResultSet> Query(
-        const Uri &uri, const std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
+        const Uri& uri, const std::vector<std::string>& columns, const NativeRdb::DataAbilityPredicates& predicates)
     {
         GTEST_LOG_(INFO) << "MockDataAbility::Query called";
         std::shared_ptr<NativeRdb::AbsSharedResultSet> set = std::make_shared<NativeRdb::AbsSharedResultSet>(
@@ -116,13 +116,13 @@ public:
         return set;
     }
 
-    Uri NormalizeUri(const Uri &uri)
+    Uri NormalizeUri(const Uri& uri)
     {
         GTEST_LOG_(INFO) << "MockAbilityTest::NormalizeUri called";
         return uri;
     }
 
-    Uri DenormalizeUri(const Uri &uri)
+    Uri DenormalizeUri(const Uri& uri)
     {
         GTEST_LOG_(INFO) << "MockAbilityTest::DenormalizeUri called";
         return uri;

test/mock/frameworks_kits_test/DemoAbility/mock_lifecycle_observer.cpp

@@ -28,7 +28,7 @@ void MockLifecycleObserver::OnBackground()
     GTEST_LOG_(INFO) << "MockLifecycleObserver::OnBackground called";
 }
 
-void MockLifecycleObserver::OnForeground(const Want &want)
+void MockLifecycleObserver::OnForeground(const Want& want)
 {
     GTEST_LOG_(INFO) << "MockLifecycleObserver::OnForeground called";
 }
@@ -38,7 +38,7 @@ void MockLifecycleObserver::OnInactive()
     GTEST_LOG_(INFO) << "MockLifecycleObserver::OnInactive called";
 }
 
-void MockLifecycleObserver::OnStart(const Want &want)
+void MockLifecycleObserver::OnStart(const Want& want)
 {
     GTEST_LOG_(INFO) << "MockLifecycleObserver::OnStart called";
 }
@@ -48,7 +48,7 @@ void MockLifecycleObserver::OnStop()
     GTEST_LOG_(INFO) << "MockLifecycleObserver::OnStop called";
 }
 
-void MockLifecycleObserver::OnStateChanged(LifeCycle::Event event, const Want &want)
+void MockLifecycleObserver::OnStateChanged(LifeCycle::Event event, const Want& want)
 {
     GTEST_LOG_(INFO) << "MockLifecycleObserver::OnStateChanged called";
 }

test/mock/frameworks_kits_test/DemoAbility/mock_lifecycle_observer.h

@@ -33,15 +33,15 @@ public:
 
     void OnBackground() override;
 
-    void OnForeground(const Want &want) override;
+    void OnForeground(const Want& want) override;
 
     void OnInactive() override;
 
-    void OnStart(const Want &want) override;
+    void OnStart(const Want& want) override;
 
     void OnStop() override;
 
-    void OnStateChanged(LifeCycle::Event event, const Want &want) override;
+    void OnStateChanged(LifeCycle::Event event, const Want& want) override;
 
     void OnStateChanged(LifeCycle::Event event) override;
 };

test/mock/frameworks_kits_test/DemoObServer/mock_ability_hancle_for_data_observer.h

@@ -23,7 +23,7 @@
 
 namespace OHOS {
 namespace AppExecFwk {
-bool EventHandler::SendEvent(InnerEvent::Pointer &event, int64_t delayTime, Priority priority)
+bool EventHandler::SendEvent(InnerEvent::Pointer& event, int64_t delayTime, Priority priority)
 {
     auto callback = event->GetTaskCallback();
     callback();

test/mock/frameworks_kits_test/DemoObServer/mock_ability_manager_client.h

@@ -42,7 +42,7 @@ public:
 static DemoAbilityManagerClientData demoAbilityMgrClientData;
 
 sptr<AAFwk::IAbilityScheduler> AAFwk::AbilityManagerClient::AcquireDataAbility(
-    const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken)
+    const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken)
 {
     sptr<AAFwk::IAbilityScheduler> retval = nullptr;
     auto iter = demoAbilityMgrClientData.data.find(uri.ToString());
@@ -66,7 +66,7 @@ sptr<AAFwk::IAbilityScheduler> AAFwk::AbilityManagerClient::AcquireDataAbility(
 }
 
 ErrCode AbilityManagerClient::ReleaseDataAbility(
-    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken)
+    sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject>& callerToken)
 {
     return ERR_OK;
 }

test/mock/frameworks_kits_test/DemoObServer/mock_ability_thread_for_data_observer.h

@@ -53,7 +53,7 @@ sptr<AppExecFwk::AbilityThread> MockCreateAbilityThread()
     info->name = std::string("MockAbilityTest");
     info->type = AbilityType::DATA;
     info->isNativeAbility = true;
-    std::cout << "info->name : " << (*info).name <<std::endl;
+    std::cout << "info->name : " << (*info).name << std::endl;
 
     sptr<IRemoteObject> token = sptr<IRemoteObject>(new AbilityThread());
 

test/mock/remote_native_token_mock/remote_native_token.cpp

@@ -20,7 +20,7 @@ namespace AppExecFwk {
 void RemoteNativeToken::SetNativeToken()
 {
     uint64_t tokenId;
-    const char **perms = new const char *[1];
+    const char** perms = new const char* [1];
     perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC"; // system_core
     NativeTokenInfoParams infoInstance = {
         .dcapsNum = 0,