1 /*
2 * Copyright (c) 2023 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 <functional>
16 #include <chrono>
17 #include <thread>
18 #include <message_parcel.h>
19
20 #include "gtest/gtest.h"
21 #include "singleton.h"
22
23 #include "allow_type.h"
24 #include "istandby_service.h"
25 #include "resourcce_request.h"
26 #include "standby_ipc_interface_code.h"
27 #include "standby_service_client.h"
28 #include "standby_service_proxy.h"
29 #include "standby_service_subscriber_stub.h"
30 #include "standby_service_subscriber_proxy.h"
31
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace DevStandbyMgr {
36 class StandbyServiceClientUnitTest : public testing::Test {
37 public:
SetUpTestCase()38 static void SetUpTestCase() {}
TearDownTestCase()39 static void TearDownTestCase() {}
40 void SetUp() override {}
41 void TearDown() override {}
42 };
43
44 /**
45 * @tc.name: StandbyServiceClientUnitTest_001
46 * @tc.desc: test SubscribeStandbyCallback.
47 * @tc.type: FUNC
48 * @tc.require:
49 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_001, TestSize.Level1)50 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_001, TestSize.Level1)
51 {
52 sptr<IStandbyServiceSubscriber> nullSubscriber = nullptr;
53 EXPECT_NE(StandbyServiceClient::GetInstance().SubscribeStandbyCallback(nullSubscriber), ERR_OK);
54 EXPECT_NE(StandbyServiceClient::GetInstance().SubscribeStandbyCallback(nullSubscriber), ERR_OK);
55 StandbyServiceClient::GetInstance().UnsubscribeStandbyCallback(nullSubscriber);
56 sptr<IStandbyServiceSubscriber> subscriber = new (std::nothrow) StandbyServiceSubscriberStub();
57 EXPECT_NE(StandbyServiceClient::GetInstance().SubscribeStandbyCallback(subscriber), ERR_OK);
58 StandbyServiceClient::GetInstance().SubscribeStandbyCallback(subscriber);
59 EXPECT_NE(StandbyServiceClient::GetInstance().UnsubscribeStandbyCallback(subscriber), ERR_OK);
60 EXPECT_NE(StandbyServiceClient::GetInstance().UnsubscribeStandbyCallback(subscriber), ERR_OK);
61 }
62
63 /**
64 * @tc.name: StandbyServiceClientUnitTest_002
65 * @tc.desc: test ApplyAllowResource.
66 * @tc.type: FUNC
67 * @tc.require:
68 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_002, TestSize.Level1)69 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_002, TestSize.Level1)
70 {
71 sptr<ResourceRequest> nullRequest = nullptr;
72 EXPECT_NE(StandbyServiceClient::GetInstance().ApplyAllowResource(nullRequest), ERR_OK);
73 EXPECT_NE(StandbyServiceClient::GetInstance().UnapplyAllowResource(nullRequest), ERR_OK);
74
75 sptr<ResourceRequest> resouarceRequest = new (std::nothrow) ResourceRequest();
76 EXPECT_NE(StandbyServiceClient::GetInstance().ApplyAllowResource(resouarceRequest), ERR_OK);
77 EXPECT_NE(StandbyServiceClient::GetInstance().UnapplyAllowResource(resouarceRequest), ERR_OK);
78
79 sptr<ResourceRequest> validResRequest = new (std::nothrow) ResourceRequest(AllowType::NETWORK,
80 0, "test_process", 100, "test", 1);
81 EXPECT_EQ(StandbyServiceClient::GetInstance().ApplyAllowResource(validResRequest), ERR_OK);
82 EXPECT_EQ(StandbyServiceClient::GetInstance().UnapplyAllowResource(validResRequest), ERR_OK);
83 }
84
85 /**
86 * @tc.name: StandbyServiceClientUnitTest_003
87 * @tc.desc: test GetAllowList.
88 * @tc.type: FUNC
89 * @tc.require:
90 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_003, TestSize.Level1)91 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_003, TestSize.Level1)
92 {
93 std::vector<AllowInfo> allowInfoList;
94 sptr<ResourceRequest> nullRequest = nullptr;
95 EXPECT_EQ(StandbyServiceClient::GetInstance().GetAllowList(AllowType::NETWORK, allowInfoList, 0), ERR_OK);
96 EXPECT_NE(StandbyServiceClient::GetInstance().GetAllowList(0, allowInfoList, 0), ERR_OK);
97 EXPECT_EQ(StandbyServiceClient::GetInstance().GetAllowList((1 << 6), allowInfoList, 0), ERR_OK);
98 allowInfoList.emplace_back(AllowInfo {});
99 StandbyServiceClient::GetInstance().GetAllowList((1 << 6), allowInfoList, 0);
100 }
101
102 /**
103 * @tc.name: StandbyServiceClientUnitTest_004
104 * @tc.desc: test IsDeviceInStandby.
105 * @tc.type: FUNC
106 * @tc.require:
107 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_004, TestSize.Level1)108 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_004, TestSize.Level1)
109 {
110 bool isStandby {false};
111 EXPECT_EQ(StandbyServiceClient::GetInstance().IsDeviceInStandby(isStandby), ERR_OK);
112 }
113
114 /**
115 * @tc.name: StandbyServiceClientUnitTest_005
116 * @tc.desc: test Unmarshalling.
117 * @tc.type: FUNC
118 * @tc.require:
119 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_005, TestSize.Level1)120 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_005, TestSize.Level1)
121 {
122 auto allowInfo = std::make_shared<AllowInfo>();
123 MessageParcel out;
124 EXPECT_TRUE(allowInfo->Marshalling(out));
125 MessageParcel data;
126 EXPECT_EQ(AllowInfo::Unmarshalling(data), nullptr);
127 EXPECT_EQ(ResourceRequest::Unmarshalling(data), nullptr);
128 }
129
130 /**
131 * @tc.name: StandbyServiceClientUnitTest_006
132 * @tc.desc: test ResetStandbyServiceClient.
133 * @tc.type: FUNC
134 * @tc.require:
135 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_006, TestSize.Level1)136 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_006, TestSize.Level1)
137 {
138 StandbyServiceClient::GetInstance().ResetStandbyServiceClient();
139 StandbyServiceClient::GetInstance().ResetStandbyServiceClient();
140 StandbyServiceClient::GetInstance().GetStandbyServiceProxy();
141 StandbyServiceClient::GetInstance().ResetStandbyServiceClient();
142 EXPECT_EQ(StandbyServiceClient::GetInstance().standbyServiceProxy_, nullptr);
143 }
144
145 /**
146 * @tc.name: StandbyServiceClientUnitTest_007
147 * @tc.desc: test StandbyServiceSubscriberStub.
148 * @tc.type: FUNC
149 * @tc.require:
150 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_007, TestSize.Level1)151 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_007, TestSize.Level1)
152 {
153 sptr<StandbyServiceSubscriberStub> subscriber = new (std::nothrow) StandbyServiceSubscriberStub();
154 MessageParcel data {};
155 MessageParcel reply {};
156 MessageOption option {};
157 subscriber->OnRemoteRequestInner(
158 (static_cast<uint32_t>(StandbySubscriberInterfaceCode::ON_ALLOW_LIST_CHANGED)), data, reply, option);
159 subscriber->OnRemoteRequestInner(
160 (static_cast<uint32_t>(StandbySubscriberInterfaceCode::ON_ALLOW_LIST_CHANGED)) + 1, data, reply, option);
161 EXPECT_NE(subscriber->HandleOnDeviceIdleMode(data), ERR_OK);
162 subscriber->HandleOnAllowListChanged(data);
163 data.WriteBool(false);
164 subscriber->HandleOnDeviceIdleMode(data);
165 data.WriteBool(false);
166 subscriber->HandleOnDeviceIdleMode(data);
167 subscriber->HandleOnAllowListChanged(data);
168 MessageParcel allowListData {};
169 subscriber->HandleOnAllowListChanged(allowListData);
170 allowListData.WriteInt32(0);
171 subscriber->HandleOnAllowListChanged(allowListData);
172 allowListData.WriteInt32(0);
173 subscriber->HandleOnAllowListChanged(allowListData);
174 allowListData.WriteString("");
175 subscriber->HandleOnAllowListChanged(allowListData);
176 allowListData.WriteUint32(0);
177 subscriber->HandleOnAllowListChanged(allowListData);
178 allowListData.WriteBool(false);
179 subscriber->HandleOnAllowListChanged(allowListData);
180 }
181
182 /**
183 * @tc.name: StandbyServiceClientUnitTest_008
184 * @tc.desc: test StandbyServiceProxy.
185 * @tc.type: FUNC
186 * @tc.require:
187 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_008, TestSize.Level1)188 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_008, TestSize.Level1)
189 {
190 sptr<IRemoteObject> impl {};
191 sptr<StandbyServiceProxy> proxy = new (std::nothrow) StandbyServiceProxy(impl);
192 sptr<IStandbyServiceSubscriber> nullSubscriber = nullptr;
193 EXPECT_NE(proxy->SubscribeStandbyCallback(nullSubscriber), ERR_OK);
194 EXPECT_NE(proxy->SubscribeStandbyCallback(nullSubscriber), ERR_OK);
195 proxy->UnsubscribeStandbyCallback(nullSubscriber);
196 }
197
198 /**
199 * @tc.name: StandbyServiceClientUnitTest_009
200 * @tc.desc: test ReportWorkSchedulerStatus.
201 * @tc.type: FUNC
202 * @tc.require:
203 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_009, TestSize.Level1)204 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_009, TestSize.Level1)
205 {
206 EXPECT_EQ(StandbyServiceClient::GetInstance().ReportWorkSchedulerStatus(true, -1, ""), ERR_OK);
207 EXPECT_EQ(StandbyServiceClient::GetInstance().ReportWorkSchedulerStatus(false, -1, ""), ERR_OK);
208 }
209
210 /**
211 * @tc.name: StandbyServiceClientUnitTest_010
212 * @tc.desc: test StandbyServiceSubscriberProxy.
213 * @tc.type: FUNC
214 * @tc.require:
215 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_010, TestSize.Level1)216 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_010, TestSize.Level1)
217 {
218 sptr<IRemoteObject> impl {};
219 sptr<StandbyServiceSubscriberProxy> proxy = new (std::nothrow) StandbyServiceSubscriberProxy(impl);
220 sptr<StandbyServiceSubscriberProxy> nullSubscriber = nullptr;
221 proxy->OnDeviceIdleMode(false, false);
222 proxy->OnAllowListChanged(-1, "", 0, false);
223 EXPECT_NE(proxy, nullptr);
224 }
225
226 /**
227 * @tc.name: StandbyServiceClientUnitTest_011
228 * @tc.desc: test IsStrategyEnabled.
229 * @tc.type: FUNC
230 * @tc.require:
231 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_011, TestSize.Level1)232 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_011, TestSize.Level1)
233 {
234 std::string strategyName;
235 bool isEnabled = false;
236 EXPECT_EQ(StandbyServiceClient::GetInstance().IsStrategyEnabled(strategyName, isEnabled), ERR_OK);
237 }
238
239 /**
240 * @tc.name: StandbyServiceClientUnitTest_012
241 * @tc.desc: test IsStrategyEnabled.
242 * @tc.type: FUNC
243 * @tc.require:
244 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_012, TestSize.Level1)245 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_012, TestSize.Level1)
246 {
247 DeviceStateType type = DeviceStateType::WIFI_P2P_CHANGE;
248 bool enabled = false;
249 EXPECT_EQ(StandbyServiceClient::GetInstance().ReportDeviceStateChanged(type, enabled), ERR_OK);
250 }
251
252 /**
253 * @tc.name: StandbyServiceClientUnitTest_013
254 * @tc.desc: test IsStrategyEnabled.
255 * @tc.type: FUNC
256 * @tc.require:
257 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_013, TestSize.Level1)258 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_013, TestSize.Level1)
259 {
260 uint32_t restrictType = 1;
261 std::vector<AllowInfo> restrictInfoList;
262 uint32_t reasonCode = ReasonCodeEnum::REASON_APP_API;
263 EXPECT_EQ(StandbyServiceClient::GetInstance().GetRestrictList(restrictType, restrictInfoList, reasonCode), ERR_OK);
264 }
265
266 /**
267 * @tc.name: StandbyServiceClientUnitTest_014
268 * @tc.desc: test IsDeviceInStandby.
269 * @tc.type: FUNC
270 * @tc.require:
271 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_014, TestSize.Level1)272 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_014, TestSize.Level1)
273 {
274 uint32_t type = 1;
275 bool enable = true;
276 uint32_t interval = 300;
277 EXPECT_EQ(StandbyServiceClient::GetInstance().SetNatInterval(type, enable, interval), ERR_PERMISSION_DENIED);
278 }
279
280 /**
281 * @tc.name: StandbyServiceClientUnitTest_015
282 * @tc.desc: test ReportPowerOverused.
283 * @tc.type: FUNC
284 * @tc.require:
285 */
HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_015, TestSize.Level1)286 HWTEST_F(StandbyServiceClientUnitTest, StandbyServiceClientUnitTest_015, TestSize.Level1)
287 {
288 std::string TEST_MODULE_NAME = "TestModule";
289 uint32_t level = static_cast<uint32_t>(PowerOverusedLevel::NORMAL);
290 EXPECT_EQ(StandbyServiceClient::GetInstance().ReportPowerOverused(TEST_MODULE_NAME, level), ERR_OK);
291 }
292
293 } // namespace DevStandbyMgr
294 } // namespace OHOS
295