• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 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 <functional>
17 #include <chrono>
18 #include <thread>
19 #include <message_parcel.h>
20 
21 #include "gtest/gtest.h"
22 
23 #include "background_task_mgr_proxy.h"
24 
25 #include "background_task_manager.h"
26 #include "background_task_subscriber.h"
27 #include "background_task_subscriber_stub.h"
28 #include "background_task_subscriber_proxy.h"
29 #include "bgtaskmgr_inner_errors.h"
30 #include "bgtaskmgr_log_wrapper.h"
31 #include "continuous_task_callback_info.h"
32 #include "continuous_task_param.h"
33 #include "delay_suspend_info.h"
34 #include "efficiency_resource_info.h"
35 #include "expired_callback.h"
36 #include "expired_callback_proxy.h"
37 #include "expired_callback_stub.h"
38 #include "mock_background_task_mgr_proxy_helper.h"
39 #include "mock_message_parcel_helper.h"
40 #include "iservice_registry.h"
41 #include "resource_callback_info.h"
42 #include "singleton.h"
43 #include "transient_task_app_info.h"
44 
45 using namespace testing::ext;
46 
47 namespace OHOS {
48 namespace BackgroundTaskMgr {
49 class BgTaskFrameworkAbnormalUnitTest : public testing::Test {
50 public:
SetUpTestCase()51     static void SetUpTestCase() {}
TearDownTestCase()52     static void TearDownTestCase() {}
SetUp()53     void SetUp() override {}
TearDown()54     void TearDown() override {}
55 };
56 
57 class TestExpiredCallback : public ExpiredCallback {
58 public:
OnExpired()59     void OnExpired() override {}
60 };
61 
62 class TestBackgroundTaskSubscriber : public BackgroundTaskSubscriber {};
63 
64 class TestBackgroundTaskSubscriberStub : public BackgroundTaskSubscriberStub {
OnConnected()65     ErrCode OnConnected() override {return ERR_OK;}
OnDisconnected()66     ErrCode OnDisconnected() override {return ERR_OK;}
OnTransientTaskStart(const TransientTaskAppInfo & info)67     ErrCode OnTransientTaskStart(const TransientTaskAppInfo& info) override {return ERR_OK;}
OnAppTransientTaskStart(const TransientTaskAppInfo & info)68     ErrCode OnAppTransientTaskStart(const TransientTaskAppInfo& info) override {return ERR_OK;}
OnAppTransientTaskEnd(const TransientTaskAppInfo & info)69     ErrCode OnAppTransientTaskEnd(const TransientTaskAppInfo& info) override {return ERR_OK;}
OnTransientTaskEnd(const TransientTaskAppInfo & info)70     ErrCode OnTransientTaskEnd(const TransientTaskAppInfo& info) override {return ERR_OK;}
OnTransientTaskErr(const TransientTaskAppInfo & info)71     ErrCode OnTransientTaskErr(const TransientTaskAppInfo& info) override {return ERR_OK;}
OnContinuousTaskStart(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)72     ErrCode OnContinuousTaskStart(
73         const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;}
OnContinuousTaskUpdate(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)74     ErrCode OnContinuousTaskUpdate(
75         const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;}
OnContinuousTaskStop(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)76     ErrCode OnContinuousTaskStop(
77         const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;}
OnAppContinuousTaskStop(int32_t uid)78     ErrCode OnAppContinuousTaskStop(int32_t uid) override {return ERR_OK;}
OnAppEfficiencyResourcesApply(const ResourceCallbackInfo & resourceInfo)79     ErrCode OnAppEfficiencyResourcesApply(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;}
OnAppEfficiencyResourcesReset(const ResourceCallbackInfo & resourceInfo)80     ErrCode OnAppEfficiencyResourcesReset(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;}
OnProcEfficiencyResourcesApply(const ResourceCallbackInfo & resourceInfo)81     ErrCode OnProcEfficiencyResourcesApply(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;}
OnProcEfficiencyResourcesReset(const ResourceCallbackInfo & resourceInfo)82     ErrCode OnProcEfficiencyResourcesReset(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;}
83 };
84 
85 class TestExpiredCallbackStub : public ExpiredCallbackStub {
86 public:
OnExpired()87     ErrCode OnExpired() override {return ERR_OK;}
88 };
89 
90 /**
91  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_001
92  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
93  * @tc.type: FUNC
94  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
95  */
96 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_001, TestSize.Level1)
97 {
98     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
99     DelaySuspendInfo delayInfo;
100     sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
101 
102     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", nullptr, delayInfo),
103         ERR_INVALID_DATA);
104 
105     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
106     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
107         ERR_INVALID_VALUE);
108 
109     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
110     MessageParcelHelper::BgTaskFwkAbnormalSetWriteString16Flag(false);
111     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
112         ERR_INVALID_DATA);
113 
114     MessageParcelHelper::BgTaskFwkAbnormalSetWriteString16Flag(true);
115     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(false);
116     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
117         ERR_INVALID_DATA);
118 
119     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(true);
120     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
121         ERR_INVALID_DATA);
122     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
123     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
124     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
125         ERR_INVALID_DATA);
126     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(true);
127     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
128         ERR_INVALID_DATA);
129 }
130 
131 /**
132  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_002
133  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
134  * @tc.type: FUNC
135  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
136  */
137 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_002, TestSize.Level1)
138 {
139     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
140 
141     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
142     EXPECT_EQ(backgroundTaskMgrProxy.CancelSuspendDelay(1), ERR_INVALID_VALUE);
143 
144     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
145     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
146     EXPECT_EQ(backgroundTaskMgrProxy.CancelSuspendDelay(1), ERR_INVALID_DATA);
147 
148     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
149     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
150     EXPECT_EQ(backgroundTaskMgrProxy.CancelSuspendDelay(1), ERR_INVALID_DATA);
151 
152     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
153     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
154     EXPECT_EQ(backgroundTaskMgrProxy.CancelSuspendDelay(1), ERR_INVALID_DATA);
155 }
156 
157 /**
158  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_003
159  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
160  * @tc.type: FUNC
161  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
162  */
163 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_003, TestSize.Level1)
164 {
165     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
166     int32_t delayTime;
167 
168     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
169     EXPECT_EQ(backgroundTaskMgrProxy.GetRemainingDelayTime(1, delayTime), ERR_INVALID_VALUE);
170 
171     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
172     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
173     EXPECT_EQ(backgroundTaskMgrProxy.GetRemainingDelayTime(1, delayTime), ERR_INVALID_DATA);
174 
175     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
176     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
177     EXPECT_EQ(backgroundTaskMgrProxy.GetRemainingDelayTime(1, delayTime), ERR_INVALID_DATA);
178 
179     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
180     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
181     EXPECT_EQ(backgroundTaskMgrProxy.GetRemainingDelayTime(1, delayTime), ERR_INVALID_DATA);
182 }
183 
184 /**
185  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_004
186  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
187  * @tc.type: FUNC
188  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
189  */
190 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_004, TestSize.Level1)
191 {
192     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
193     int32_t notificationId = -1;
194     int32_t continuousTaskId = -1;
195     EXPECT_EQ(backgroundTaskMgrProxy.StartBackgroundRunning(
196         *new ContinuousTaskParam(), notificationId, continuousTaskId), ERR_INVALID_DATA);
197 
198     sptr<ContinuousTaskParam> taskParam(new ContinuousTaskParam());
199 
200     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
201     EXPECT_EQ(backgroundTaskMgrProxy.StartBackgroundRunning(
202         *taskParam, notificationId, continuousTaskId), ERR_INVALID_VALUE);
203 
204     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
205     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(false);
206     EXPECT_EQ(backgroundTaskMgrProxy.StartBackgroundRunning(
207         *taskParam, notificationId, continuousTaskId), ERR_INVALID_DATA);
208 
209     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(true);
210     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
211     EXPECT_EQ(backgroundTaskMgrProxy.StartBackgroundRunning(
212         *taskParam, notificationId, continuousTaskId), ERR_INVALID_DATA);
213 
214     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
215     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
216     EXPECT_EQ(backgroundTaskMgrProxy.StartBackgroundRunning(
217         *taskParam, notificationId, continuousTaskId), ERR_INVALID_DATA);
218 }
219 
220 /**
221  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_005
222  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
223  * @tc.type: FUNC
224  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V issueI99HSB
225  */
226 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_005, TestSize.Level1)
227 {
228     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
229 
230     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
231     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_VALUE);
232 
233     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
234     MessageParcelHelper::BgTaskFwkAbnormalSetWriteStringFlag(false);
235     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_DATA);
236 
237     MessageParcelHelper::BgTaskFwkAbnormalSetWriteStringFlag(true);
238     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(false);
239     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_DATA);
240 
241     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(true);
242     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
243     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_DATA);
244 
245     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
246     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
247     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_DATA);
248 
249     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
250     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
251     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_DATA);
252 }
253 
254 /**
255  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_006
256  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
257  * @tc.type: FUNC
258  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
259  */
260 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_006, TestSize.Level1)
261 {
262     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
263     EXPECT_EQ(backgroundTaskMgrProxy.SubscribeBackgroundTask(nullptr), ERR_INVALID_DATA);
264 
265     sptr<TestBackgroundTaskSubscriberStub> subscribe =
266         sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub());
267 
268     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
269     EXPECT_EQ(backgroundTaskMgrProxy.SubscribeBackgroundTask(subscribe), ERR_INVALID_VALUE);
270 
271     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
272     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(false);
273     EXPECT_EQ(backgroundTaskMgrProxy.SubscribeBackgroundTask(subscribe), ERR_INVALID_DATA);
274 
275     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(true);
276     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
277     EXPECT_EQ(backgroundTaskMgrProxy.SubscribeBackgroundTask(subscribe), ERR_INVALID_DATA);
278 
279     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
280     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
281     EXPECT_EQ(backgroundTaskMgrProxy.SubscribeBackgroundTask(subscribe), ERR_INVALID_DATA);
282 }
283 
284 /**
285  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_007
286  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
287  * @tc.type: FUNC
288  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
289  */
290 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_007, TestSize.Level1)
291 {
292     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
293     EXPECT_EQ(backgroundTaskMgrProxy.UnsubscribeBackgroundTask(nullptr), ERR_INVALID_DATA);
294 
295     sptr<TestBackgroundTaskSubscriberStub> subscribe =
296         sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub());
297 
298     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
299     EXPECT_EQ(backgroundTaskMgrProxy.UnsubscribeBackgroundTask(subscribe), ERR_INVALID_VALUE);
300 
301     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
302     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(false);
303     EXPECT_EQ(backgroundTaskMgrProxy.UnsubscribeBackgroundTask(subscribe), ERR_INVALID_DATA);
304 
305     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(true);
306     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
307     EXPECT_EQ(backgroundTaskMgrProxy.UnsubscribeBackgroundTask(subscribe), ERR_INVALID_DATA);
308 
309     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
310     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
311     EXPECT_EQ(backgroundTaskMgrProxy.UnsubscribeBackgroundTask(subscribe), ERR_INVALID_DATA);
312 }
313 
314 /**
315  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_008
316  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
317  * @tc.type: FUNC
318  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
319  */
320 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_008, TestSize.Level1)
321 {
322     std::vector<TransientTaskAppInfo> list;
323     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
324 
325     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
326     EXPECT_EQ(backgroundTaskMgrProxy.GetTransientTaskApps(list), ERR_INVALID_VALUE);
327 
328     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
329     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
330     EXPECT_EQ(backgroundTaskMgrProxy.GetTransientTaskApps(list), ERR_INVALID_DATA);
331 
332     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
333     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
334     EXPECT_EQ(backgroundTaskMgrProxy.GetTransientTaskApps(list), ERR_INVALID_DATA);
335 
336     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(true);
337     EXPECT_EQ(backgroundTaskMgrProxy.GetTransientTaskApps(list), ERR_INVALID_DATA);
338 }
339 
340 /**
341  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_009
342  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
343  * @tc.type: FUNC
344  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
345  */
346 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_009, TestSize.Level1)
347 {
348     std::vector<ContinuousTaskCallbackInfo> list;
349     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
350 
351     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
352     EXPECT_EQ(backgroundTaskMgrProxy.GetContinuousTaskApps(list), ERR_INVALID_VALUE);
353 
354     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
355     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
356     EXPECT_EQ(backgroundTaskMgrProxy.GetContinuousTaskApps(list), ERR_INVALID_DATA);
357 
358     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
359     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
360     EXPECT_EQ(backgroundTaskMgrProxy.GetContinuousTaskApps(list), ERR_INVALID_DATA);
361 
362     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(true);
363     EXPECT_EQ(backgroundTaskMgrProxy.GetContinuousTaskApps(list), ERR_INVALID_DATA);
364 }
365 
366 /**
367  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_010
368  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
369  * @tc.type: FUNC
370  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
371  */
372 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_010, TestSize.Level1)
373 {
374     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
375 
376     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
377     EXPECT_EQ(backgroundTaskMgrProxy.StopContinuousTask(1, 1, 1, ""), ERR_INVALID_VALUE);
378 
379     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
380     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
381     EXPECT_EQ(backgroundTaskMgrProxy.StopContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
382 
383     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
384     MessageParcelHelper::BgTaskFwkAbnormalSetWriteUint32Flag(false);
385     EXPECT_EQ(backgroundTaskMgrProxy.StopContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
386 
387     MessageParcelHelper::BgTaskFwkAbnormalSetWriteUint32Flag(true);
388     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
389     EXPECT_EQ(backgroundTaskMgrProxy.StopContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
390 
391     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
392     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
393     EXPECT_EQ(backgroundTaskMgrProxy.StopContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
394 }
395 
396 /**
397  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_011
398  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
399  * @tc.type: FUNC
400  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
401  */
402 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_011, TestSize.Level1)
403 {
404     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
405     EXPECT_EQ(backgroundTaskMgrProxy.ApplyEfficiencyResources(*new EfficiencyResourceInfo()), ERR_INVALID_DATA);
406 
407     sptr<EfficiencyResourceInfo> resourceInfo = new (std::nothrow) EfficiencyResourceInfo();
408 
409     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
410     EXPECT_EQ(backgroundTaskMgrProxy.ApplyEfficiencyResources(*resourceInfo), ERR_INVALID_VALUE);
411 
412     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
413     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(false);
414     EXPECT_EQ(backgroundTaskMgrProxy.ApplyEfficiencyResources(*resourceInfo), ERR_INVALID_DATA);
415 
416     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(true);
417     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
418     EXPECT_EQ(backgroundTaskMgrProxy.ApplyEfficiencyResources(*resourceInfo), ERR_INVALID_DATA);
419 
420     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
421     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
422     EXPECT_EQ(backgroundTaskMgrProxy.ApplyEfficiencyResources(*resourceInfo), ERR_INVALID_DATA);
423 }
424 
425 /**
426  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_012
427  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
428  * @tc.type: FUNC
429  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
430  */
431 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_012, TestSize.Level1)
432 {
433     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
434 
435     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
436     EXPECT_EQ(backgroundTaskMgrProxy.ResetAllEfficiencyResources(), ERR_INVALID_VALUE);
437 
438     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
439     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
440     EXPECT_EQ(backgroundTaskMgrProxy.ResetAllEfficiencyResources(), ERR_INVALID_DATA);
441 
442     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
443     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
444     EXPECT_EQ(backgroundTaskMgrProxy.ResetAllEfficiencyResources(), ERR_INVALID_DATA);
445 }
446 
447 /**
448  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_013
449  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
450  * @tc.type: FUNC
451  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
452  */
453 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_013, TestSize.Level1)
454 {
455     std::vector<ResourceCallbackInfo> appList;
456     std::vector<ResourceCallbackInfo> procList;
457     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
458 
459     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
460     EXPECT_EQ(backgroundTaskMgrProxy.GetEfficiencyResourcesInfos(appList, procList), ERR_INVALID_VALUE);
461 
462     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
463     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
464     EXPECT_EQ(backgroundTaskMgrProxy.GetEfficiencyResourcesInfos(appList, procList), ERR_INVALID_DATA);
465 
466     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
467     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
468     EXPECT_EQ(backgroundTaskMgrProxy.GetEfficiencyResourcesInfos(appList, procList), ERR_INVALID_DATA);
469 
470     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(true);
471     EXPECT_EQ(backgroundTaskMgrProxy.GetEfficiencyResourcesInfos(appList, procList), ERR_INVALID_DATA);
472 }
473 
474 /**
475  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_014
476  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
477  * @tc.type: FUNC
478  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
479  */
480 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_014, TestSize.Level1)
481 {
482     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
483     EXPECT_EQ(backgroundTaskMgrProxy.RequestBackgroundRunningForInner(
484         *new ContinuousTaskParamForInner()), ERR_INVALID_DATA);
485 
486     sptr<ContinuousTaskParamForInner> taskParam = sptr<ContinuousTaskParamForInner>(new ContinuousTaskParamForInner());
487 
488     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
489     EXPECT_EQ(backgroundTaskMgrProxy.RequestBackgroundRunningForInner(*taskParam), ERR_INVALID_VALUE);
490 
491     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
492     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(false);
493     EXPECT_EQ(backgroundTaskMgrProxy.RequestBackgroundRunningForInner(*taskParam), ERR_INVALID_DATA);
494 
495     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(true);
496     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
497     EXPECT_EQ(backgroundTaskMgrProxy.RequestBackgroundRunningForInner(*taskParam), ERR_INVALID_DATA);
498 
499     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
500     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
501     EXPECT_EQ(backgroundTaskMgrProxy.RequestBackgroundRunningForInner(*taskParam), ERR_INVALID_DATA);
502 }
503 
504 /**
505  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_015
506  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
507  * @tc.type: FUNC
508  * @tc.require: issuesI936BL
509  */
510 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_015, TestSize.Level1)
511 {
512     int32_t uid = -1;
513     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
514 
515     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
516     EXPECT_NE(backgroundTaskMgrProxy.PauseTransientTaskTimeForInner(uid), 0);
517 
518     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
519     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
520     EXPECT_NE(backgroundTaskMgrProxy.PauseTransientTaskTimeForInner(uid), 0);
521 
522     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
523     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
524     EXPECT_NE(backgroundTaskMgrProxy.PauseTransientTaskTimeForInner(uid), 0);
525 
526     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
527     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
528     EXPECT_NE(backgroundTaskMgrProxy.PauseTransientTaskTimeForInner(uid), 0);
529 }
530 
531 /**
532  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_016
533  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
534  * @tc.type: FUNC
535  * @tc.require: issuesI936BL
536  */
537 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_016, TestSize.Level1)
538 {
539     int32_t uid = -1;
540     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
541 
542     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
543     EXPECT_NE(backgroundTaskMgrProxy.StartTransientTaskTimeForInner(uid), 0);
544 
545     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
546     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
547     EXPECT_NE(backgroundTaskMgrProxy.StartTransientTaskTimeForInner(uid), 0);
548 
549     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
550     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
551     EXPECT_NE(backgroundTaskMgrProxy.StartTransientTaskTimeForInner(uid), 0);
552 
553     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
554     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
555     EXPECT_NE(backgroundTaskMgrProxy.StartTransientTaskTimeForInner(uid), 0);
556 }
557 
558 /**
559  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_017
560  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
561  * @tc.type: FUNC
562  * @tc.require: issueIAULHW
563  */
564 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_017, TestSize.Level1)
565 {
566     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
567 
568     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
569     EXPECT_NE(backgroundTaskMgrProxy.SetBgTaskConfig("", 1), 0);
570 
571     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
572     MessageParcelHelper::BgTaskFwkAbnormalSetWriteStringFlag(false);
573     EXPECT_NE(backgroundTaskMgrProxy.SetBgTaskConfig("", 1), 0);
574 
575     MessageParcelHelper::BgTaskFwkAbnormalSetWriteStringFlag(true);
576     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
577     EXPECT_NE(backgroundTaskMgrProxy.SetBgTaskConfig("", 1), 0);
578 
579     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
580     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
581     EXPECT_NE(backgroundTaskMgrProxy.SetBgTaskConfig("", 1), 0);
582 
583     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
584     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
585     EXPECT_NE(backgroundTaskMgrProxy.SetBgTaskConfig("", 1), 0);
586 }
587 }
588 }
589