• 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;}
OnContinuousTaskSuspend(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)78     ErrCode OnContinuousTaskSuspend(
79         const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;}
OnContinuousTaskActive(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)80     ErrCode OnContinuousTaskActive(
81         const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;}
OnAppContinuousTaskStop(int32_t uid)82     ErrCode OnAppContinuousTaskStop(int32_t uid) override {return ERR_OK;}
OnAppEfficiencyResourcesApply(const ResourceCallbackInfo & resourceInfo)83     ErrCode OnAppEfficiencyResourcesApply(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;}
OnAppEfficiencyResourcesReset(const ResourceCallbackInfo & resourceInfo)84     ErrCode OnAppEfficiencyResourcesReset(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;}
OnProcEfficiencyResourcesApply(const ResourceCallbackInfo & resourceInfo)85     ErrCode OnProcEfficiencyResourcesApply(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;}
OnProcEfficiencyResourcesReset(const ResourceCallbackInfo & resourceInfo)86     ErrCode OnProcEfficiencyResourcesReset(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;}
GetFlag(int32_t & flag)87     ErrCode GetFlag(int32_t &flag) override {return ERR_OK;}
88 };
89 
90 class TestExpiredCallbackStub : public ExpiredCallbackStub {
91 public:
OnExpired()92     ErrCode OnExpired() override {return ERR_OK;}
93 };
94 
95 /**
96  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_001
97  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
98  * @tc.type: FUNC
99  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
100  */
101 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_001, TestSize.Level2)
102 {
103     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
104     DelaySuspendInfo delayInfo;
105     sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
106 
107     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", nullptr, delayInfo),
108         ERR_INVALID_DATA);
109 
110     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
111     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
112         ERR_INVALID_VALUE);
113 
114     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
115     MessageParcelHelper::BgTaskFwkAbnormalSetWriteString16Flag(false);
116     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
117         ERR_INVALID_DATA);
118 
119     MessageParcelHelper::BgTaskFwkAbnormalSetWriteString16Flag(true);
120     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(false);
121     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
122         ERR_INVALID_DATA);
123 
124     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(true);
125     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
126         ERR_INVALID_DATA);
127     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
128     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
129     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
130         ERR_INVALID_DATA);
131     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(true);
132     EXPECT_EQ(backgroundTaskMgrProxy.RequestSuspendDelay("reason", expiredCallbackStub, delayInfo),
133         ERR_INVALID_DATA);
134 }
135 
136 /**
137  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_002
138  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
139  * @tc.type: FUNC
140  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
141  */
142 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_002, TestSize.Level2)
143 {
144     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
145 
146     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
147     EXPECT_EQ(backgroundTaskMgrProxy.CancelSuspendDelay(1), ERR_INVALID_VALUE);
148 
149     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
150     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
151     EXPECT_EQ(backgroundTaskMgrProxy.CancelSuspendDelay(1), ERR_INVALID_DATA);
152 
153     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
154     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
155     EXPECT_EQ(backgroundTaskMgrProxy.CancelSuspendDelay(1), ERR_INVALID_DATA);
156 
157     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
158     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
159     EXPECT_EQ(backgroundTaskMgrProxy.CancelSuspendDelay(1), ERR_INVALID_DATA);
160 }
161 
162 /**
163  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_003
164  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
165  * @tc.type: FUNC
166  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
167  */
168 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_003, TestSize.Level2)
169 {
170     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
171     int32_t delayTime;
172 
173     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
174     EXPECT_EQ(backgroundTaskMgrProxy.GetRemainingDelayTime(1, delayTime), ERR_INVALID_VALUE);
175 
176     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
177     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
178     EXPECT_EQ(backgroundTaskMgrProxy.GetRemainingDelayTime(1, delayTime), ERR_INVALID_DATA);
179 
180     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
181     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
182     EXPECT_EQ(backgroundTaskMgrProxy.GetRemainingDelayTime(1, delayTime), ERR_INVALID_DATA);
183 
184     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
185     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
186     EXPECT_EQ(backgroundTaskMgrProxy.GetRemainingDelayTime(1, delayTime), ERR_INVALID_DATA);
187 }
188 
189 /**
190  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_004
191  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
192  * @tc.type: FUNC
193  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
194  */
195 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_004, TestSize.Level2)
196 {
197     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
198     int32_t notificationId = -1;
199     int32_t continuousTaskId = -1;
200     EXPECT_EQ(backgroundTaskMgrProxy.StartBackgroundRunning(
201         *new ContinuousTaskParam(), notificationId, continuousTaskId), ERR_INVALID_DATA);
202 
203     sptr<ContinuousTaskParam> taskParam(new ContinuousTaskParam());
204 
205     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
206     EXPECT_EQ(backgroundTaskMgrProxy.StartBackgroundRunning(
207         *taskParam, notificationId, continuousTaskId), ERR_INVALID_VALUE);
208 
209     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
210     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(false);
211     EXPECT_EQ(backgroundTaskMgrProxy.StartBackgroundRunning(
212         *taskParam, notificationId, continuousTaskId), ERR_INVALID_DATA);
213 
214     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(true);
215     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
216     EXPECT_EQ(backgroundTaskMgrProxy.StartBackgroundRunning(
217         *taskParam, notificationId, continuousTaskId), ERR_INVALID_DATA);
218 
219     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
220     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
221     EXPECT_EQ(backgroundTaskMgrProxy.StartBackgroundRunning(
222         *taskParam, notificationId, continuousTaskId), ERR_INVALID_DATA);
223 }
224 
225 /**
226  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_005
227  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
228  * @tc.type: FUNC
229  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V issueI99HSB
230  */
231 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_005, TestSize.Level2)
232 {
233     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
234 
235     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
236     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_VALUE);
237 
238     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
239     MessageParcelHelper::BgTaskFwkAbnormalSetWriteStringFlag(false);
240     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_DATA);
241 
242     MessageParcelHelper::BgTaskFwkAbnormalSetWriteStringFlag(true);
243     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(false);
244     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_DATA);
245 
246     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(true);
247     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
248     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_DATA);
249 
250     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
251     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
252     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_DATA);
253 
254     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
255     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
256     EXPECT_EQ(backgroundTaskMgrProxy.StopBackgroundRunning("abilityName", nullptr, -1), ERR_INVALID_DATA);
257 }
258 
259 /**
260  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_006
261  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
262  * @tc.type: FUNC
263  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
264  */
265 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_006, TestSize.Level2)
266 {
267     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
268     EXPECT_EQ(backgroundTaskMgrProxy.SubscribeBackgroundTask(nullptr, 0), ERR_INVALID_DATA);
269 
270     sptr<TestBackgroundTaskSubscriberStub> subscribe =
271         sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub());
272 
273     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
274     EXPECT_EQ(backgroundTaskMgrProxy.SubscribeBackgroundTask(subscribe, 0), ERR_INVALID_VALUE);
275 
276     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
277     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(false);
278     EXPECT_EQ(backgroundTaskMgrProxy.SubscribeBackgroundTask(subscribe, 0), ERR_INVALID_DATA);
279 
280     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(true);
281     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
282     EXPECT_EQ(backgroundTaskMgrProxy.SubscribeBackgroundTask(subscribe, 0), ERR_INVALID_DATA);
283 
284     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
285     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
286     EXPECT_EQ(backgroundTaskMgrProxy.SubscribeBackgroundTask(subscribe, 0), ERR_INVALID_DATA);
287 }
288 
289 /**
290  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_007
291  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
292  * @tc.type: FUNC
293  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
294  */
295 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_007, TestSize.Level2)
296 {
297     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
298     EXPECT_EQ(backgroundTaskMgrProxy.UnsubscribeBackgroundTask(nullptr), ERR_INVALID_DATA);
299 
300     sptr<TestBackgroundTaskSubscriberStub> subscribe =
301         sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub());
302 
303     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
304     EXPECT_EQ(backgroundTaskMgrProxy.UnsubscribeBackgroundTask(subscribe), ERR_INVALID_VALUE);
305 
306     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
307     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(false);
308     EXPECT_EQ(backgroundTaskMgrProxy.UnsubscribeBackgroundTask(subscribe), ERR_INVALID_DATA);
309 
310     MessageParcelHelper::BgTaskFwkAbnormalSetWriteRemoteObjectFlag(true);
311     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
312     EXPECT_EQ(backgroundTaskMgrProxy.UnsubscribeBackgroundTask(subscribe), ERR_INVALID_DATA);
313 
314     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
315     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
316     EXPECT_EQ(backgroundTaskMgrProxy.UnsubscribeBackgroundTask(subscribe), ERR_INVALID_DATA);
317 }
318 
319 /**
320  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_008
321  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
322  * @tc.type: FUNC
323  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
324  */
325 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_008, TestSize.Level2)
326 {
327     std::vector<TransientTaskAppInfo> list;
328     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
329 
330     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
331     EXPECT_EQ(backgroundTaskMgrProxy.GetTransientTaskApps(list), ERR_INVALID_VALUE);
332 
333     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
334     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
335     EXPECT_EQ(backgroundTaskMgrProxy.GetTransientTaskApps(list), ERR_INVALID_DATA);
336 
337     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
338     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
339     EXPECT_EQ(backgroundTaskMgrProxy.GetTransientTaskApps(list), ERR_INVALID_DATA);
340 
341     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(true);
342     EXPECT_EQ(backgroundTaskMgrProxy.GetTransientTaskApps(list), ERR_INVALID_DATA);
343 }
344 
345 /**
346  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_009
347  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
348  * @tc.type: FUNC
349  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
350  */
351 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_009, TestSize.Level2)
352 {
353     std::vector<ContinuousTaskCallbackInfo> list;
354     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
355 
356     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
357     EXPECT_EQ(backgroundTaskMgrProxy.GetContinuousTaskApps(list), ERR_INVALID_VALUE);
358 
359     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
360     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
361     EXPECT_EQ(backgroundTaskMgrProxy.GetContinuousTaskApps(list), ERR_INVALID_DATA);
362 
363     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
364     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
365     EXPECT_EQ(backgroundTaskMgrProxy.GetContinuousTaskApps(list), ERR_INVALID_DATA);
366 
367     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(true);
368     EXPECT_EQ(backgroundTaskMgrProxy.GetContinuousTaskApps(list), ERR_INVALID_DATA);
369 }
370 
371 /**
372  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_010
373  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
374  * @tc.type: FUNC
375  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
376  */
377 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_010, TestSize.Level2)
378 {
379     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
380 
381     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
382     EXPECT_EQ(backgroundTaskMgrProxy.StopContinuousTask(1, 1, 1, ""), ERR_INVALID_VALUE);
383 
384     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
385     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
386     EXPECT_EQ(backgroundTaskMgrProxy.StopContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
387 
388     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
389     MessageParcelHelper::BgTaskFwkAbnormalSetWriteUint32Flag(false);
390     EXPECT_EQ(backgroundTaskMgrProxy.StopContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
391 
392     MessageParcelHelper::BgTaskFwkAbnormalSetWriteUint32Flag(true);
393     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
394     EXPECT_EQ(backgroundTaskMgrProxy.StopContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
395 
396     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
397     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
398     EXPECT_EQ(backgroundTaskMgrProxy.StopContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
399 }
400 
401 /**
402  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_011
403  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
404  * @tc.type: FUNC
405  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
406  */
407 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_011, TestSize.Level2)
408 {
409     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
410     EXPECT_EQ(backgroundTaskMgrProxy.ApplyEfficiencyResources(*new EfficiencyResourceInfo()), ERR_INVALID_DATA);
411 
412     sptr<EfficiencyResourceInfo> resourceInfo = new (std::nothrow) EfficiencyResourceInfo();
413 
414     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
415     EXPECT_EQ(backgroundTaskMgrProxy.ApplyEfficiencyResources(*resourceInfo), ERR_INVALID_VALUE);
416 
417     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
418     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(false);
419     EXPECT_EQ(backgroundTaskMgrProxy.ApplyEfficiencyResources(*resourceInfo), ERR_INVALID_DATA);
420 
421     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(true);
422     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
423     EXPECT_EQ(backgroundTaskMgrProxy.ApplyEfficiencyResources(*resourceInfo), ERR_INVALID_DATA);
424 
425     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
426     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
427     EXPECT_EQ(backgroundTaskMgrProxy.ApplyEfficiencyResources(*resourceInfo), ERR_INVALID_DATA);
428 }
429 
430 /**
431  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_012
432  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
433  * @tc.type: FUNC
434  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
435  */
436 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_012, TestSize.Level2)
437 {
438     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
439 
440     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
441     EXPECT_EQ(backgroundTaskMgrProxy.ResetAllEfficiencyResources(), ERR_INVALID_VALUE);
442 
443     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
444     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
445     EXPECT_EQ(backgroundTaskMgrProxy.ResetAllEfficiencyResources(), ERR_INVALID_DATA);
446 
447     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
448     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
449     EXPECT_EQ(backgroundTaskMgrProxy.ResetAllEfficiencyResources(), ERR_INVALID_DATA);
450 }
451 
452 /**
453  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_013
454  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
455  * @tc.type: FUNC
456  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
457  */
458 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_013, TestSize.Level2)
459 {
460     std::vector<ResourceCallbackInfo> appList;
461     std::vector<ResourceCallbackInfo> procList;
462     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
463 
464     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
465     EXPECT_EQ(backgroundTaskMgrProxy.GetEfficiencyResourcesInfos(appList, procList), ERR_INVALID_VALUE);
466 
467     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
468     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
469     EXPECT_EQ(backgroundTaskMgrProxy.GetEfficiencyResourcesInfos(appList, procList), ERR_INVALID_DATA);
470 
471     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
472     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
473     EXPECT_EQ(backgroundTaskMgrProxy.GetEfficiencyResourcesInfos(appList, procList), ERR_INVALID_DATA);
474 
475     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(true);
476     EXPECT_EQ(backgroundTaskMgrProxy.GetEfficiencyResourcesInfos(appList, procList), ERR_INVALID_DATA);
477 }
478 
479 /**
480  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_014
481  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
482  * @tc.type: FUNC
483  * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V
484  */
485 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_014, TestSize.Level2)
486 {
487     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
488     EXPECT_EQ(backgroundTaskMgrProxy.RequestBackgroundRunningForInner(
489         *new ContinuousTaskParamForInner()), ERR_INVALID_DATA);
490 
491     sptr<ContinuousTaskParamForInner> taskParam = sptr<ContinuousTaskParamForInner>(new ContinuousTaskParamForInner());
492 
493     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
494     EXPECT_EQ(backgroundTaskMgrProxy.RequestBackgroundRunningForInner(*taskParam), ERR_INVALID_VALUE);
495 
496     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
497     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(false);
498     EXPECT_EQ(backgroundTaskMgrProxy.RequestBackgroundRunningForInner(*taskParam), ERR_INVALID_DATA);
499 
500     MessageParcelHelper::BgTaskFwkAbnormalSetWriteParcelableFlag(true);
501     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
502     EXPECT_EQ(backgroundTaskMgrProxy.RequestBackgroundRunningForInner(*taskParam), ERR_INVALID_DATA);
503 
504     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
505     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
506     EXPECT_EQ(backgroundTaskMgrProxy.RequestBackgroundRunningForInner(*taskParam), ERR_INVALID_DATA);
507 }
508 
509 /**
510  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_015
511  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
512  * @tc.type: FUNC
513  * @tc.require: issuesI936BL
514  */
515 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_015, TestSize.Level2)
516 {
517     int32_t uid = -1;
518     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
519 
520     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
521     EXPECT_NE(backgroundTaskMgrProxy.PauseTransientTaskTimeForInner(uid), 0);
522 
523     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
524     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
525     EXPECT_NE(backgroundTaskMgrProxy.PauseTransientTaskTimeForInner(uid), 0);
526 
527     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
528     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
529     EXPECT_NE(backgroundTaskMgrProxy.PauseTransientTaskTimeForInner(uid), 0);
530 
531     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
532     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
533     EXPECT_NE(backgroundTaskMgrProxy.PauseTransientTaskTimeForInner(uid), 0);
534 }
535 
536 /**
537  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_016
538  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
539  * @tc.type: FUNC
540  * @tc.require: issuesI936BL
541  */
542 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_016, TestSize.Level2)
543 {
544     int32_t uid = -1;
545     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
546 
547     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
548     EXPECT_NE(backgroundTaskMgrProxy.StartTransientTaskTimeForInner(uid), 0);
549 
550     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
551     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
552     EXPECT_NE(backgroundTaskMgrProxy.StartTransientTaskTimeForInner(uid), 0);
553 
554     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
555     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
556     EXPECT_NE(backgroundTaskMgrProxy.StartTransientTaskTimeForInner(uid), 0);
557 
558     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
559     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
560     EXPECT_NE(backgroundTaskMgrProxy.StartTransientTaskTimeForInner(uid), 0);
561 }
562 
563 /**
564  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_017
565  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
566  * @tc.type: FUNC
567  * @tc.require: issueIAULHW
568  */
569 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_017, TestSize.Level2)
570 {
571     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
572 
573     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
574     EXPECT_NE(backgroundTaskMgrProxy.SetBgTaskConfig("", 1), 0);
575 
576     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
577     MessageParcelHelper::BgTaskFwkAbnormalSetWriteStringFlag(false);
578     EXPECT_NE(backgroundTaskMgrProxy.SetBgTaskConfig("", 1), 0);
579 
580     MessageParcelHelper::BgTaskFwkAbnormalSetWriteStringFlag(true);
581     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
582     EXPECT_NE(backgroundTaskMgrProxy.SetBgTaskConfig("", 1), 0);
583 
584     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
585     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
586     EXPECT_NE(backgroundTaskMgrProxy.SetBgTaskConfig("", 1), 0);
587 
588     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
589     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
590     EXPECT_NE(backgroundTaskMgrProxy.SetBgTaskConfig("", 1), 0);
591 }
592 
593 /**
594  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_018
595  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
596  * @tc.type: FUNC
597  * @tc.require: issueIC6B53
598  */
599 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_018, TestSize.Level2)
600 {
601     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
602 
603     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
604     EXPECT_EQ(backgroundTaskMgrProxy.SuspendContinuousTask(1, 1, 1, ""), ERR_INVALID_VALUE);
605 
606     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
607     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
608     EXPECT_EQ(backgroundTaskMgrProxy.SuspendContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
609 
610     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
611     MessageParcelHelper::BgTaskFwkAbnormalSetWriteUint32Flag(false);
612     EXPECT_EQ(backgroundTaskMgrProxy.SuspendContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
613 
614     MessageParcelHelper::BgTaskFwkAbnormalSetWriteUint32Flag(true);
615     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
616     EXPECT_EQ(backgroundTaskMgrProxy.SuspendContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
617 
618     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
619     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
620     EXPECT_EQ(backgroundTaskMgrProxy.SuspendContinuousTask(1, 1, 1, ""), ERR_INVALID_DATA);
621 }
622 
623 /**
624  * @tc.name: BackgroundTaskMgrProxyAbnormalTest_019
625  * @tc.desc: test BackgroundTaskMgrProxy abnormal.
626  * @tc.type: FUNC
627  * @tc.require: issueIC6B53
628  */
629 HWTEST_F(BgTaskFrameworkAbnormalUnitTest, BackgroundTaskMgrProxyAbnormalTest_019, TestSize.Level2)
630 {
631     BackgroundTaskMgrProxy backgroundTaskMgrProxy = BackgroundTaskMgrProxy(nullptr);
632 
633     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(false);
634     EXPECT_EQ(backgroundTaskMgrProxy.ActiveContinuousTask(1, 1, ""), ERR_INVALID_VALUE);
635 
636     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInterfaceTokenFlag(true);
637     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(false);
638     EXPECT_EQ(backgroundTaskMgrProxy.ActiveContinuousTask(1, 1, ""), ERR_INVALID_DATA);
639 
640     MessageParcelHelper::BgTaskFwkAbnormalSetWriteInt32WithParamFlag(true);
641     MessageParcelHelper::BgTaskFwkAbnormalSetWriteUint32Flag(false);
642     EXPECT_EQ(backgroundTaskMgrProxy.ActiveContinuousTask(1, 1, ""), ERR_INVALID_DATA);
643 
644     MessageParcelHelper::BgTaskFwkAbnormalSetWriteUint32Flag(true);
645     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(0);
646     EXPECT_EQ(backgroundTaskMgrProxy.ActiveContinuousTask(1, 1, ""), ERR_INVALID_DATA);
647 
648     BgTaskMgrProxyHelper::BgTaskFwkAbnormalSetBgTaskMgrProxyInnerTransactFlag(1);
649     MessageParcelHelper::BgTaskFwkAbnormalSetWriteReadInt32WithParamFlag(false);
650     EXPECT_EQ(backgroundTaskMgrProxy.ActiveContinuousTask(1, 1, ""), ERR_INVALID_DATA);
651 }
652 }
653 }
654