1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "backup_para_mock.h"
19 #include "bms_adapter_mock.h"
20 #include "b_json/b_json_entity_caps.h"
21 #include "b_jsonutil_mock.h"
22 #include "direct_ex_mock.h"
23 #include "ipc_skeleton_mock.h"
24 #include "sa_backup_connection_mock.h"
25 #include "service_reverse_proxy_mock.h"
26 #include "svc_backup_connection_mock.h"
27 #include "svc_extension_proxy_mock.h"
28 #include "svc_session_manager_mock.h"
29
30 #include "service_incremental.cpp"
31
32 namespace OHOS::FileManagement::Backup {
33 using namespace std;
34 using namespace OHOS::AppFileService;
35
36 class BService {
37 public:
38 virtual ErrCode GetLocalCapabilities(int& fd) = 0;
39 virtual ErrCode VerifyCallerAndGetCallerName(std::string&) = 0;
40 virtual ErrCode InitRestoreSession(const sptr<IServiceReverse>&) = 0;
41 virtual ErrCode InitRestoreSessionWithErrMsg(const sptr<IServiceReverse>&, int32_t&, std::string&) = 0;
42 virtual ErrCode InitBackupSession(const sptr<IServiceReverse>&) = 0;
43 virtual ErrCode InitBackupSessionWithErrMsg(const sptr<IServiceReverse>&, int32_t&, std::string&) = 0;
44 virtual ErrCode Start() = 0;
45 virtual ErrCode PublishFile(const BFileInfo&) = 0;
46 virtual ErrCode AppFileReady(const std::string &, int, int32_t) = 0;
47 virtual ErrCode AppFileReadyWithoutFd(const std::string &, int32_t) = 0;
48 virtual ErrCode AppDone(ErrCode) = 0;
49 virtual ErrCode ServiceResultReport(const std::string, BackupRestoreScenario, ErrCode) = 0;
50 virtual ErrCode AppendBundlesRestoreSessionDataByDetail(int, const std::vector<std::string>&,
51 const std::vector<std::string>&, int32_t, int32_t) = 0;
52 virtual ErrCode AppendBundlesRestoreSessionData(int, const std::vector<std::string>&, int32_t, int32_t) = 0;
53 virtual ErrCode AppendBundlesBackupSession(const std::vector<BundleName>&) = 0;
54 virtual ErrCode AppendBundlesDetailsBackupSession(const std::vector<BundleName>&,
55 const std::vector<std::string>&) = 0;
56 virtual ErrCode Finish() = 0;
57 virtual ErrCode LaunchBackupExtension(const BundleName&) = 0;
58 virtual ErrCode LaunchBackupSAExtension(const BundleName&) = 0;
59 virtual ErrCode GetFileHandle(const string&, const string&) = 0;
60 virtual int Dump(int, const vector<u16string>&) = 0;
61 virtual ErrCode VerifyCaller() = 0;
62 virtual ErrCode VerifyCaller(IServiceReverseType::Scenario) = 0;
63 virtual int32_t GetUserIdDefault() = 0;
64 virtual ErrCode GetBackupInfo(const BundleName&, std::string&) = 0;
65 virtual ErrCode UpdateTimer(const BundleName&, uint32_t, bool&) = 0;
66 virtual ErrCode UpdateSendRate(const std::string&, int32_t, bool&) = 0;
67 virtual ErrCode ReportAppProcessInfo(const std::string, BackupRestoreScenario) = 0;
68 virtual ErrCode StartExtTimer(bool&) = 0;
69 virtual ErrCode StartFwkTimer(bool&) = 0;
70 virtual ErrCode StopExtTimer(bool&) = 0;
71 virtual ErrCode RefreshDataSize(int64_t) = 0;
72 virtual std::string GetCallerName() = 0;
73 virtual bool IsReportBundleExecFail(const std::string&) = 0;
74 virtual bool IsReportFileReadyFail(const std::string&) = 0;
75 virtual std::vector<std::string> GetSupportBackupBundleNames(vector<BJsonEntityCaps::BundleInfo>&, bool,
76 const vector<string>&) = 0;
77 virtual ErrCode HandleCurBundleFileReady(const std::string&, const std::string&, bool) = 0;
78 virtual ErrCode HandleCurAppDone(ErrCode, const std::string&, bool) = 0;
79 virtual UniqueFd GetLocalCapabilitiesForBundleInfos() = 0;
80 virtual ErrCode GetBackupDataSize(bool, const std::vector<BIncrementalData>&) = 0;
81 virtual ErrCode CleanBundleTempDir(const std::string& bundleName) = 0;
82 virtual ErrCode HandleExtDisconnect(BackupRestoreScenario, bool, ErrCode) = 0;
83 virtual ErrCode GetExtOnRelease(bool&) = 0;
84 virtual void SetExtOnRelease(const BundleName&, bool) = 0;
85 virtual void RemoveExtOnRelease(const BundleName&) = 0;
86 virtual ErrCode GetCompatibilityInfo(const std::string&, const std::string&, std::string&) = 0;
87 public:
88 virtual bool UpdateToRestoreBundleMap(const string&, const string&) = 0;
89 public:
90 BService() = default;
91 virtual ~BService() = default;
92 public:
93 static inline std::shared_ptr<BService> serviceMock = nullptr;
94 };
95
96 class ServiceMock : public BService {
97 public:
98 MOCK_METHOD(ErrCode, GetLocalCapabilities, (int&));
99 MOCK_METHOD(ErrCode, VerifyCallerAndGetCallerName, (std::string&));
100 MOCK_METHOD(ErrCode, InitRestoreSession, (const sptr<IServiceReverse>&));
101 MOCK_METHOD(ErrCode, InitRestoreSessionWithErrMsg, (const sptr<IServiceReverse>&, int32_t &, std::string&));
102 MOCK_METHOD(ErrCode, InitBackupSession, (const sptr<IServiceReverse>&));
103 MOCK_METHOD(ErrCode, InitBackupSessionWithErrMsg, (const sptr<IServiceReverse>&, int32_t &, std::string&));
104 MOCK_METHOD(ErrCode, Start, ());
105 MOCK_METHOD(ErrCode, PublishFile, (const BFileInfo&));
106 MOCK_METHOD(ErrCode, AppFileReady, (const string&, int, int32_t));
107 MOCK_METHOD(ErrCode, AppFileReadyWithoutFd, (const string&, int32_t));
108 MOCK_METHOD(ErrCode, AppDone, (ErrCode));
109 MOCK_METHOD(ErrCode, ServiceResultReport, (const std::string, BackupRestoreScenario, ErrCode));
110 MOCK_METHOD(ErrCode, AppendBundlesRestoreSessionDataByDetail, (int, (const std::vector<std::string>&),
111 (const std::vector<std::string>&), int32_t, int32_t));
112 MOCK_METHOD(ErrCode, AppendBundlesRestoreSessionData, (int, (const std::vector<BundleName>&), int32_t,
113 int32_t));
114 MOCK_METHOD(ErrCode, AppendBundlesBackupSession, (const std::vector<BundleName>&));
115 MOCK_METHOD(ErrCode, AppendBundlesDetailsBackupSession, ((const std::vector<BundleName>&),
116 (const std::vector<std::string>&)));
117 MOCK_METHOD(ErrCode, Finish, ());
118 MOCK_METHOD(ErrCode, LaunchBackupExtension, (const BundleName&));
119 MOCK_METHOD(ErrCode, LaunchBackupSAExtension, (const BundleName&));
120 MOCK_METHOD(ErrCode, GetFileHandle, (const string&, const string&));
121 MOCK_METHOD(int, Dump, (int, const vector<u16string>&));
122 MOCK_METHOD(ErrCode, VerifyCaller, ());
123 MOCK_METHOD(ErrCode, VerifyCaller, (IServiceReverseType::Scenario));
124 MOCK_METHOD(int32_t, GetUserIdDefault, ());
125 MOCK_METHOD(ErrCode, GetBackupInfo, (const BundleName&, std::string&));
126 MOCK_METHOD(ErrCode, UpdateTimer, (const BundleName&, uint32_t, bool&));
127 MOCK_METHOD(ErrCode, UpdateSendRate, (const std::string&, int32_t, bool&));
128 MOCK_METHOD(ErrCode, ReportAppProcessInfo, (const std::string, BackupRestoreScenario));
129 MOCK_METHOD(ErrCode, StartExtTimer, (bool&));
130 MOCK_METHOD(ErrCode, StartFwkTimer, (bool&));
131 MOCK_METHOD(ErrCode, StopExtTimer, (bool&));
132 MOCK_METHOD(ErrCode, RefreshDataSize, (int64_t));
133 MOCK_METHOD(std::string, GetCallerName, ());
134 MOCK_METHOD(bool, IsReportBundleExecFail, (const std::string&));
135 MOCK_METHOD(bool, IsReportFileReadyFail, (const std::string&));
136 MOCK_METHOD(std::vector<std::string>, GetSupportBackupBundleNames, ((vector<BJsonEntityCaps::BundleInfo>&), bool,
137 (const vector<string>&)));
138 MOCK_METHOD(ErrCode, HandleCurBundleFileReady, (const std::string&, const std::string&, bool));
139 MOCK_METHOD(ErrCode, HandleCurAppDone, (ErrCode, const std::string&, bool));
140 MOCK_METHOD(UniqueFd, GetLocalCapabilitiesForBundleInfos, ());
141 MOCK_METHOD(ErrCode, GetBackupDataSize, (bool, const std::vector<BIncrementalData>&));
142 MOCK_METHOD(ErrCode, CleanBundleTempDir, (const std::string&));
143 MOCK_METHOD(ErrCode, HandleExtDisconnect, (BackupRestoreScenario, bool, ErrCode));
144 MOCK_METHOD(ErrCode, GetExtOnRelease, (bool&));
145 MOCK_METHOD(void, SetExtOnRelease, (const BundleName&, bool));
146 MOCK_METHOD(void, RemoveExtOnRelease, (const BundleName&));
147 MOCK_METHOD(ErrCode, GetCompatibilityInfo, (const std::string&, const std::string&, std::string&));
148 public:
149 MOCK_METHOD(bool, UpdateToRestoreBundleMap, (const string&, const string&));
150 };
151
OnStart()152 void Service::OnStart() {}
153
OnStop()154 void Service::OnStop() {}
155
GetLocalCapabilitiesForBundleInfos(int & fd)156 ErrCode Service::GetLocalCapabilitiesForBundleInfos(int &fd)
157 {
158 return BError(BError::Codes::OK);
159 }
InitBackupSessionWithErrMsg(const sptr<IServiceReverse> & remote,int32_t & errCodeForMsg,std::string & errMsg)160 ErrCode Service::InitBackupSessionWithErrMsg(const sptr<IServiceReverse> &remote,
161 int32_t& errCodeForMsg, std::string &errMsg)
162 {
163 errCodeForMsg = BError(BError::Codes::OK);
164 return BError(BError::Codes::OK);
165 }
166
GetLocalCapabilities(int & fd)167 ErrCode Service::GetLocalCapabilities(int &fd)
168 {
169 return BService::serviceMock->GetLocalCapabilities(fd);
170 }
171
StopAll(const wptr<IRemoteObject> &,bool)172 void Service::StopAll(const wptr<IRemoteObject>&, bool) {}
173
VerifyCallerAndGetCallerName(std::string & bundleName)174 ErrCode Service::VerifyCallerAndGetCallerName(std::string &bundleName)
175 {
176 return BService::serviceMock->VerifyCallerAndGetCallerName(bundleName);
177 }
178
InitRestoreSession(const sptr<IServiceReverse> & remote)179 ErrCode Service::InitRestoreSession(const sptr<IServiceReverse> &remote)
180 {
181 return BService::serviceMock->InitRestoreSession(remote);
182 }
183
InitRestoreSessionWithErrMsg(const sptr<IServiceReverse> & remote,int32_t & errCodeForMsg,std::string & errMsg)184 ErrCode Service::InitRestoreSessionWithErrMsg(const sptr<IServiceReverse> &remote,
185 int32_t& errCodeForMsg, std::string &errMsg)
186 {
187 return BService::serviceMock->InitRestoreSessionWithErrMsg(remote, errCodeForMsg, errMsg);
188 }
189
InitBackupSession(const sptr<IServiceReverse> & remote)190 ErrCode Service::InitBackupSession(const sptr<IServiceReverse> &remote)
191 {
192 return BService::serviceMock->InitBackupSession(remote);
193 }
194
Start()195 ErrCode Service::Start()
196 {
197 return BService::serviceMock->Start();
198 }
199
PublishFile(const BFileInfo & fileInfo)200 ErrCode Service::PublishFile(const BFileInfo &fileInfo)
201 {
202 return BService::serviceMock->PublishFile(fileInfo);
203 }
204
AppFileReady(const std::string & fileName,int fd,int32_t appFileReadyErrCode)205 ErrCode Service::AppFileReady(const std::string &fileName, int fd, int32_t appFileReadyErrCode)
206 {
207 return BService::serviceMock->AppFileReady(fileName, fd, appFileReadyErrCode);
208 }
209
AppFileReadyWithoutFd(const std::string & fileName,int32_t appFileReadyErrCode)210 ErrCode Service::AppFileReadyWithoutFd(const std::string &fileName, int32_t appFileReadyErrCode)
211 {
212 return BService::serviceMock->AppFileReadyWithoutFd(fileName, appFileReadyErrCode);
213 }
214
AppDone(int32_t appDoneErrCode)215 ErrCode Service::AppDone(int32_t appDoneErrCode)
216 {
217 return BService::serviceMock->AppDone(appDoneErrCode);
218 }
219
ServiceResultReport(const std::string & restoreRetInfo,BackupRestoreScenario sennario,ErrCode errCode)220 ErrCode Service::ServiceResultReport(const std::string& restoreRetInfo,
221 BackupRestoreScenario sennario, ErrCode errCode)
222 {
223 return BService::serviceMock->ServiceResultReport(restoreRetInfo, sennario, errCode);
224 }
225
AppendBundlesRestoreSessionDataByDetail(int fd,const std::vector<std::string> & bundleNames,const std::vector<std::string> & detailInfos,int32_t restoreType,int32_t userId)226 ErrCode Service::AppendBundlesRestoreSessionDataByDetail(int fd,
227 const std::vector<std::string> &bundleNames,
228 const std::vector<std::string> &detailInfos,
229 int32_t restoreType,
230 int32_t userId)
231 {
232 return BService::serviceMock->AppendBundlesRestoreSessionDataByDetail(fd, bundleNames, detailInfos,
233 restoreType, userId);
234 }
235
AppendBundlesRestoreSessionData(int fd,const std::vector<std::string> & bundleNames,int32_t restoreType,int32_t userId)236 ErrCode Service::AppendBundlesRestoreSessionData(int fd,
237 const std::vector<std::string> &bundleNames,
238 int32_t restoreType,
239 int32_t userId)
240 {
241 return BService::serviceMock->AppendBundlesRestoreSessionData(fd, bundleNames, restoreType, userId);
242 }
243
AppendBundlesBackupSession(const std::vector<BundleName> & bundleNames)244 ErrCode Service::AppendBundlesBackupSession(const std::vector<BundleName> &bundleNames)
245 {
246 return BService::serviceMock->AppendBundlesBackupSession(bundleNames);
247 }
248
AppendBundlesDetailsBackupSession(const std::vector<BundleName> & bundleNames,const std::vector<std::string> & bundleInfos)249 ErrCode Service::AppendBundlesDetailsBackupSession(const std::vector<BundleName> &bundleNames,
250 const std::vector<std::string> &bundleInfos)
251 {
252 return BService::serviceMock->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos);
253 }
254
Finish()255 ErrCode Service::Finish()
256 {
257 return BService::serviceMock->Finish();
258 }
259
LaunchBackupExtension(const BundleName & bundleName)260 ErrCode Service::LaunchBackupExtension(const BundleName &bundleName)
261 {
262 return BService::serviceMock->LaunchBackupExtension(bundleName);
263 }
264
LaunchBackupSAExtension(const BundleName & bundleName)265 ErrCode Service::LaunchBackupSAExtension(const BundleName &bundleName)
266 {
267 return BService::serviceMock->LaunchBackupSAExtension(bundleName);
268 }
269
GetFileHandle(const string & bundleName,const string & fileName)270 ErrCode Service::GetFileHandle(const string &bundleName, const string &fileName)
271 {
272 return BService::serviceMock->GetFileHandle(bundleName, fileName);
273 }
274
OnBackupExtensionDied(const string &&,bool)275 void Service::OnBackupExtensionDied(const string&&, bool) {}
276
ExtConnectDied(const string &)277 void Service::ExtConnectDied(const string&) {}
278
ExtStart(const string &)279 void Service::ExtStart(const string&) {}
280
Dump(int fd,const vector<u16string> & args)281 int Service::Dump(int fd, const vector<u16string> &args)
282 {
283 return BService::serviceMock->Dump(fd, args);
284 }
285
ExtConnectFailed(const string &,ErrCode)286 void Service::ExtConnectFailed(const string&, ErrCode) {}
287
ExtConnectDone(string)288 void Service::ExtConnectDone(string) {}
289
ClearSessionAndSchedInfo(const string &)290 void Service::ClearSessionAndSchedInfo(const string&) {}
291
VerifyCaller()292 ErrCode Service::VerifyCaller()
293 {
294 return BService::serviceMock->VerifyCaller();
295 }
296
VerifyCaller(IServiceReverseType::Scenario scenario)297 ErrCode Service::VerifyCaller(IServiceReverseType::Scenario scenario)
298 {
299 return BService::serviceMock->VerifyCaller(scenario);
300 }
301
GetUserIdDefault()302 int32_t Service::GetUserIdDefault()
303 {
304 return BService::serviceMock->GetUserIdDefault();
305 }
306
OnAllBundlesFinished(ErrCode)307 void Service::OnAllBundlesFinished(ErrCode) {}
308
OnStartSched()309 void Service::OnStartSched() {}
310
SendStartAppGalleryNotify(const BundleName &)311 void Service::SendStartAppGalleryNotify(const BundleName&) {}
312
SessionDeactive()313 void Service::SessionDeactive() {}
314
GetBackupInfo(const BundleName & bundleName,std::string & result)315 ErrCode Service::GetBackupInfo(const BundleName &bundleName, std::string &result)
316 {
317 return BService::serviceMock->GetBackupInfo(bundleName, result);
318 }
319
UpdateTimer(const BundleName & bundleName,uint32_t timeOut,bool & result)320 ErrCode Service::UpdateTimer(const BundleName &bundleName, uint32_t timeOut, bool &result)
321 {
322 return BService::serviceMock->UpdateTimer(bundleName, timeOut, result);
323 }
324
UpdateSendRate(const std::string & bundleName,int32_t sendRate,bool & result)325 ErrCode Service::UpdateSendRate(const std::string &bundleName, int32_t sendRate, bool &result)
326 {
327 return BService::serviceMock->UpdateSendRate(bundleName, sendRate, result);
328 }
329
OnSABackup(const std::string &,const int &,const std::string &,const ErrCode &)330 void Service::OnSABackup(const std::string&, const int&, const std::string&, const ErrCode&) {}
331
OnSARestore(const std::string &,const std::string &,const ErrCode &)332 void Service::OnSARestore(const std::string&, const std::string&, const ErrCode&) {}
333
NotifyCallerCurAppDone(ErrCode,const std::string &)334 void Service::NotifyCallerCurAppDone(ErrCode, const std::string&) {}
335
SendEndAppGalleryNotify(const BundleName &)336 void Service::SendEndAppGalleryNotify(const BundleName&) {}
337
NoticeClientFinish(const string &,ErrCode)338 void Service::NoticeClientFinish(const string&, ErrCode) {}
339
ReportAppProcessInfo(const std::string & processInfo,BackupRestoreScenario sennario)340 ErrCode Service::ReportAppProcessInfo(const std::string &processInfo, BackupRestoreScenario sennario)
341 {
342 return BService::serviceMock->ReportAppProcessInfo(processInfo, sennario);
343 }
344
StartExtTimer(bool & isExtStart)345 ErrCode Service::StartExtTimer(bool &isExtStart)
346 {
347 return BService::serviceMock->StartExtTimer(isExtStart);
348 }
349
StartFwkTimer(bool & isFwkStart)350 ErrCode Service::StartFwkTimer(bool &isFwkStart)
351 {
352 return BService::serviceMock->StartFwkTimer(isFwkStart);
353 }
354
StopExtTimer(bool & isExtStop)355 ErrCode Service::StopExtTimer(bool &isExtStop)
356 {
357 return BService::serviceMock->StopExtTimer(isExtStop);
358 }
359
RefreshDataSize(int64_t totalsize)360 ErrCode Service::RefreshDataSize(int64_t totalsize)
361 {
362 return BService::serviceMock->RefreshDataSize(totalsize);
363 }
364
TimeOutCallback(wptr<Service> ptr,std::string bundleName)365 std::function<void()> Service::TimeOutCallback(wptr<Service> ptr, std::string bundleName)
366 {
367 return []() {};
368 }
369
SetCurrentSessProperties(std::vector<BJsonEntityCaps::BundleInfo> &,std::vector<std::string> &,RestoreTypeEnum,std::string &)370 void Service::SetCurrentSessProperties(std::vector<BJsonEntityCaps::BundleInfo>&, std::vector<std::string>&,
371 RestoreTypeEnum, std::string &) {}
372
SetCurrentSessProperties(std::vector<BJsonEntityCaps::BundleInfo> &,std::vector<std::string> &,std::map<std::string,std::vector<BJsonUtil::BundleDetailInfo>> &,std::map<std::string,bool> &,RestoreTypeEnum,std::string &)373 void Service::SetCurrentSessProperties(std::vector<BJsonEntityCaps::BundleInfo>&, std::vector<std::string>&,
374 std::map<std::string, std::vector<BJsonUtil::BundleDetailInfo>>&, std::map<std::string, bool>&,
375 RestoreTypeEnum, std::string &) {}
376
SetCurrentSessProperties(BJsonEntityCaps::BundleInfo &,std::map<std::string,bool> &,const std::string &)377 void Service::SetCurrentSessProperties(BJsonEntityCaps::BundleInfo&, std::map<std::string, bool>&,
378 const std::string&) {}
379
ReleaseOnException()380 void Service::ReleaseOnException() {}
381
UpdateToRestoreBundleMap(const string & bundleName,const string & fileName)382 bool SvcRestoreDepsManager::UpdateToRestoreBundleMap(const string &bundleName, const string &fileName)
383 {
384 return BService::serviceMock->UpdateToRestoreBundleMap(bundleName, fileName);
385 }
386
OnBundleStarted(BError,sptr<SvcSessionManager>,const BundleName &)387 void Service::OnBundleStarted(BError, sptr<SvcSessionManager>, const BundleName&) {}
388
HandleExceptionOnAppendBundles(sptr<SvcSessionManager>,const vector<BundleName> &,const vector<BundleName> &)389 void Service::HandleExceptionOnAppendBundles(sptr<SvcSessionManager>, const vector<BundleName>&,
390 const vector<BundleName>&) {}
391
BundleBeginRadarReport(const std::string &,const ErrCode,const IServiceReverseType::Scenario)392 void Service::BundleBeginRadarReport(const std::string&, const ErrCode, const IServiceReverseType::Scenario) {}
393
BundleEndRadarReport(const std::string &,const ErrCode,const IServiceReverseType::Scenario)394 void Service::BundleEndRadarReport(const std::string&, const ErrCode, const IServiceReverseType::Scenario) {}
395
FileReadyRadarReport(const std::string &,const std::string &,const ErrCode,const IServiceReverseType::Scenario)396 void Service::FileReadyRadarReport(const std::string&, const std::string&, const ErrCode,
397 const IServiceReverseType::Scenario) {}
398
ExtensionConnectFailRadarReport(const std::string &,const ErrCode,const IServiceReverseType::Scenario)399 void Service::ExtensionConnectFailRadarReport(const std::string&, const ErrCode, const IServiceReverseType::Scenario) {}
400
PermissionCheckFailRadar(const std::string &,const std::string &)401 void Service::PermissionCheckFailRadar(const std::string&, const std::string&) {}
402
OnStartResRadarReport(const std::vector<std::string> &,int32_t)403 void Service::OnStartResRadarReport(const std::vector<std::string>&, int32_t) {}
404
GetCallerName()405 std::string Service::GetCallerName()
406 {
407 return BService::serviceMock->GetCallerName();
408 }
409
IsReportBundleExecFail(const std::string & bundleName)410 bool Service::IsReportBundleExecFail(const std::string &bundleName)
411 {
412 return BService::serviceMock->IsReportBundleExecFail(bundleName);
413 }
414
ClearBundleRadarReport()415 void Service::ClearBundleRadarReport() {}
416
UpdateBundleRadarReport(const std::string &)417 void Service::UpdateBundleRadarReport(const std::string&) {}
418
IsReportFileReadyFail(const std::string & bundleName)419 bool Service::IsReportFileReadyFail(const std::string &bundleName)
420 {
421 return BService::serviceMock->IsReportFileReadyFail(bundleName);
422 }
423
ClearFileReadyRadarReport()424 void Service::ClearFileReadyRadarReport() {}
425
UpdateFailedBundles(const std::string &,BundleTaskInfo)426 void Service::UpdateFailedBundles(const std::string&, BundleTaskInfo) {}
427
ClearFailedBundles()428 void Service::ClearFailedBundles() {}
429
StartRunningTimer(const std::string &)430 void Service::StartRunningTimer(const std::string&) {}
431
GetSupportBackupBundleNames(vector<BJsonEntityCaps::BundleInfo> & bundleInfos,bool isIncBackup,const vector<std::string> & srcBundleNames)432 std::vector<std::string> Service::GetSupportBackupBundleNames(vector<BJsonEntityCaps::BundleInfo> &bundleInfos,
433 bool isIncBackup, const vector<std::string> &srcBundleNames)
434 {
435 return BService::serviceMock->GetSupportBackupBundleNames(bundleInfos, isIncBackup, srcBundleNames);
436 }
437
HandleCurBundleFileReady(const std::string & bundleName,const std::string & fileName,bool isIncBackup)438 ErrCode Service::HandleCurBundleFileReady(const std::string &bundleName, const std::string &fileName, bool isIncBackup)
439 {
440 return BService::serviceMock->HandleCurBundleFileReady(bundleName, fileName, isIncBackup);
441 }
442
HandleCurAppDone(ErrCode errCode,const std::string & bundleName,bool isIncBackup)443 ErrCode Service::HandleCurAppDone(ErrCode errCode, const std::string &bundleName, bool isIncBackup)
444 {
445 return BService::serviceMock->HandleCurAppDone(errCode, bundleName, isIncBackup);
446 }
447
StartCurBundleBackupOrRestore(const std::string &)448 void Service::StartCurBundleBackupOrRestore(const std::string&) {}
449
GetLocalCapabilitiesForBundleInfos()450 UniqueFd Service::GetLocalCapabilitiesForBundleInfos()
451 {
452 return BService::serviceMock->GetLocalCapabilitiesForBundleInfos();
453 }
454
AppendBundles(const std::vector<std::string> & bundleNames)455 void Service::AppendBundles(const std::vector<std::string> &bundleNames) {}
GetBackupDataSize(bool isPreciseScan,const std::vector<BIncrementalData> & bundleNameList)456 ErrCode Service::GetBackupDataSize(bool isPreciseScan, const std::vector<BIncrementalData>& bundleNameList)
457 {
458 return BService::serviceMock->GetBackupDataSize(isPreciseScan, bundleNameList);
459 }
460
CleanBundleTempDir(const std::string & bundleName)461 ErrCode Service::CleanBundleTempDir(const std::string& bundleName)
462 {
463 return BService::serviceMock->CleanBundleTempDir(bundleName);
464 }
465
HandleExtDisconnect(BackupRestoreScenario scenario,bool isAppResultReport,ErrCode errCode)466 ErrCode Service::HandleExtDisconnect(BackupRestoreScenario scenario, bool isAppResultReport, ErrCode errCode)
467 {
468 return BService::serviceMock->HandleExtDisconnect(scenario, isAppResultReport, errCode);
469 }
470
GetExtOnRelease(bool & isExtOnRelease)471 ErrCode Service::GetExtOnRelease(bool &isExtOnRelease)
472 {
473 return BService::serviceMock->GetExtOnRelease(isExtOnRelease);
474 }
475
SetExtOnRelease(const BundleName & bundleName,bool isOnRelease)476 void Service::SetExtOnRelease(const BundleName &bundleName, bool isOnRelease)
477 {
478 return BService::serviceMock->SetExtOnRelease(bundleName, isOnRelease);
479 }
480
RemoveExtOnRelease(const BundleName & bundleName)481 void Service::RemoveExtOnRelease(const BundleName &bundleName)
482 {
483 return BService::serviceMock->RemoveExtOnRelease(bundleName);
484 }
485
GetCompatibilityInfo(const std::string & bundleName,const std::string & extInfo,std::string & compatInfo)486 ErrCode Service::GetCompatibilityInfo(const std::string &bundleName, const std::string &extInfo,
487 std::string &compatInfo)
488 {
489 return BService::serviceMock->GetCompatibilityInfo(bundleName, extInfo, compatInfo);
490 }
491 } // namespace OHOS::FileManagement::Backup
492
493 namespace OHOS::FileManagement::Backup {
494 using namespace std;
495 using namespace testing;
496 using namespace testing::ext;
497
498 constexpr int32_t SERVICE_ID = 5203;
499
500 class ServiceIncrementalTest : public testing::Test {
501 public:
502 static void SetUpTestCase(void);
503 static void TearDownTestCase();
SetUp()504 void SetUp() {};
TearDown()505 void TearDown() {};
506
507 static inline sptr<Service> service = nullptr;
508 static inline shared_ptr<BackupParaMock> param = nullptr;
509 static inline shared_ptr<BJsonUtilMock> jsonUtil = nullptr;
510 static inline shared_ptr<SvcSessionManagerMock> session = nullptr;
511 static inline shared_ptr<BundleMgrAdapterMock> bms = nullptr;
512 static inline sptr<SvcExtensionProxyMock> svcProxy = nullptr;
513 static inline sptr<SvcBackupConnectionMock> connect = nullptr;
514 static inline shared_ptr<SABackupConnectionMock> saConnect = nullptr;
515 static inline shared_ptr<IPCSkeletonMock> skeleton = nullptr;
516 static inline sptr<ServiceReverseProxyMock> srProxy = nullptr;
517 static inline shared_ptr<ServiceMock> srvMock = nullptr;
518 static inline shared_ptr<DirectoryFuncMock> directMock = nullptr;
519 };
520
SetUpTestCase(void)521 void ServiceIncrementalTest::SetUpTestCase(void)
522 {
523 GTEST_LOG_(INFO) << "SetUpTestCase enter";
524 srvMock = make_shared<ServiceMock>();
525 ServiceMock::serviceMock = srvMock;
526 service = sptr(new Service(SERVICE_ID));
527 param = make_shared<BackupParaMock>();
528 BackupParaMock::backupPara = param;
529 jsonUtil = make_shared<BJsonUtilMock>();
530 BJsonUtilMock::jsonUtil = jsonUtil;
531 session = make_shared<SvcSessionManagerMock>();
532 SvcSessionManagerMock::sessionManager = session;
533 svcProxy = sptr(new SvcExtensionProxyMock());
534 bms = make_shared<BundleMgrAdapterMock>();
535 BundleMgrAdapterMock::bms = bms;
536 connect = sptr(new SvcBackupConnectionMock());
537 SvcBackupConnectionMock::connect = connect;
538 saConnect = make_shared<SABackupConnectionMock>();
539 SABackupConnectionMock::saConnect = saConnect;
540 skeleton = make_shared<IPCSkeletonMock>();
541 IPCSkeletonMock::skeleton = skeleton;
542 srProxy = sptr(new ServiceReverseProxyMock());
543 directMock = make_shared<DirectoryFuncMock>();
544 DirectoryFuncMock::directoryFunc_ = directMock;
545 }
546
TearDownTestCase()547 void ServiceIncrementalTest::TearDownTestCase()
548 {
549 GTEST_LOG_(INFO) << "TearDownTestCase enter";
550 service = nullptr;
551 BackupParaMock::backupPara = nullptr;
552 param = nullptr;
553 BJsonUtilMock::jsonUtil = nullptr;
554 jsonUtil = nullptr;
555 SvcSessionManagerMock::sessionManager = nullptr;
556 session = nullptr;
557 svcProxy = nullptr;
558 BundleMgrAdapterMock::bms = nullptr;
559 bms = nullptr;
560 SvcBackupConnectionMock::connect = nullptr;
561 connect = nullptr;
562 SABackupConnectionMock::saConnect = nullptr;
563 saConnect = nullptr;
564 IPCSkeletonMock::skeleton = nullptr;
565 skeleton = nullptr;
566 srProxy = nullptr;
567 ServiceMock::serviceMock = nullptr;
568 srvMock = nullptr;
569 DirectoryFuncMock::directoryFunc_ = nullptr;
570 directMock = nullptr;
571 }
572
573 /**
574 * @tc.number: SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000
575 * @tc.name: SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000
576 * @tc.desc: 测试 GetLocalCapabilitiesIncremental 的正常/异常分支
577 * @tc.size: MEDIUM
578 * @tc.type: FUNC
579 * @tc.level Level 1
580 * @tc.require: issueIAKC3I
581 */
582 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000, TestSize.Level1)
583 {
584 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000";
585 try {
586 auto session_ = service->session_;
587 service->session_ = nullptr;
588 int fd = -1;
589 service->GetLocalCapabilitiesIncremental({}, fd);
590 service->session_ = session_;
591 EXPECT_EQ(static_cast<int>(fd), BConstants::INVALID_FD_NUM);
592
593 service->isOccupyingSession_ = true;
594 fd = service->GetLocalCapabilitiesIncremental({});
595 EXPECT_EQ(static_cast<int>(fd), -ENOENT);
596
597 service->isOccupyingSession_ = false;
598 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode()));
599 fd = service->GetLocalCapabilitiesIncremental({});
600 EXPECT_EQ(static_cast<int>(fd), -ENOENT);
601
602 vector<BJsonEntityCaps::BundleInfo> infos;
603 infos.emplace_back(BJsonEntityCaps::BundleInfo{.name = "bundleName", .appIndex = 0});
604 EXPECT_CALL(*directMock, ForceRemoveDirectoryBMS(_)).WillRepeatedly(Return(true));
605 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
606 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0));
607 EXPECT_CALL(*bms, GetBundleInfosForIncremental(An<int32_t>(), An<const vector<BIncrementalData>&>()))
608 .WillOnce(Return(infos));
609
610 BJsonUtil::BundleDetailInfo bundleInfo;
611 bundleInfo.bundleIndex = 1;
612 bundleInfo.bundleName = "bundleName";
613 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
614 fd = service->GetLocalCapabilitiesIncremental({});
615
616 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
617 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0));
618 EXPECT_CALL(*bms, GetBundleInfosForIncremental(An<int32_t>(), An<const vector<BIncrementalData>&>()))
619 .WillOnce(Return(infos));
620 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
621 service->isCreatingIncreaseFile_.store(2);
622 fd = service->GetLocalCapabilitiesIncremental({});
623 service->isCreatingIncreaseFile_.store(0);
624 EXPECT_TRUE(static_cast<int>(fd) > 0);
625 } catch (...) {
626 EXPECT_TRUE(false);
627 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetLocalCapabilitiesIncremental.";
628 }
629 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000";
630 }
631
632 /**
633 * @tc.number: SUB_ServiceIncremental_StartGetFdTask_0000
634 * @tc.name: SUB_ServiceIncremental_StartGetFdTask_0000
635 * @tc.desc: 测试 StartGetFdTask 的正常/异常分支
636 * @tc.size: MEDIUM
637 * @tc.type: FUNC
638 * @tc.level Level 1
639 * @tc.require: issueIAKC3I
640 */
641 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_StartGetFdTask_0000, TestSize.Level1)
642 {
643 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_StartGetFdTask_0000";
644 try {
645 service->StartGetFdTask("", nullptr);
646 EXPECT_TRUE(true);
647
648 auto session_ = service->session_;
649 service->session_ = nullptr;
650 EXPECT_THROW(service->StartGetFdTask("", service), BError);
651
652 service->session_ = session_;
653 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
654 EXPECT_THROW(service->StartGetFdTask("", service), BError);
655
656 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
657 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
658 EXPECT_THROW(service->StartGetFdTask("", service), BError);
659
660 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
661 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
662 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
663 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(true));
664 EXPECT_CALL(*svcProxy, User0OnBackup()).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode()));
665 service->StartGetFdTask("", service);
666 EXPECT_TRUE(true);
667
668 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
669 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
670 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
671 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(true));
672 EXPECT_CALL(*svcProxy, User0OnBackup()).WillOnce(Return(ERR_OK));
673 service->StartGetFdTask("", service);
674 EXPECT_TRUE(true);
675 } catch (...) {
676 EXPECT_TRUE(false);
677 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by StartGetFdTask.";
678 }
679 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_StartGetFdTask_0000";
680 }
681
682 /**
683 * @tc.number: SUB_ServiceIncremental_StartGetFdTask_0100
684 * @tc.name: SUB_ServiceIncremental_StartGetFdTask_0100
685 * @tc.desc: 测试 StartGetFdTask 的正常/异常分支
686 * @tc.size: MEDIUM
687 * @tc.type: FUNC
688 * @tc.level Level 1
689 * @tc.require: issueIAKC3I
690 */
691 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_StartGetFdTask_0100, TestSize.Level1)
692 {
693 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_StartGetFdTask_0100";
694 try {
695 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
696 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
697 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
698 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
699 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
700 EXPECT_THROW(service->StartGetFdTask("", service), BError);
701
702 BJsonUtil::BundleDetailInfo bundleInfo;
703 vector<BJsonEntityCaps::BundleInfo> info;
704 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
705 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
706 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0));
707 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
708 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true));
709 EXPECT_CALL(*session, GetLastIncrementalTime(_)).WillOnce(Return(0));
710 EXPECT_CALL(*bms, GetBundleInfosForIncremental(An<const vector<BIncrementalData>&>(), An<int32_t>()))
711 .WillOnce(Return(info));
712 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
713 EXPECT_THROW(service->StartGetFdTask("", service), BError);
714 } catch (...) {
715 EXPECT_TRUE(false);
716 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by StartGetFdTask.";
717 }
718 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_StartGetFdTask_0100";
719 }
720
721 /**
722 * @tc.number: SUB_ServiceIncremental_RefreshBundleDataSize_0000
723 * @tc.name: SUB_ServiceIncremental_RefreshBundleDataSize_0000
724 * @tc.desc: 测试 RefreshBundleDataSize 的正常/异常分支
725 * @tc.size: MEDIUM
726 * @tc.type: FUNC
727 * @tc.level Level 1
728 * @tc.require: issueIAKC3I
729 */
730 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_RefreshBundleDataSize_0000, TestSize.Level1)
731 {
732 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_RefreshBundleDataSize_0000";
733 try {
734 service->RefreshBundleDataSize({}, "", nullptr);
735 EXPECT_TRUE(true);
736
737 auto session_ = service->session_;
738 service->session_ = nullptr;
739 service->RefreshBundleDataSize({}, "", service);
740 EXPECT_TRUE(true);
741
742 service->session_ = session_;
743 BJsonUtil::BundleDetailInfo bundleInfo;
744 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
745 service->RefreshBundleDataSize({}, "", service);
746 EXPECT_TRUE(true);
747
748 bundleInfo.bundleIndex = 0;
749 bundleInfo.bundleName = "bundleName";
750 vector<BJsonEntityCaps::BundleInfo> infos;
751 infos.emplace_back(BJsonEntityCaps::BundleInfo{.name = "bundleName", .appIndex = 0});
752 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
753 service->RefreshBundleDataSize(infos, "", service);
754 EXPECT_TRUE(true);
755
756 bundleInfo.bundleIndex = 1;
757 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
758 service->RefreshBundleDataSize(infos, "", service);
759 EXPECT_TRUE(true);
760
761 bundleInfo.bundleName = "appName";
762 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
763 service->RefreshBundleDataSize(infos, "", service);
764 EXPECT_TRUE(true);
765 } catch (...) {
766 EXPECT_TRUE(false);
767 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by RefreshBundleDataSize.";
768 }
769 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_RefreshBundleDataSize_0000";
770 }
771
772 /**
773 * @tc.number: SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000
774 * @tc.name: SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000
775 * @tc.desc: 测试 GetAppLocalListAndDoIncrementalBackup 的正常/异常分支
776 * @tc.size: MEDIUM
777 * @tc.type: FUNC
778 * @tc.level Level 1
779 * @tc.require: issueIAKC3I
780 */
781 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000, TestSize.Level1)
782 {
783 GTEST_LOG_(INFO) <<
784 "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000";
785 try {
786 auto session_ = service->session_;
787 service->session_ = nullptr;
788 EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::SA_INVAL_ARG).GetCode());
789 service->session_ = session_;
790
791 service->isOccupyingSession_ = true;
792 EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::SA_INVAL_ARG).GetCode());
793
794 service->isOccupyingSession_ = false;
795 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
796 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
797 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
798 EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::SA_INVAL_ARG).GetCode());
799
800 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
801 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
802 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
803 EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::OK).GetCode());
804 } catch (...) {
805 EXPECT_TRUE(false);
806 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetAppLocalListAndDoIncrementalBackup.";
807 }
808 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000";
809 }
810
811 /**
812 * @tc.number: SUB_ServiceIncremental_InitIncrementalBackupSession_0000
813 * @tc.name: SUB_ServiceIncremental_InitIncrementalBackupSession_0000
814 * @tc.desc: 测试 InitIncrementalBackupSession 的正常/异常分支
815 * @tc.size: MEDIUM
816 * @tc.type: FUNC
817 * @tc.level Level 1
818 * @tc.require: issueIAKC3I
819 */
820 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_InitIncrementalBackupSession_0000, TestSize.Level1)
821 {
822 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_InitIncrementalBackupSession_0000";
823 try {
824 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
825 EXPECT_CALL(*srvMock, GetCallerName()).WillRepeatedly(Return(""));
826 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::SA_INVAL_ARG).GetCode());
827 auto session_ = service->session_;
828 service->session_ = nullptr;
829 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
830 sptr<IServiceReverse> srPrt = static_cast<sptr<IServiceReverse>>(srProxy);
831 srPrt = nullptr;
832 EXPECT_EQ(service->InitIncrementalBackupSession(srPrt), BError(BError::Codes::SA_INVAL_ARG).GetCode());
833 service->session_ = session_;
834
835 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
836 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
837 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
838 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK)));
839 EXPECT_EQ(service->InitIncrementalBackupSession(srPrt), BError(BError::Codes::OK).GetCode());
840
841 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
842 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
843 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
844 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_SESSION_CONFLICT)));
845 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::SA_SESSION_CONFLICT).GetCode());
846
847 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
848 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
849 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
850 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG)));
851 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::SA_INVAL_ARG).GetCode());
852
853 } catch (...) {
854 EXPECT_TRUE(false);
855 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by InitIncrementalBackupSession.";
856 }
857 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_InitIncrementalBackupSession_0000";
858 }
859
860 /**
861 * @tc.number: SUB_ServiceIncremental_InitIncrementalBackupSession_0100
862 * @tc.name: SUB_ServiceIncremental_InitIncrementalBackupSession_0100
863 * @tc.desc: 测试 InitIncrementalBackupSession with errMsg的正常/异常分支
864 * @tc.size: MEDIUM
865 * @tc.type: FUNC
866 * @tc.level Level 1
867 * @tc.require: issueIAKC3I
868 */
869 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_InitIncrementalBackupSession_0100, TestSize.Level1)
870 {
871 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_InitIncrementalBackupSession_0100";
872 try {
873 std::string errMsg;
874 sptr<IServiceReverse> reverseNUll = nullptr;
875 ErrCode errCode;
876 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
877 EXPECT_CALL(*srvMock, GetCallerName()).WillRepeatedly(Return(""));
878 service->InitIncrementalBackupSessionWithErrMsg(reverseNUll, errCode, errMsg);
879 EXPECT_EQ(errCode, BError(BError::Codes::SA_INVAL_ARG).GetCode());
880
881 auto session_ = service->session_;
882 service->session_ = nullptr;
883 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
884 service->InitIncrementalBackupSessionWithErrMsg(reverseNUll, errCode, errMsg);
885 EXPECT_EQ(errCode, BError(BError::Codes::SA_INVAL_ARG).GetCode());
886 service->session_ = session_;
887
888 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
889 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
890 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
891 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK)));
892 service->InitIncrementalBackupSessionWithErrMsg(reverseNUll, errCode, errMsg);
893 EXPECT_EQ(errCode, BError(BError::Codes::OK).GetCode());
894 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
895 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
896 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
897 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_SESSION_CONFLICT)));
898 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
899 EXPECT_CALL(*session, GetSessionCallerName()).WillOnce(Return(""));
900 EXPECT_CALL(*session, GetSessionActiveTime()).WillOnce(Return(""));
901 EXPECT_CALL(*jsonUtil, BuildInitSessionErrInfo(_, _, _)).WillOnce(Return(""));
902 service->InitIncrementalBackupSessionWithErrMsg(reverseNUll, errCode, errMsg);
903 EXPECT_EQ(errCode, BError(BError::Codes::SA_SESSION_CONFLICT).GetCode());
904
905 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
906 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
907 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
908 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG)));
909 service->InitIncrementalBackupSessionWithErrMsg(reverseNUll, errCode, errMsg);
910 EXPECT_EQ(errCode, BError(BError::Codes::SA_INVAL_ARG).GetCode());
911 } catch (...) {
912 EXPECT_TRUE(false);
913 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by InitIncrementalBackupSession.";
914 }
915 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_InitIncrementalBackupSession_0100";
916 }
917
918 /**
919 * @tc.number: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000
920 * @tc.name: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000
921 * @tc.desc: 测试 AppendBundlesIncrementalBackupSession 的正常/异常分支
922 * @tc.size: MEDIUM
923 * @tc.type: FUNC
924 * @tc.level Level 1
925 * @tc.require: issueIAKC3I
926 */
927 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000, TestSize.Level1)
928 {
929 GTEST_LOG_(INFO) <<
930 "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000";
931 try {
932 auto session_ = service->session_;
933 service->session_ = nullptr;
934 EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::SA_INVAL_ARG).GetCode());
935 service->session_ = session_;
936
937 service->isOccupyingSession_ = true;
938 EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::SA_INVAL_ARG).GetCode());
939
940 service->isOccupyingSession_ = false;
941 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
942 EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::SA_INVAL_ARG).GetCode());
943
944 std::vector<std::string> supportBackupNames;
945 vector<BJsonEntityCaps::BundleInfo> bundleInfos;
946 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
947 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0));
948 EXPECT_CALL(*bms, GetBundleInfosForAppendBundles(_, _)).WillOnce(Return(bundleInfos));
949 EXPECT_CALL(*srvMock, GetSupportBackupBundleNames(_, _, _)).WillOnce(Return(supportBackupNames));
950 EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::OK).GetCode());
951 } catch (...) {
952 EXPECT_TRUE(false);
953 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppendBundlesIncrementalBackupSession.";
954 }
955 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000";
956 }
957
958 /**
959 * @tc.number: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100
960 * @tc.name: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100
961 * @tc.desc: 测试 AppendBundlesIncrementalBackupSession 的正常/异常分支
962 * @tc.size: MEDIUM
963 * @tc.type: FUNC
964 * @tc.level Level 1
965 * @tc.require: issueIAKC3I
966 */
967 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100, TestSize.Level1)
968 {
969 GTEST_LOG_(INFO) <<
970 "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100";
971 try {
972 auto session_ = service->session_;
973 service->session_ = nullptr;
974 auto ret = service->AppendBundlesIncrementalBackupSession({}, {});
975 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
976 service->session_ = session_;
977
978 service->isOccupyingSession_ = true;
979 ret = service->AppendBundlesIncrementalBackupSession({}, {});
980 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
981
982 service->isOccupyingSession_ = false;
983 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
984 ret = service->AppendBundlesIncrementalBackupSession({}, {});
985 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
986
987 std::vector<std::string> supportBackupNames;
988 vector<BJsonEntityCaps::BundleInfo> bundleInfos;
989 std::map<std::string, std::vector<BJsonUtil::BundleDetailInfo>> bundleNameDetailMap;
990 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
991 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0));
992 EXPECT_CALL(*jsonUtil, BuildBundleInfos(_, _, _, _, _)).WillOnce(Return(bundleNameDetailMap));
993 EXPECT_CALL(*bms, GetBundleInfosForAppendBundles(_, _)).WillOnce(Return(bundleInfos));
994 EXPECT_CALL(*srvMock, GetSupportBackupBundleNames(_, _, _)).WillOnce(Return(supportBackupNames));
995 ret = service->AppendBundlesIncrementalBackupSession({}, {});
996 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
997 } catch (...) {
998 EXPECT_TRUE(false);
999 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppendBundlesIncrementalBackupSession.";
1000 }
1001 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100";
1002 }
1003
1004 /**
1005 * @tc.number: SUB_ServiceIncremental_PublishIncrementalFile_0000
1006 * @tc.name: SUB_ServiceIncremental_PublishIncrementalFile_0000
1007 * @tc.desc: 测试 PublishIncrementalFile 的正常/异常分支
1008 * @tc.size: MEDIUM
1009 * @tc.type: FUNC
1010 * @tc.level Level 1
1011 * @tc.require: issueIAKC3I
1012 */
1013 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_PublishIncrementalFile_0000, TestSize.Level1)
1014 {
1015 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_PublishIncrementalFile_0000";
1016 try {
1017 BFileInfo fileInfo;
1018 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1019 auto ret = service->PublishIncrementalFile(fileInfo);
1020 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1021
1022 fileInfo.fileName = "test";
1023 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1024 ret = service->PublishIncrementalFile(fileInfo);
1025 EXPECT_EQ(ret, EPERM);
1026
1027 fileInfo.fileName.clear();
1028 auto session_ = service->session_;
1029 service->session_ = nullptr;
1030 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1031 ret = service->PublishIncrementalFile(fileInfo);
1032 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1033
1034 service->session_ = session_;
1035 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1036 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1037 ret = service->PublishIncrementalFile(fileInfo);
1038 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1039
1040 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1041 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1042 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
1043 ret = service->PublishIncrementalFile(fileInfo);
1044 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1045
1046 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1047 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1048 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1049 EXPECT_CALL(*svcProxy, PublishIncrementalFile(_))
1050 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1051 ret = service->PublishIncrementalFile(fileInfo);
1052 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1053
1054 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1055 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1056 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1057 EXPECT_CALL(*svcProxy, PublishIncrementalFile(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1058 ret = service->PublishIncrementalFile(fileInfo);
1059 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1060 } catch (...) {
1061 EXPECT_TRUE(false);
1062 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by PublishIncrementalFile.";
1063 }
1064 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_PublishIncrementalFile_0000";
1065 }
1066
1067 /**
1068 * @tc.number: SUB_ServiceIncremental_PublishSAIncrementalFile_0000
1069 * @tc.name: SUB_ServiceIncremental_PublishSAIncrementalFile_0000
1070 * @tc.desc: 测试 PublishSAIncrementalFile 的正常/异常分支
1071 * @tc.size: MEDIUM
1072 * @tc.type: FUNC
1073 * @tc.level Level 1
1074 * @tc.require: issueIAKC3I
1075 */
1076 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_PublishSAIncrementalFile_0000, TestSize.Level1)
1077 {
1078 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_PublishSAIncrementalFile_0000";
1079 try {
1080 BFileInfo fileInfo;
1081 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1082 auto ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
1083 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1084
1085 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1086 ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
1087 EXPECT_EQ(ret, BError(BError::Codes::SA_EXT_ERR_CALL).GetCode());
1088
1089 fileInfo.owner = "abc";
1090 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1091 ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
1092 EXPECT_EQ(ret, BError(BError::Codes::SA_EXT_ERR_CALL).GetCode());
1093
1094 fileInfo.owner = "123";
1095 shared_ptr<SABackupConnection> sa = nullptr;
1096 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1097 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1098 ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
1099 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1100
1101 sa = make_shared<SABackupConnection>(nullptr, nullptr, nullptr, nullptr);
1102 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1103 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1104 EXPECT_CALL(*saConnect, CallRestoreSA(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1105 ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
1106 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1107 } catch (...) {
1108 EXPECT_TRUE(false);
1109 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by PublishSAIncrementalFile.";
1110 }
1111 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_PublishSAIncrementalFile_0000";
1112 }
1113
1114 /**
1115 * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0000
1116 * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0000
1117 * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支
1118 * @tc.size: MEDIUM
1119 * @tc.type: FUNC
1120 * @tc.level Level 1
1121 * @tc.require: issueIAKC3I
1122 */
1123 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0000, TestSize.Level1)
1124 {
1125 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0000";
1126 try {
1127 string bundleName;
1128 string fileName;
1129 int32_t errCode = 0;
1130 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1131 .WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1132 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1133 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1134 EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1135 auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1136 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1137
1138 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1139 .WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1140 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1141 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1142 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1143 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1144 ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1145 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1146
1147 fileName = BConstants::EXT_BACKUP_MANAGE;
1148 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1149 .WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1150 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1151 EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1)));
1152 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1153 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1154 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1155 ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1156 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1157 } catch (...) {
1158 EXPECT_TRUE(false);
1159 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady.";
1160 }
1161 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0000";
1162 }
1163
1164 /**
1165 * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0100
1166 * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0100
1167 * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支
1168 * @tc.size: MEDIUM
1169 * @tc.type: FUNC
1170 * @tc.level Level 1
1171 * @tc.require: issueIAKC3I
1172 */
1173 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0100, TestSize.Level1)
1174 {
1175 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0100";
1176 try {
1177 string bundleName;
1178 string fileName;
1179 int32_t errCode = 0;
1180 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1181 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1182 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1183 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1184 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1185 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1186 EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _))
1187 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1188 auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1189 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1190
1191 fileName = BConstants::EXT_BACKUP_MANAGE;
1192 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1193 .WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1194 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1195 EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1)));
1196 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1197 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1198 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1199 EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1200 ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1201 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1202 } catch (...) {
1203 EXPECT_TRUE(false);
1204 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady.";
1205 }
1206 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0100";
1207 }
1208
1209 /**
1210 * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0200
1211 * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0200
1212 * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支
1213 * @tc.size: MEDIUM
1214 * @tc.type: FUNC
1215 * @tc.level Level 1
1216 * @tc.require: issueIAKC3I
1217 */
1218 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0200, TestSize.Level1)
1219 {
1220 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0200";
1221 try {
1222 string fileName;
1223 int32_t errCode = 0;
1224 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1225 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1226 auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1227 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1228
1229 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1230 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1231 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1232 EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1233 ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1234 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1235
1236 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1237 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1238 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1239 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1240 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1241 ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1242 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1243
1244 fileName = BConstants::EXT_BACKUP_MANAGE;
1245 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1246 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1247 EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1)));
1248 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1249 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1250 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1251 ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1252 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1253 } catch (...) {
1254 EXPECT_TRUE(false);
1255 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady.";
1256 }
1257 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0200";
1258 }
1259
1260 /**
1261 * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0300
1262 * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0300
1263 * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支
1264 * @tc.size: MEDIUM
1265 * @tc.type: FUNC
1266 * @tc.level Level 1
1267 * @tc.require: issueIAKC3I
1268 */
1269 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0300, TestSize.Level1)
1270 {
1271 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0300";
1272 try {
1273 string fileName;
1274 int32_t errCode = 0;
1275 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1276 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1277 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1278 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1279 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1280 EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _))
1281 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1282 auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1283 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1284
1285 fileName = BConstants::EXT_BACKUP_MANAGE;
1286 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1287 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1288 EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1)));
1289 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1290 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1291 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1292 EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1293 ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1294 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1295 } catch (...) {
1296 EXPECT_TRUE(false);
1297 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady.";
1298 }
1299 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0300";
1300 }
1301
1302 /**
1303 * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReadyWithoutFd_0000
1304 * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReadyWithoutFd_0000
1305 * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支
1306 * @tc.size: MEDIUM
1307 * @tc.type: FUNC
1308 * @tc.level Level 1
1309 * @tc.require: issueIAKC3I
1310 */
1311 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReadyWithoutFd_0000, TestSize.Level1)
1312 {
1313 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReadyWithoutFd_0000";
1314 try {
1315 string bundleName;
1316 string fileName;
1317 int32_t errCode = 0;
1318 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1319 .WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1320 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1321 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1322 EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1323 auto ret = service->AppIncrementalFileReadyWithoutFd(fileName, errCode);
1324 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1325
1326 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1327 .WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1328 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1329 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1330 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1331 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1332 ret = service->AppIncrementalFileReadyWithoutFd(fileName, errCode);
1333 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1334
1335 fileName = BConstants::EXT_BACKUP_MANAGE;
1336 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1337 .WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1338 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1339 EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1)));
1340 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1341 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1342 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1343 ret = service->AppIncrementalFileReadyWithoutFd(fileName, errCode);
1344 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1345 } catch (...) {
1346 EXPECT_TRUE(false);
1347 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReadyWithoutFd.";
1348 }
1349 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReadyWithoutFd_0000";
1350 }
1351
1352 /**
1353 * @tc.number: SUB_ServiceIncremental_AppIncrementalDone_0000
1354 * @tc.name: SUB_ServiceIncremental_AppIncrementalDone_0000
1355 * @tc.desc: 测试 AppIncrementalDone 的正常/异常分支
1356 * @tc.size: MEDIUM
1357 * @tc.type: FUNC
1358 * @tc.level Level 1
1359 * @tc.require: issueIAKC3I
1360 */
1361 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalDone_0000, TestSize.Level1)
1362 {
1363 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalDone_0000";
1364 try {
1365 int32_t errCode = BError(BError::Codes::OK).GetCode();
1366 auto session_ = service->session_;
1367 service->session_ = nullptr;
1368 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillRepeatedly(Return(100));
1369 BJsonUtil::BundleDetailInfo bundleInfo;
1370 bundleInfo.bundleIndex = 0;
1371 bundleInfo.bundleName = "bundleName";
1372 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
1373 auto ret = service->AppIncrementalDone(errCode);
1374 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1375 service->session_ = session_;
1376
1377 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1378 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1379 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
1380 ret = service->AppIncrementalDone(errCode);
1381 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1382
1383 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1384 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1385 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
1386 ret = service->AppIncrementalDone(errCode);
1387 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1388
1389 service->backupExtMutexMap_.clear();
1390 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1391 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1392 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
1393 ret = service->AppIncrementalDone(BError(BError::Codes::SA_INVAL_ARG).GetCode());
1394 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1395
1396 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1397 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1398 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
1399 ret = service->AppIncrementalDone(errCode);
1400 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1401 } catch (...) {
1402 EXPECT_TRUE(false);
1403 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalDone.";
1404 }
1405 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalDone_0000";
1406 }
1407
1408 /**
1409 * @tc.number: SUB_ServiceIncremental_GetIncrementalFileHandle_0000
1410 * @tc.name: SUB_ServiceIncremental_GetIncrementalFileHandle_0000
1411 * @tc.desc: 测试 GetIncrementalFileHandle 的正常/异常分支
1412 * @tc.size: MEDIUM
1413 * @tc.type: FUNC
1414 * @tc.level Level 1
1415 * @tc.require: issueIAKC3I
1416 */
1417 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle_0000, TestSize.Level1)
1418 {
1419 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetIncrementalFileHandle_0000";
1420 try {
1421 string bundleName;
1422 string fileName;
1423 auto session_ = service->session_;
1424 service->session_ = nullptr;
1425 auto ret = service->GetIncrementalFileHandle(bundleName, fileName);
1426 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1427 service->session_ = session_;
1428
1429 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1430 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1431 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1432
1433 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1434 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::UNKNOWN));
1435 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1436 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1437
1438 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1439 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
1440 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1441 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1442 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1443
1444 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1445 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
1446 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1447 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
1448 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1449 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1450 } catch (...) {
1451 EXPECT_TRUE(false);
1452 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetIncrementalFileHandle.";
1453 }
1454 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetIncrementalFileHandle_0000";
1455 }
1456
1457 /**
1458 * @tc.number: SUB_ServiceIncremental_GetIncrementalFileHandle_0100
1459 * @tc.name: SUB_ServiceIncremental_GetIncrementalFileHandle_0100
1460 * @tc.desc: 测试 GetIncrementalFileHandle 的正常/异常分支
1461 * @tc.size: MEDIUM
1462 * @tc.type: FUNC
1463 * @tc.level Level 1
1464 * @tc.require: issueIAKC3I
1465 */
1466 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle_0100, TestSize.Level1)
1467 {
1468 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetIncrementalFileHandle_0100";
1469 try {
1470 string bundleName;
1471 string fileName;
1472 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1473 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
1474 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1475 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1476 EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_, _, _, _)).WillOnce(Return(0));
1477 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1478 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1479 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1480 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1481 EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _))
1482 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1483 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
1484 auto ret = service->GetIncrementalFileHandle(bundleName, fileName);
1485 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1486
1487 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1488 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
1489 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1490 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1491 EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_, _, _, _)).WillOnce(Return(0));
1492 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1493 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1494 EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1495 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1496 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1497
1498 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1499 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::WAIT));
1500 EXPECT_CALL(*srvMock, UpdateToRestoreBundleMap(_, _)).WillOnce(Return(true));
1501 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1502 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1503 } catch (...) {
1504 EXPECT_TRUE(false);
1505 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetIncrementalFileHandle.";
1506 }
1507 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetIncrementalFileHandle_0100";
1508 }
1509
1510 /**
1511 * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0000
1512 * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0000
1513 * @tc.desc: 测试 IncrementalBackup 的正常/异常分支
1514 * @tc.size: MEDIUM
1515 * @tc.type: FUNC
1516 * @tc.level Level 1
1517 * @tc.require: issueIAKC3I
1518 */
1519 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0000, TestSize.Level1)
1520 {
1521 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0000";
1522 try {
1523 string bundleName;
1524 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1525 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1526 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1527
1528 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1529 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1530 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
1531 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1532
1533 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1534 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1535 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1536 EXPECT_FALSE(service->IncrementalBackup(bundleName));
1537
1538 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1539 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1540 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1541 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true));
1542 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
1543 EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(0));
1544 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1545 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return(0));
1546 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1547
1548 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1549 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1550 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1551 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true));
1552 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
1553 EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(1));
1554 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1555 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return(0));
1556 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1557
1558 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1559 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1560 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1561 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false));
1562 EXPECT_FALSE(service->IncrementalBackup(bundleName));
1563 } catch (...) {
1564 EXPECT_TRUE(false);
1565 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup.";
1566 }
1567 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_IncrementalBackup_0000";
1568 }
1569
1570 /**
1571 * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0100
1572 * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0100
1573 * @tc.desc: 测试 IncrementalBackup 的正常/异常分支
1574 * @tc.size: MEDIUM
1575 * @tc.type: FUNC
1576 * @tc.level Level 1
1577 * @tc.require: issueIAKC3I
1578 */
1579 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0100, TestSize.Level1)
1580 {
1581 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0100";
1582 try {
1583 string bundleName;
1584 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1585 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1586 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1587 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false));
1588 EXPECT_FALSE(service->IncrementalBackup(bundleName));
1589
1590 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1591 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1592 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1593 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true));
1594 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false));
1595 EXPECT_FALSE(service->IncrementalBackup(bundleName));
1596
1597 set<string> fileNameVec { "fileName" };
1598 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE))
1599 .WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1600 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1601 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1602 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true));
1603 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true));
1604 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
1605 EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1606 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy));
1607 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return(0));
1608 EXPECT_CALL(*session, GetOldBackupVersion()).WillOnce(Return(""));
1609 EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec));
1610 EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_, _, _, _)).WillOnce(Return(0));
1611 EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1612 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1613 } catch (...) {
1614 EXPECT_TRUE(false);
1615 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup.";
1616 }
1617 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_IncrementalBackup_0100";
1618 }
1619
1620 /**
1621 * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0200
1622 * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0200
1623 * @tc.desc: 测试 IncrementalBackup 的正常/异常分支
1624 * @tc.size: MEDIUM
1625 * @tc.type: FUNC
1626 * @tc.level Level 1
1627 * @tc.require: issueIAKC3I
1628 */
1629 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0200, TestSize.Level1)
1630 {
1631 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0200";
1632 try {
1633 string bundleName;
1634 set<string> fileNameVec { "fileName" };
1635 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE))
1636 .WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1637 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1638 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1639 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true));
1640 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true));
1641 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
1642 EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1643 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy));
1644 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return(0));
1645 EXPECT_CALL(*session, GetOldBackupVersion()).WillOnce(Return("1.0.0"));
1646 EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec));
1647 EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_, _, _, _)).WillOnce(Return(0));
1648 EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return(0));
1649 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1650
1651 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1652 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1653 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1654 EXPECT_FALSE(service->IncrementalBackup(bundleName));
1655 } catch (...) {
1656 EXPECT_TRUE(false);
1657 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup.";
1658 }
1659 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_IncrementalBackup_0200";
1660 }
1661
1662 /**
1663 * @tc.number: SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000
1664 * @tc.name: SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000
1665 * @tc.desc: 测试 NotifyCallerCurAppIncrementDone 的正常/异常分支
1666 * @tc.size: MEDIUM
1667 * @tc.type: FUNC
1668 * @tc.level Level 1
1669 * @tc.require: issueIAKC3I
1670 */
1671 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000, TestSize.Level1)
1672 {
1673 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000";
1674 try {
1675 ErrCode errCode = 0;
1676 string callerName;
1677 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1678 service->NotifyCallerCurAppIncrementDone(errCode, callerName);
1679 EXPECT_TRUE(true);
1680
1681 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1682 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1683 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return(0));
1684 service->NotifyCallerCurAppIncrementDone(errCode, callerName);
1685 EXPECT_TRUE(true);
1686
1687 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1688 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1689 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return(0));
1690 service->NotifyCallerCurAppIncrementDone(errCode, callerName);
1691 EXPECT_TRUE(true);
1692 } catch (...) {
1693 EXPECT_TRUE(false);
1694 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by NotifyCallerCurAppIncrementDone.";
1695 }
1696 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0200";
1697 }
1698
1699 /**
1700 * @tc.number: SUB_ServiceIncremental_SendUserIdToApp_0000
1701 * @tc.name: SUB_ServiceIncremental_SendUserIdToApp_0000
1702 * @tc.desc: 测试 SendUserIdToApp 的正常/异常分支
1703 * @tc.size: MEDIUM
1704 * @tc.type: FUNC
1705 * @tc.level Level 1
1706 * @tc.require: issueIAKC3I
1707 */
1708 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SendUserIdToApp_0000, TestSize.Level1)
1709 {
1710 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SendUserIdToApp_0000";
1711 try {
1712 string bundleName;
1713 int32_t userId = 100;
1714 auto session_ = service->session_;
1715 service->session_ = nullptr;
1716 service->SendUserIdToApp(bundleName, userId);
1717 service->session_ = session_;
1718 EXPECT_TRUE(true);
1719
1720 EXPECT_CALL(*jsonUtil, BuildBundleInfoJson(_, _)).WillOnce(Return(false));
1721 service->SendUserIdToApp(bundleName, userId);
1722 EXPECT_TRUE(true);
1723
1724 EXPECT_CALL(*jsonUtil, BuildBundleInfoJson(_, _)).WillOnce(Return(true));
1725 service->SendUserIdToApp(bundleName, userId);
1726 EXPECT_TRUE(true);
1727 } catch (...) {
1728 EXPECT_TRUE(false);
1729 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by SendUserIdToApp.";
1730 }
1731 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SendUserIdToApp_0200";
1732 }
1733
1734 /**
1735 * @tc.number: SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000
1736 * @tc.name: SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000
1737 * @tc.desc: 测试 SetCurrentBackupSessProperties 的正常/异常分支
1738 * @tc.size: MEDIUM
1739 * @tc.type: FUNC
1740 * @tc.level Level 1
1741 * @tc.require: issueIAKC3I
1742 */
1743 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000, TestSize.Level1)
1744 {
1745 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000";
1746 try {
1747 vector<string> bundleNames { "bundleName" };
1748 int32_t userId = 100;
1749 vector<BJsonEntityCaps::BundleInfo> bundleInfos;
1750 auto session_ = service->session_;
1751 service->session_ = nullptr;
1752 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
1753 service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, true);
1754 EXPECT_TRUE(true);
1755
1756 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(true));
1757 service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, true);
1758 EXPECT_TRUE(true);
1759
1760 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
1761 service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, false);
1762 EXPECT_TRUE(true);
1763
1764 BJsonEntityCaps::BundleInfo bundleInfo;
1765 bundleInfo.name = "bundleName";
1766 bundleInfos.push_back(bundleInfo);
1767 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"));
1768 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
1769 service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, false);
1770 EXPECT_TRUE(true);
1771
1772 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"));
1773 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
1774 service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, true);
1775 EXPECT_TRUE(true);
1776 service->session_ = session_;
1777 } catch (...) {
1778 EXPECT_TRUE(false);
1779 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by SetCurrentBackupSessProperties.";
1780 }
1781 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SetCurrentBackupSessProperties_0200";
1782 }
1783
1784 /**
1785 * @tc.number: SUB_ServiceIncremental_Release_0000
1786 * @tc.name: SUB_ServiceIncremental_Release_0000
1787 * @tc.desc: 测试 Release 的正常/异常分支
1788 * @tc.size: MEDIUM
1789 * @tc.type: FUNC
1790 * @tc.level Level 1
1791 * @tc.require: issueIAKC3I
1792 */
1793 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Release_0000, TestSize.Level1)
1794 {
1795 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Release_0000";
1796 try {
1797 auto session_ = service->session_;
1798 service->session_ = nullptr;
1799 auto ret = service->Release();
1800 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1801
1802 service->session_ = session_;
1803 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1804 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1805 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
1806 ret = service->Release();
1807 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1808
1809 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1810 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1811 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
1812 ret = service->Release();
1813 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1814
1815 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1816 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1817 ret = service->Release();
1818 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1819 } catch (...) {
1820 EXPECT_TRUE(false);
1821 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by Release.";
1822 }
1823 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Release_0200";
1824 }
1825
1826 /**
1827 * @tc.number: SUB_ServiceIncremental_SetBundleIncDataInfo_0000
1828 * @tc.name: SUB_ServiceIncremental_SetBundleIncDataInfo_0000
1829 * @tc.desc: 测试 SetBundleIncDataInfo 的正常/异常分支
1830 * @tc.size: MEDIUM
1831 * @tc.type: FUNC
1832 * @tc.level Level 1
1833 * @tc.require: issueIAKC3I
1834 */
1835 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetBundleIncDataInfo_0000, TestSize.Level1)
1836 {
1837 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SetBundleIncDataInfo_0000";
1838 try {
1839 vector<BIncrementalData> bundlesToBackup;
1840 vector<string> supportBundleNames;
1841 service->SetBundleIncDataInfo(bundlesToBackup, supportBundleNames);
1842 EXPECT_TRUE(true);
1843
1844 BIncrementalData data;
1845 data.bundleName = "bundleName";
1846 bundlesToBackup.push_back(data);
1847 service->SetBundleIncDataInfo(bundlesToBackup, supportBundleNames);
1848 EXPECT_TRUE(true);
1849
1850 supportBundleNames.emplace_back("bundleName");
1851 service->SetBundleIncDataInfo(bundlesToBackup, supportBundleNames);
1852 EXPECT_TRUE(true);
1853 } catch (...) {
1854 EXPECT_TRUE(false);
1855 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by SetBundleIncDataInfo.";
1856 }
1857 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SetBundleIncDataInfo_0200";
1858 }
1859
1860 /**
1861 * @tc.number: SUB_ServiceIncremental_CancelTask_0000
1862 * @tc.name: SUB_ServiceIncremental_CancelTask_0000
1863 * @tc.desc: 测试 CancelTask 的正常/异常分支
1864 * @tc.size: MEDIUM
1865 * @tc.type: FUNC
1866 * @tc.level Level 1
1867 * @tc.require: issueIAKC3I
1868 */
1869 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0000, TestSize.Level1)
1870 {
1871 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_CancelTask_0000";
1872 try {
1873 service->CancelTask("", nullptr);
1874 EXPECT_TRUE(true);
1875
1876 auto session_ = service->session_;
1877 service->session_ = nullptr;
1878 service->CancelTask("", service);
1879 service->session_ = session_;
1880 EXPECT_TRUE(true);
1881
1882 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1883 service->CancelTask("", service);
1884 EXPECT_TRUE(true);
1885
1886 std::string bundleName = "123";
__anond7cb6eda0202(const string &&bundleName, bool isCleanCalled) 1887 auto callDied = [](const string &&bundleName, bool isCleanCalled) {};
__anond7cb6eda0302(const string &&bundleName) 1888 auto callConnected = [](const string &&bundleName) {};
1889 auto connectPtr = sptr(new SvcBackupConnection(callDied, callConnected, bundleName));
1890
1891 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(wptr(connectPtr)));
1892 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
1893 service->CancelTask("", service);
1894 EXPECT_TRUE(true);
1895
1896 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(wptr(connectPtr)));
1897 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1898 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1899 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false));
1900 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
1901 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1902 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED))
1903 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1904 service->CancelTask("", service);
1905 EXPECT_TRUE(true);
1906
1907 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(wptr(connectPtr)));
1908 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1909 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1910 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false));
1911 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
1912 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1913 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP))
1914 .WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1915 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false));
1916 service->CancelTask("", service);
1917 EXPECT_TRUE(true);
1918 } catch (...) {
1919 EXPECT_TRUE(false);
1920 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by CancelTask.";
1921 }
1922 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_CancelTask_0000";
1923 }
1924
1925 /**
1926 * @tc.number: SUB_ServiceIncremental_CancelTask_0100
1927 * @tc.name: SUB_ServiceIncremental_CancelTask_0100
1928 * @tc.desc: 测试 CancelTask 的正常/异常分支
1929 * @tc.size: MEDIUM
1930 * @tc.type: FUNC
1931 * @tc.level Level 1
1932 * @tc.require: issueIAKC3I
1933 */
1934 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0100, TestSize.Level1)
1935 {
1936 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_CancelTask_0100";
1937 try {
1938 std::string bundleName = "123";
__anond7cb6eda0402(const string &&bundleName, bool isCleanCalled) 1939 auto callDied = [](const string &&bundleName, bool isCleanCalled) {};
__anond7cb6eda0502(const string &&bundleName) 1940 auto callConnected = [](const string &&bundleName) {};
1941 auto connectPtr = sptr(new SvcBackupConnection(callDied, callConnected, bundleName));
1942
1943 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(wptr(connectPtr)));
1944 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1945 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1946 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false));
1947 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
1948 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1949 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP))
1950 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1951 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true));
1952 EXPECT_CALL(*session, GetServiceReverseProxy()).WillRepeatedly(Return(srProxy));
1953 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillRepeatedly(Return(0));
1954 service->CancelTask("", service);
1955 EXPECT_TRUE(true);
1956
1957 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(wptr(connectPtr)));
1958 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1959 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1960 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false));
1961 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
1962 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1963 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE))
1964 .WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1965 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false));
1966 service->CancelTask("", service);
1967 EXPECT_TRUE(true);
1968
1969 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(wptr(connectPtr))).WillOnce(Return(nullptr));
1970 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1971 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1972 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false));
1973 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
1974 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1975 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE))
1976 .WillOnce(Return(IServiceReverseType::Scenario::RESTORE))
1977 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1978 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true));
1979 service->CancelTask("", service);
1980 EXPECT_TRUE(true);
1981 } catch (...) {
1982 EXPECT_TRUE(false);
1983 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by CancelTask.";
1984 }
1985 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_CancelTask_0100";
1986 }
1987
1988 /**
1989 * @tc.number: SUB_ServiceIncremental_Cancel_0000
1990 * @tc.name: SUB_ServiceIncremental_Cancel_0000
1991 * @tc.desc: 测试 Cancel 的正常/异常分支
1992 * @tc.size: MEDIUM
1993 * @tc.type: FUNC
1994 * @tc.level Level 1
1995 * @tc.require: issueIAKC3I
1996 */
1997 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0000, TestSize.Level1)
1998 {
1999 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Cancel_0000";
2000 try {
2001 string bundleName = "com.example.app2backup";
2002 BackupExtInfo info {};
2003 info.backupExtName = "com.example.app2backup";
2004 SvcSessionManager::Impl impl;
2005 int32_t result;
2006
2007 auto session_ = service->session_;
2008 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
2009 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2010 EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
2011 service->CancelForResult(bundleName, result);
2012 EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode());
2013
2014 impl.backupExtNameMap.insert(make_pair(bundleName, info));
2015 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
2016 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2017 EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
2018 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::UNKNOWN));
2019 service->CancelForResult(bundleName, result);
2020 EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode());
2021
2022 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
2023 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2024 EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
2025 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::CLEAN));
2026 service->CancelForResult(bundleName, result);
2027 EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode());
2028 } catch (...) {
2029 EXPECT_TRUE(false);
2030 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by Cancel.";
2031 }
2032 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Cancel_0000";
2033 }
2034
2035 /**
2036 * @tc.number: SUB_ServiceIncremental_Cancel_0100
2037 * @tc.name: SUB_ServiceIncremental_Cancel_0100
2038 * @tc.desc: 测试 Cancel 的正常/异常分支
2039 * @tc.size: MEDIUM
2040 * @tc.type: FUNC
2041 * @tc.level Level 1
2042 * @tc.require: issueIAKC3I
2043 */
2044 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0100, TestSize.Level1)
2045 {
2046 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Cancel_0000";
2047 try {
2048 string bundleName = "com.example.app2backup";
2049 BackupExtInfo info {};
2050 info.backupExtName = "com.example.app2backup";
2051 SvcSessionManager::Impl impl;
2052 int32_t result;
2053
2054 impl.backupExtNameMap.insert(make_pair(bundleName, info));
2055 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
2056 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2057 EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
2058 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::START));
2059 service->CancelForResult(bundleName, result);
2060 EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode());
2061
2062 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
2063 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2064 EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
2065 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
2066 service->CancelForResult(bundleName, result);
2067 EXPECT_EQ(result, BError(BError::Codes::OK).GetCode());
2068 } catch (...) {
2069 EXPECT_TRUE(false);
2070 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by Cancel.";
2071 }
2072 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Cancel_0100";
2073 }
2074
2075 /**
2076 * @tc.number: SUB_ServiceIncremental_GetExtensionMutex_0000
2077 * @tc.name: SUB_ServiceIncremental_GetExtensionMutex_0000
2078 * @tc.desc: 测试 GetExtensionMutex 的正常/异常分支
2079 * @tc.size: MEDIUM
2080 * @tc.type: FUNC
2081 * @tc.level Level 1
2082 * @tc.require: issueIAKC3I
2083 */
2084 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetExtensionMutex_0000, TestSize.Level1)
2085 {
2086 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetExtensionMutex_0000";
2087 try {
2088 BundleName bundleName = "bundleName";
2089 service->backupExtMutexMap_.clear();
2090 auto ret = service->GetExtensionMutex(bundleName);
2091 EXPECT_TRUE(ret != nullptr);
2092
2093 ret = service->GetExtensionMutex(bundleName);
2094 EXPECT_TRUE(ret != nullptr);
2095 service->backupExtMutexMap_.clear();
2096 } catch (...) {
2097 EXPECT_TRUE(false);
2098 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetExtensionMutex.";
2099 }
2100 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetExtensionMutex_0000";
2101 }
2102
2103 /**
2104 * @tc.number: SUB_ServiceIncremental_RemoveExtensionMutex_0000
2105 * @tc.name: SUB_ServiceIncremental_RemoveExtensionMutex_0000
2106 * @tc.desc: 测试 RemoveExtensionMutex 的正常/异常分支
2107 * @tc.size: MEDIUM
2108 * @tc.type: FUNC
2109 * @tc.level Level 1
2110 * @tc.require: issueIAKC3I
2111 */
2112 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_RemoveExtensionMutex_0000, TestSize.Level1)
2113 {
2114 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_RemoveExtensionMutex_0000";
2115 try {
2116 BundleName bundleName = "bundleName";
2117 service->backupExtMutexMap_.clear();
2118 service->RemoveExtensionMutex(bundleName);
2119 EXPECT_TRUE(true);
2120
2121 service->backupExtMutexMap_[bundleName] = nullptr;
2122 service->RemoveExtensionMutex(bundleName);
2123 EXPECT_TRUE(true);
2124 service->backupExtMutexMap_.clear();
2125 } catch (...) {
2126 EXPECT_TRUE(false);
2127 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by RemoveExtensionMutex.";
2128 }
2129 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_RemoveExtensionMutex_0000";
2130 }
2131
2132 /**
2133 * @tc.number: SUB_ServiceIncremental_ClearIncrementalStatFile_0000
2134 * @tc.name: SUB_ServiceIncremental_ClearIncrementalStatFile_0000
2135 * @tc.desc: 测试 ClearIncrementalStatFile 分身与一般应用分支
2136 * @tc.size: MEDIUM
2137 * @tc.type: FUNC
2138 * @tc.level Level 1
2139 * @tc.require: issueIAKC3I
2140 */
2141 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_ClearIncrementalStatFile_0000, TestSize.Level1)
2142 {
2143 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_ClearIncrementalStatFile_0000";
2144 try {
2145
2146 int userId = BConstants::DEFAULT_USER_ID;
2147 ASSERT_TRUE(service != nullptr);
2148 BJsonUtil::BundleDetailInfo bundleInfo;
2149 bundleInfo.bundleIndex = 1;
2150 bundleInfo.bundleName = "com.example.app2backup";
2151 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
2152 service->ClearIncrementalStatFile(userId, bundleInfo.bundleName);
2153
2154 bundleInfo.bundleIndex = 0;
2155 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
2156 service->ClearIncrementalStatFile(userId, bundleInfo.bundleName);
2157 EXPECT_EQ(bundleInfo.bundleIndex, 0);
2158 } catch (...) {
2159 EXPECT_TRUE(false);
2160 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by ClearIncrementalStatFile.";
2161 }
2162 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_ClearIncrementalStatFile_0000";
2163 }
2164
2165 /**
2166 * @tc.number: SUB_ServiceIncremental_ClearIncrementalStatFile_0100
2167 * @tc.name: SUB_ServiceIncremental_ClearIncrementalStatFile_0100
2168 * @tc.desc: 测试 ClearIncrementalStatFile 的文件删除异常分支
2169 * @tc.size: MEDIUM
2170 * @tc.type: FUNC
2171 * @tc.level Level 1
2172 * @tc.require: issueIAKC3I
2173 */
2174 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_ClearIncrementalStatFile_0100, TestSize.Level1)
2175 {
2176 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_ClearIncrementalStatFile_0100";
2177 try {
2178
2179 int userId = BConstants::DEFAULT_USER_ID;
2180 ASSERT_TRUE(service != nullptr);
2181 BJsonUtil::BundleDetailInfo bundleInfo;
2182 bundleInfo.bundleIndex = 0;
2183 bundleInfo.bundleName = "com.example.app2backup";
2184 string path = BConstants::GetSaBundleBackupRootDir(userId).data() + bundleInfo.bundleName;
2185 string cmdMkdir = string("mkdir -p ") + path;
2186 int ret = system(cmdMkdir.c_str());
2187 EXPECT_EQ(ret, 0);
2188
2189 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
2190 service->ClearIncrementalStatFile(userId, bundleInfo.bundleName);
2191
2192 EXPECT_CALL(*directMock, ForceRemoveDirectoryBMS(_)).WillOnce(Return(false));
2193 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
2194 service->ClearIncrementalStatFile(userId, bundleInfo.bundleName);
2195 EXPECT_EQ(bundleInfo.bundleIndex, 0);
2196 string cmdRmdir = string("rm -r ") + path;
2197 ret = system(cmdRmdir.c_str());
2198 EXPECT_EQ(ret, 0);
2199 } catch (...) {
2200 EXPECT_TRUE(false);
2201 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by ClearIncrementalStatFile.";
2202 }
2203 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_ClearIncrementalStatFile_0100";
2204 }
2205 }