1 /*
2 * Copyright (c) 2025-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 #include <gtest/gtest.h>
16
17 #define private public
18 #include "suspend_manager_base_observer.h"
19 #include "suspend_manager_base_client.h"
20 #include "suspend_state_observer_base_stub.h"
21 #include "suspend_state_observer_base_proxy.h"
22 #include "accesstoken_kit.h"
23 #include "token_setproc.h"
24 #include "singleton.h"
25 #include "res_sched_service.h"
26 #include "suspend_manager_base_log.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace ResourceSchedule {
33 namespace {
34 static const std::string FOUNDATION_NAME = "foundation";
35 }
36
37 class SuspendStateObserverBaseStubTestObj : public SuspendStateObserverBaseStub {
38 public:
39 std::vector<int32_t> pidList_;
40 int32_t uid_;
41 States state_ = States::ACTIVE_STATE;
42 public:
OnActive(const std::vector<int32_t> & pidList,int32_t uid)43 ErrCode OnActive(const std::vector<int32_t> &pidList, int32_t uid)
44 {
45 SUSPEND_MANAGER_LOGI("SuspendStateObserverBaseStubTestObj register OnActive");
46 pidList_ = pidList;
47 uid_ = uid;
48 state_ = States::ACTIVE_STATE;
49 return ERR_OK;
50 }
OnDoze(const std::vector<int32_t> & pidList,int32_t uid)51 ErrCode OnDoze(const std::vector<int32_t> &pidList, int32_t uid)
52 {
53 SUSPEND_MANAGER_LOGI("SuspendStateObserverBaseStubTestObj register OnDoze");
54 pidList_ = pidList;
55 uid_ = uid;
56 state_ = States::DOZE_STATE;
57 return ERR_OK;
58 }
OnFrozen(const std::vector<int32_t> & pidList,int32_t uid)59 ErrCode OnFrozen(const std::vector<int32_t> &pidList, int32_t uid)
60 {
61 SUSPEND_MANAGER_LOGI("SuspendStateObserverBaseStubTestObj register OnFrozen");
62 pidList_ = pidList;
63 uid_ = uid;
64 state_ = States::FROZEN_STATE;
65 return ERR_OK;
66 }
67 };
68
69 class SuspendStateObserverTest : public testing::Test {
70 public:
SetUpTestCase()71 static void SetUpTestCase() {}
TearDownTestCase()72 static void TearDownTestCase() {}
73 void SetUp();
74 void TearDown();
75 };
76
SetUp()77 void SuspendStateObserverTest::SetUp()
78 {}
79
TearDown()80 void SuspendStateObserverTest::TearDown()
81 {}
82
GetNativeToken(const std::string & name)83 void GetNativeToken(const std::string &name)
84 {
85 auto tokenId = Security::AccessToken::AccessTokenKit::GetNativeTokenId(name);
86 EXPECT_EQ(0, SetSelfTokenID(tokenId));
87 }
88
89 /**
90 * @tc.name: RegisterSuspendObserverTest_001
91 * @tc.desc: client侧注册去注册全流程实现.
92 * @tc.type: FUNC
93 * @tc.require: ICQKUB
94 */
95 HWTEST_F(SuspendStateObserverTest, RegisterSuspendObserverTest_001, TestSize.Level1)
96 {
97 auto selfTokenId = GetSelfTokenID();
98 GetNativeToken(FOUNDATION_NAME);
99 /* 构造一个观察者对象 */
100 sptr<SuspendStateObserverBaseStub> suspendObservers_;
101 /* 注册空对象，失败 */
102 SuspendManagerBaseClient::GetInstance().RegisterSuspendObserver(suspendObservers_);
103 suspendObservers_ = sptr<SuspendStateObserverBaseStub>(new SuspendStateObserverBaseStubTestObj());
104 EXPECT_NE(suspendObservers_, nullptr);
105 /* 注册该对象，成功 */
106 SuspendManagerBaseClient::GetInstance().RegisterSuspendObserver(suspendObservers_);
107 /* 再次注册该对象，失败 */
108 SuspendManagerBaseClient::GetInstance().RegisterSuspendObserver(suspendObservers_);
109 /* 去注册空对象，失败 */
110 SuspendManagerBaseClient::GetInstance().UnregisterSuspendObserver(nullptr);
111 /* 去注册该对象，成功 */
112 SuspendManagerBaseClient::GetInstance().UnregisterSuspendObserver(suspendObservers_);
113 /* 再次去注册该对象，失败 */
114 SuspendManagerBaseClient::GetInstance().UnregisterSuspendObserver(suspendObservers_);
115
116 EXPECT_EQ(0, SetSelfTokenID(selfTokenId));
117 }
118
119 /**
120 * @tc.name: RegisterSuspendObserverTest_002
121 * @tc.desc: service中序列化反序列化全流程实现.
122 * @tc.type: FUNC
123 * @tc.require: ICQKUB
124 */
125 HWTEST_F(SuspendStateObserverTest, RegisterSuspendObserverTest_002, TestSize.Level1)
126 {
127 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers_ =
128 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
129 EXPECT_NE(suspendObservers_, nullptr);
130
131 auto suspendManagerService_ = DelayedSingleton<ResSchedService>::GetInstance();
132 EXPECT_NE(suspendManagerService_, nullptr);
133
134 MessageParcel data;
135 ASSERT_TRUE(data.WriteInterfaceToken(ResSchedService::GetDescriptor()));
136 ASSERT_TRUE(data.WriteRemoteObject(suspendObservers_->AsObject()));
137 MessageParcel reply;
138 MessageOption option;
139 uint32_t code = static_cast<uint32_t>(IResSchedServiceIpcCode::COMMAND_REGISTER_SUSPEND_OBSERVER);
140 ErrCode ret = suspendManagerService_->OnRemoteRequest(code, data, reply, option);
141 EXPECT_EQ(ret, ERR_OK);
142
143 ASSERT_TRUE(data.WriteInterfaceToken(ResSchedService::GetDescriptor()));
144 ASSERT_TRUE(data.WriteRemoteObject(suspendObservers_->AsObject()));
145 code = static_cast<uint32_t>(IResSchedServiceIpcCode::COMMAND_UNREGISTER_SUSPEND_OBSERVER);
146 ret = suspendManagerService_->OnRemoteRequest(code, data, reply, option);
147 EXPECT_EQ(ret, ERR_OK);
148 }
149
150 /**
151 * @tc.name: RegisterSuspendObserverTest_003
152 * @tc.desc: implement中注册去注册边界实现.
153 * @tc.type: FUNC
154 * @tc.require: ICQKUB
155 */
156 HWTEST_F(SuspendStateObserverTest, RegisterSuspendObserverTest_003, TestSize.Level1)
157 {
158 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers_ =
159 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
160 EXPECT_NE(suspendObservers_, nullptr);
161
162 int32_t ret = SuspendManagerBaseObserver::GetInstance().RegisterSuspendObserverInner(nullptr);
163 EXPECT_EQ(ret, ERR_INVALID_VALUE);
164
165 ret = SuspendManagerBaseObserver::GetInstance().UnregisterSuspendObserverInner(nullptr);
166 EXPECT_EQ(ret, ERR_INVALID_VALUE);
167
168 ret = SuspendManagerBaseObserver::GetInstance().UnregisterSuspendObserverInner(suspendObservers_);
169 EXPECT_EQ(ret, ERR_OK);
170 }
171
172 /**
173 * @tc.name: RegisterSuspendObserverTest_004
174 * @tc.desc: implement中注册去注册边界实现.
175 * @tc.type: FUNC
176 * @tc.require: ICQKUB
177 */
178 HWTEST_F(SuspendStateObserverTest, RegisterSuspendObserverTest_004, TestSize.Level1)
179 {
180 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers_ =
181 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
182 EXPECT_NE(suspendObservers_, nullptr);
183
184 int32_t ret = SuspendManagerBaseObserver::GetInstance().RegisterSuspendObserverInner(nullptr);
185 EXPECT_EQ(ret, ERR_INVALID_VALUE);
186
187 ret = SuspendManagerBaseObserver::GetInstance().UnregisterSuspendObserverInner(nullptr);
188 EXPECT_EQ(ret, ERR_INVALID_VALUE);
189 }
190
191 /**
192 * @tc.name: UpdateSuspendObserverTest_001
193 * @tc.desc: 正常注册，观察者状态变化.
194 * @tc.type: FUNC
195 * @tc.require: ICQKUB
196 */
197 HWTEST_F(SuspendStateObserverTest, UpdateSuspendObserverTest_001, TestSize.Level1)
198 {
199 /* 构造一个观察者对象 */
200 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers_ =
201 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
202 EXPECT_NE(suspendObservers_, nullptr);
203
204 /* 注册观察者对象 */
205 int32_t ret = SuspendManagerBaseObserver::GetInstance().RegisterSuspendObserverInner(suspendObservers_);
206 EXPECT_EQ(ret, ERR_OK);
207
208 /* 校验观察者初始值 */
209 EXPECT_EQ(suspendObservers_->state_, States::ACTIVE_STATE);
210 EXPECT_EQ(suspendObservers_->uid_, 0);
211 EXPECT_TRUE(suspendObservers_->pidList_.empty());
212
213 /* 通知观察者frozen信息 */
214 States state = States::FROZEN_STATE;
215 int32_t uid = 100;
216 std::vector<int32_t> pidList = {10, 20, 30};
217 ret = SuspendManagerBaseObserver::GetInstance().UpdateSuspendObserver(state, uid, pidList);
218 EXPECT_EQ(ret, ERR_OK);
219 EXPECT_EQ(suspendObservers_->state_, state);
220 EXPECT_EQ(suspendObservers_->uid_, uid);
221 EXPECT_EQ(suspendObservers_->pidList_, pidList);
222
223 /* 通知观察者active信息 */
224 state = States::ACTIVE_STATE;
225 uid = 200;
226 pidList = {40, 50, 60};
227 ret = SuspendManagerBaseObserver::GetInstance().UpdateSuspendObserver(state, uid, pidList);
228 EXPECT_EQ(ret, ERR_OK);
229 EXPECT_EQ(suspendObservers_->state_, state);
230 EXPECT_EQ(suspendObservers_->uid_, uid);
231 EXPECT_EQ(suspendObservers_->pidList_, pidList);
232
233 /* 通知观察者doze信息 */
234 state = States::DOZE_STATE;
235 uid = 300;
236 pidList = {70, 80, 90};
237 ret = SuspendManagerBaseObserver::GetInstance().UpdateSuspendObserver(state, uid, pidList);
238 EXPECT_EQ(ret, ERR_OK);
239 EXPECT_EQ(suspendObservers_->state_, state);
240 EXPECT_EQ(suspendObservers_->uid_, uid);
241 EXPECT_EQ(suspendObservers_->pidList_, pidList);
242
243 /* 去注册观察者对象 */
244 ret = SuspendManagerBaseObserver::GetInstance().UnregisterSuspendObserverInner(suspendObservers_);
245 EXPECT_EQ(ret, ERR_OK);
246
247 /* 通知观察者frozen信息 */
248 state = States::FROZEN_STATE;
249 uid = 100;
250 pidList = {10, 20, 30};
251 ret = SuspendManagerBaseObserver::GetInstance().UpdateSuspendObserver(state, uid, pidList);
252 EXPECT_EQ(ret, ERR_OK);
253
254 /* 观察者信息不再变化 */
255 EXPECT_NE(suspendObservers_->state_, state);
256 EXPECT_NE(suspendObservers_->uid_, uid);
257 EXPECT_NE(suspendObservers_->pidList_, pidList);
258 }
259
260 /**
261 * @tc.name: UpdateSuspendObserverTest_002
262 * @tc.desc: 未注册场景观察者状态变化.
263 * @tc.type: FUNC
264 * @tc.require: ICQKUB
265 */
266 HWTEST_F(SuspendStateObserverTest, UpdateSuspendObserverTest_002, TestSize.Level1)
267 {
268 /* 构造一个观察者对象 */
269 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers_ =
270 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
271 EXPECT_NE(suspendObservers_, nullptr);
272
273 /* 注册空的观察者对象 */
274 int32_t ret = SuspendManagerBaseObserver::GetInstance().RegisterSuspendObserverInner(nullptr);
275 EXPECT_EQ(ret, ERR_INVALID_VALUE);
276
277 /* 校验观察者初始值 */
278 EXPECT_EQ(suspendObservers_->state_, States::ACTIVE_STATE);
279 EXPECT_EQ(suspendObservers_->uid_, 0);
280 EXPECT_TRUE(suspendObservers_->pidList_.empty());
281
282 /* 通知观察者frozen信息 */
283 States state = States::FROZEN_STATE;
284 int32_t uid = 100;
285 std::vector<int32_t> pidList = {10, 20, 30};
286 ret = SuspendManagerBaseObserver::GetInstance().UpdateSuspendObserver(state, uid, pidList);
287 EXPECT_EQ(ret, ERR_OK);
288 /* 观察者信息无变化 */
289 EXPECT_EQ(suspendObservers_->state_, States::ACTIVE_STATE);
290 EXPECT_EQ(suspendObservers_->uid_, 0);
291 EXPECT_TRUE(suspendObservers_->pidList_.empty());
292 }
293
294 /**
295 * @tc.name: UpdateSuspendObserverTest_003
296 * @tc.desc: 动态注册场景观察者状态变化.
297 * @tc.type: FUNC
298 * @tc.require: ICQKUB
299 */
300 HWTEST_F(SuspendStateObserverTest, UpdateSuspendObserverTest_003, TestSize.Level1)
301 {
302 /* 构造两个观察者对象 */
303 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers1_ =
304 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
305 EXPECT_NE(suspendObservers1_, nullptr);
306 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers2_ =
307 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
308 EXPECT_NE(suspendObservers2_, nullptr);
309
310 /* 注册一个观察者对象 */
311 int32_t ret = SuspendManagerBaseObserver::GetInstance().RegisterSuspendObserverInner(suspendObservers1_);
312 EXPECT_EQ(ret, ERR_OK);
313
314 /* 校验观察者初始值 */
315 EXPECT_EQ(suspendObservers1_->state_, States::ACTIVE_STATE);
316 EXPECT_EQ(suspendObservers1_->uid_, 0);
317 EXPECT_TRUE(suspendObservers1_->pidList_.empty());
318 EXPECT_EQ(suspendObservers2_->state_, States::ACTIVE_STATE);
319 EXPECT_EQ(suspendObservers2_->uid_, 0);
320 EXPECT_TRUE(suspendObservers2_->pidList_.empty());
321
322 /* 通知观察者frozen1信息 */
323 States stateFrozen1 = States::FROZEN_STATE;
324 int32_t uidFrozen1 = 100;
325 std::vector<int32_t> pidListFrozen1 = {10, 20, 30};
326 ret = SuspendManagerBaseObserver::GetInstance().UpdateSuspendObserver(stateFrozen1, uidFrozen1, pidListFrozen1);
327 EXPECT_EQ(ret, ERR_OK);
328 /* 注册观察者信息变化 */
329 EXPECT_EQ(suspendObservers1_->state_, stateFrozen1);
330 EXPECT_EQ(suspendObservers1_->uid_, uidFrozen1);
331 EXPECT_EQ(suspendObservers1_->pidList_, pidListFrozen1);
332 /* 未注册观察者信息无变化 */
333 EXPECT_EQ(suspendObservers2_->state_, States::ACTIVE_STATE);
334 EXPECT_EQ(suspendObservers2_->uid_, 0);
335 EXPECT_TRUE(suspendObservers2_->pidList_.empty());
336
337 /* 注册第二个观察者对象 */
338 ret = SuspendManagerBaseObserver::GetInstance().RegisterSuspendObserverInner(suspendObservers2_);
339 EXPECT_EQ(ret, ERR_OK);
340
341 /* 通知观察者frozen2信息 */
342 States stateFrozen2 = States::FROZEN_STATE;
343 int32_t uidFrozen2 = 200;
344 std::vector<int32_t> pidListFrozen2 = {10, 20, 30};
345 ret = SuspendManagerBaseObserver::GetInstance().UpdateSuspendObserver(stateFrozen2, uidFrozen2, pidListFrozen2);
346 EXPECT_EQ(ret, ERR_OK);
347 /* 注册观察者信息变化 */
348 EXPECT_EQ(suspendObservers1_->state_, stateFrozen2);
349 EXPECT_EQ(suspendObservers1_->uid_, uidFrozen2);
350 EXPECT_EQ(suspendObservers1_->pidList_, pidListFrozen2);
351 EXPECT_EQ(suspendObservers2_->state_, stateFrozen2);
352 EXPECT_EQ(suspendObservers2_->uid_, uidFrozen2);
353 EXPECT_EQ(suspendObservers2_->pidList_, pidListFrozen2);
354
355 /* 去注册两个观察者对象 */
356 ret = SuspendManagerBaseObserver::GetInstance().UnregisterSuspendObserverInner(suspendObservers1_);
357 EXPECT_EQ(ret, ERR_OK);
358 ret = SuspendManagerBaseObserver::GetInstance().UnregisterSuspendObserverInner(suspendObservers2_);
359 EXPECT_EQ(ret, ERR_OK);
360 }
361
362 /**
363 * @tc.name: UpdateSuspendObserverTest_004
364 * @tc.desc: 动态去注册场景观察者状态变化.
365 * @tc.type: FUNC
366 * @tc.require: ICQKUB
367 */
368 HWTEST_F(SuspendStateObserverTest, UpdateSuspendObserverTest_004, TestSize.Level1)
369 {
370 /* 构造两个观察者对象 */
371 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers1_ =
372 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
373 EXPECT_NE(suspendObservers1_, nullptr);
374 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers2_ =
375 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
376 EXPECT_NE(suspendObservers2_, nullptr);
377
378 /* 注册两个观察者对象 */
379 int32_t ret = SuspendManagerBaseObserver::GetInstance().RegisterSuspendObserverInner(suspendObservers1_);
380 EXPECT_EQ(ret, ERR_OK);
381 ret = SuspendManagerBaseObserver::GetInstance().RegisterSuspendObserverInner(suspendObservers2_);
382 EXPECT_EQ(ret, ERR_OK);
383
384 /* 通知观察者frozen1信息 */
385 States stateFrozen1 = States::FROZEN_STATE;
386 int32_t uidFrozen1 = 100;
387 std::vector<int32_t> pidListFrozen1 = {10, 20, 30};
388 ret = SuspendManagerBaseObserver::GetInstance().UpdateSuspendObserver(stateFrozen1, uidFrozen1, pidListFrozen1);
389
390 /* 去注册第一个观察者对象 */
391 ret = SuspendManagerBaseObserver::GetInstance().UnregisterSuspendObserverInner(suspendObservers1_);
392 EXPECT_EQ(ret, ERR_OK);
393
394 /* 通知观察者active信息 */
395 States stateActive = States::ACTIVE_STATE;
396 int32_t uidActive = 300;
397 std::vector<int32_t> pidListActive = {40, 50, 60};
398 ret = SuspendManagerBaseObserver::GetInstance().UpdateSuspendObserver(stateActive, uidActive, pidListActive);
399 EXPECT_EQ(ret, ERR_OK);
400
401 /* 未注册观察者信息无变化 */
402 EXPECT_EQ(suspendObservers1_->state_, stateFrozen1);
403 EXPECT_EQ(suspendObservers1_->uid_, uidFrozen1);
404 EXPECT_EQ(suspendObservers1_->pidList_, pidListFrozen1);
405 /* 注册观察者信息变化 */
406 EXPECT_EQ(suspendObservers2_->state_, stateActive);
407 EXPECT_EQ(suspendObservers2_->uid_, uidActive);
408 EXPECT_EQ(suspendObservers2_->pidList_, pidListActive);
409
410 /* 去注册第二个观察者对象 */
411 ret = SuspendManagerBaseObserver::GetInstance().UnregisterSuspendObserverInner(suspendObservers2_);
412 EXPECT_EQ(ret, ERR_OK);
413
414 /* 全去注册后再通知观察者doze信息 */
415 States stateDoze = States::DOZE_STATE;
416 int32_t uidDoze = 400;
417 std::vector<int32_t> pidListDoze = {70, 80, 90};
418 ret = SuspendManagerBaseObserver::GetInstance().UpdateSuspendObserver(stateDoze, uidDoze, pidListDoze);
419 EXPECT_EQ(ret, ERR_OK);
420 /* 未注册观察者信息无变化 */
421 EXPECT_EQ(suspendObservers1_->state_, stateFrozen1);
422 EXPECT_EQ(suspendObservers1_->uid_, uidFrozen1);
423 EXPECT_EQ(suspendObservers1_->pidList_, pidListFrozen1);
424 EXPECT_EQ(suspendObservers2_->state_, stateActive);
425 EXPECT_EQ(suspendObservers2_->uid_, uidActive);
426 EXPECT_EQ(suspendObservers2_->pidList_, pidListActive);
427
428 /* 已完全去注册，无法继续去注册 */
429 ret = SuspendManagerBaseObserver::GetInstance().UnregisterSuspendObserverInner(suspendObservers1_);
430 EXPECT_EQ(ret, ERR_OK);
431 ret = SuspendManagerBaseObserver::GetInstance().UnregisterSuspendObserverInner(suspendObservers2_);
432 EXPECT_EQ(ret, ERR_OK);
433 }
434
435 /**
436 * @tc.name: UpdateSuspendObserverTest_005
437 * @tc.desc: 正常注册，观察者状态变化.
438 * @tc.type: FUNC
439 * @tc.require: ICQKUB
440 */
441 HWTEST_F(SuspendStateObserverTest, UpdateSuspendObserverTest_005, TestSize.Level1)
442 {
443 /* 构造一个观察者对象 */
444 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers_ =
445 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
446 EXPECT_NE(suspendObservers_, nullptr);
447
448 /* 注册观察者对象 */
449 int32_t ret = SuspendManagerBaseObserver::GetInstance().RegisterSuspendObserverInner(suspendObservers_);
450 EXPECT_EQ(ret, ERR_OK);
451
452 /* 校验观察者初始值 */
453 EXPECT_EQ(suspendObservers_->state_, States::ACTIVE_STATE);
454 EXPECT_EQ(suspendObservers_->uid_, 0);
455 EXPECT_TRUE(suspendObservers_->pidList_.empty());
456
457 /* 通知观察者frozen信息 */
458 States state = static_cast<States>(5);
459 int32_t uid = 100;
460 std::vector<int32_t> pidList = {10, 20, 30};
461 ret = SuspendManagerBaseObserver::GetInstance().UpdateSuspendObserver(state, uid, pidList);
462 EXPECT_EQ(ret, ERR_INVALID_VALUE);
463 EXPECT_EQ(suspendObservers_->state_, States::ACTIVE_STATE);
464 EXPECT_EQ(suspendObservers_->uid_, 0);
465 EXPECT_TRUE(suspendObservers_->pidList_.empty());
466 }
467
468 /**
469 * @tc.name: SuspendStateObserverBaseStubTest_001
470 * @tc.desc: SuspendStateObserverBaseStub状态变化，测试active消息解析.
471 * @tc.type: FUNC
472 * @tc.require: ICQKUB
473 */
474 HWTEST_F(SuspendStateObserverTest, SuspendStateObserverBaseStubTest_001, TestSize.Level1)
475 {
476 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers_ =
477 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
478 EXPECT_NE(suspendObservers_, nullptr);
479 sptr<SuspendStateObserverBaseProxy> proxy = new SuspendStateObserverBaseProxy(suspendObservers_);
480 EXPECT_NE(proxy, nullptr);
481 int32_t uid = 100;
482 std::vector<int32_t> pidList = {10, 20, 30};
483 MessageParcel data;
484 const uint32_t message = static_cast<uint32_t>(ISuspendStateObserverBaseIpcCode::COMMAND_ON_ACTIVE);
485 MessageParcel reply;
486 MessageOption option(MessageOption::TF_ASYNC);
487 /* 非法data解析失败 */
488 ErrCode ret = suspendObservers_->OnRemoteRequest(message, data, reply, option);
489 EXPECT_NE(ret, ERR_OK);
490 /* 合法data解析成功 */
491 proxy->OnActive(pidList, uid);
492 EXPECT_EQ(suspendObservers_->state_, States::ACTIVE_STATE);
493 EXPECT_EQ(suspendObservers_->uid_, uid);
494 EXPECT_EQ(suspendObservers_->pidList_, pidList);
495 }
496
497 /**
498 * @tc.name: SuspendStateObserverBaseStubTest_002
499 * @tc.desc: SuspendStateObserverBaseStub状态变化，测试Frozen消息解析.
500 * @tc.type: FUNC
501 * @tc.require: ICQKUB
502 */
503 HWTEST_F(SuspendStateObserverTest, SuspendStateObserverBaseStubTest_002, TestSize.Level1)
504 {
505 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers_ =
506 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
507 EXPECT_NE(suspendObservers_, nullptr);
508 sptr<SuspendStateObserverBaseProxy> proxy = new SuspendStateObserverBaseProxy(suspendObservers_);
509 EXPECT_NE(proxy, nullptr);
510 int32_t uid = 100;
511 std::vector<int32_t> pidList = {10, 20, 30};
512 MessageParcel data;
513 MessageParcel reply;
514 MessageOption option(MessageOption::TF_ASYNC);
515 const uint32_t message = static_cast<uint32_t>(ISuspendStateObserverBaseIpcCode::COMMAND_ON_FROZEN);
516 /* 非法data解析失败 */
517 ErrCode ret = suspendObservers_->OnRemoteRequest(message, data, reply, option);
518 EXPECT_NE(ret, ERR_OK);
519 proxy->OnFrozen(pidList, uid);
520 /* 合法data解析成功 */
521 EXPECT_EQ(suspendObservers_->state_, States::FROZEN_STATE);
522 EXPECT_EQ(suspendObservers_->uid_, uid);
523 EXPECT_EQ(suspendObservers_->pidList_, pidList);
524 }
525
526 /**
527 * @tc.name: SuspendStateObserverBaseStubTest_003
528 * @tc.desc: SuspendStateObserverBaseStub状态变化，测试Doze消息解析.
529 * @tc.type: FUNC
530 * @tc.require: ICQKUB
531 */
532 HWTEST_F(SuspendStateObserverTest, SuspendStateObserverBaseStubTest_003, TestSize.Level1)
533 {
534 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers_ =
535 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
536 EXPECT_NE(suspendObservers_, nullptr);
537 sptr<SuspendStateObserverBaseProxy> proxy = new SuspendStateObserverBaseProxy(suspendObservers_);
538 EXPECT_NE(proxy, nullptr);
539 int32_t uid = 100;
540 std::vector<int32_t> pidList = {10, 20, 30};
541 MessageParcel data;
542 const uint32_t message = static_cast<uint32_t>(ISuspendStateObserverBaseIpcCode::COMMAND_ON_DOZE);
543 MessageParcel reply;
544 MessageOption option(MessageOption::TF_ASYNC);
545 /* 非法data解析失败 */
546 ErrCode ret = suspendObservers_->OnRemoteRequest(message, data, reply, option);
547 EXPECT_NE(ret, ERR_OK);
548 proxy->OnDoze(pidList, uid);
549 /* 合法data解析成功 */
550 EXPECT_EQ(suspendObservers_->state_, States::DOZE_STATE);
551 EXPECT_EQ(suspendObservers_->uid_, uid);
552 EXPECT_EQ(suspendObservers_->pidList_, pidList);
553 }
554
555 /**
556 * @tc.name: SuspendStateObserverBaseStubTest_004
557 * @tc.desc: test SuspendStateObserverBaseStub.
558 * @tc.type: FUNC
559 * @tc.require: ICQKUB
560 */
561 HWTEST_F(SuspendStateObserverTest, SuspendStateObserverBaseStubTest_004, TestSize.Level1)
562 {
563 sptr<SuspendStateObserverBaseStubTestObj> suspendObservers_ =
564 sptr<SuspendStateObserverBaseStubTestObj>(new SuspendStateObserverBaseStubTestObj());
565 EXPECT_NE(suspendObservers_, nullptr);
566 int32_t uid = 100;
567 MessageParcel data;
568 const uint32_t message = static_cast<uint32_t>(ISuspendStateObserverBaseIpcCode::COMMAND_ON_FROZEN);
569 MessageParcel reply;
570 MessageOption option(MessageOption::TF_ASYNC);
571 /* 非法data解析失败 */
572 ErrCode ret = suspendObservers_->OnRemoteRequest(message, data, reply, option);
573 EXPECT_NE(ret, ERR_OK);
574
575 /* 空方法接口覆盖 */
576 std::vector<int32_t> pidList = {10, 20, 30};
577 suspendObservers_->OnActive(pidList, uid);
578 suspendObservers_->OnDoze(pidList, uid);
579 suspendObservers_->OnFrozen(pidList, uid);
580 }
581 } // namespace ResourceSchedule
582 } // namespace OHOS