1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "accesstoken_kit.h"
17 #include <gmock/gmock.h>
18 #include "gtest/gtest.h"
19 #include "ipc_skeleton.h"
20
21 #include "boomerang_callback_stub.h"
22 #include "boomerang_server.h"
23 #include "devicestatus_callback_stub.h"
24 #include "devicestatus_define.h"
25 #include "devicestatus_dumper.h"
26 #include "devicestatus_manager.h"
27 #include "devicestatus_hisysevent.h"
28 #include "fi_log.h"
29 #include "nativetoken_kit.h"
30 #include "token_setproc.h"
31 #include "parcel.h"
32
33 #undef LOG_TAG
34 #define LOG_TAG "BoomerangServerTest"
35
36 namespace OHOS {
37 namespace Msdp {
38 namespace DeviceStatus {
39 using namespace testing::ext;
40 namespace {
41 BoomerangServer boomerang_;
42 int32_t FD { 1 };
43 inline constexpr size_t MAX_STRING_LEN{1024};
44 Intention intention_ { Intention::BOOMERANG };
45
CreateEmptyPixelMap()46 static std::unique_ptr<Media::PixelMap> CreateEmptyPixelMap()
47 {
48 Media::InitializationOptions initOptions;
49 initOptions.size = {1080, 1920};
50 initOptions.pixelFormat = Media::PixelFormat::BGRA_8888;
51 initOptions.editable = true;
52 std::unique_ptr<Media::PixelMap> pixmap = Media::PixelMap::Create(initOptions);
53 return pixmap;
54 }
55
56 } // namespace
57
58 class BoomerangServerTest : public testing::Test {
59 public:
SetUpTestCase()60 static void SetUpTestCase() {};
TearDownTestCase()61 static void TearDownTestCase() {};
SetUp()62 void SetUp() {};
TearDown()63 void TearDown() {};
64 class BoomerangServerTestCallback : public BoomerangCallbackStub {
65 public:
BoomerangServerTestCallback()66 explicit BoomerangServerTestCallback() {}
~BoomerangServerTestCallback()67 virtual ~BoomerangServerTestCallback() {};
68 MOCK_METHOD(void, OnScreenshotResult, (const BoomerangData& data), (override));
69 MOCK_METHOD(void, OnNotifyMetadata, (const std::string& metadata), (override));
70 MOCK_METHOD(void, OnEncodeImageResult, (std::shared_ptr<Media::PixelMap> pixelMap), (override));
71 MOCK_METHOD(void, EmitOnEvent, (BoomerangData& data));
72 MOCK_METHOD(void, EmitOnMetadata, (std::string metadata));
73 MOCK_METHOD(void, EmitOnEncodeImage, (std::shared_ptr<Media::PixelMap> pixelMap));
74 };
75 };
76
77 /**
78 * @tc.name: BoomerangServerTest
79 * @tc.desc: BoomerangServerTest001
80 * @tc.type: FUNC
81 * @tc.require:
82 */
83
84 HWTEST_F(BoomerangServerTest, BoomerangServerTest001, TestSize.Level1)
85 {
86 CALL_TEST_DEBUG;
87 CallingContext context {
88 .intention = intention_,
89 .tokenId = IPCSkeleton::GetCallingTokenID(),
90 .uid = IPCSkeleton::GetCallingUid(),
91 .pid = IPCSkeleton::GetCallingPid(),
92 };
93 char bundleName[MAX_STRING_LEN] = {0};
94 int32_t type { BOOMERANG_TYPE_INVALID };
95 sptr<IRemoteBoomerangCallback> subCallback { nullptr };
96 int32_t ret = boomerang_.SubscribeCallback(context, type, bundleName, subCallback);
97 EXPECT_EQ(ret, RET_ERR);
98 }
99
100 /**
101 * @tc.name: BoomerangServerTest
102 * @tc.desc: BoomerangServerTest02
103 * @tc.type: FUNC
104 * @tc.require:
105 */
106 HWTEST_F(BoomerangServerTest, BoomerangServerTest02, TestSize.Level1)
107 {
108 CALL_TEST_DEBUG;
109 CallingContext context {
110 .intention = intention_,
111 .tokenId = IPCSkeleton::GetCallingTokenID(),
112 .uid = IPCSkeleton::GetCallingUid(),
113 .pid = IPCSkeleton::GetCallingPid(),
114 };
115 char bundleName[MAX_STRING_LEN] = {0};
116 int32_t type { BOOMERANG_TYPE_BOOMERANG };
117 sptr<IRemoteBoomerangCallback> subCallback = new (std::nothrow) BoomerangServerTestCallback();
118 int32_t ret = boomerang_.SubscribeCallback(context, type, bundleName, subCallback);
119 EXPECT_EQ(ret, RET_OK);
120 }
121
122 /**
123 * @tc.name: BoomerangServerTest
124 * @tc.desc: BoomerangServerTest003
125 * @tc.type: FUNC
126 * @tc.require:
127 */
128 HWTEST_F(BoomerangServerTest, BoomerangServerTest003, TestSize.Level1)
129 {
130 CALL_TEST_DEBUG;
131 CallingContext context {
132 .intention = intention_,
133 .tokenId = IPCSkeleton::GetCallingTokenID(),
134 .uid = IPCSkeleton::GetCallingUid(),
135 .pid = IPCSkeleton::GetCallingPid(),
136 };
137 char bundleName[MAX_STRING_LEN] = {0};
138 sptr<IRemoteBoomerangCallback> notifyCallback { nullptr };
139 int32_t ret = boomerang_.NotifyMetadataBindingEvent(context, bundleName, notifyCallback);
140 EXPECT_EQ(ret, RET_ERR);
141 }
142
143 /**
144 * @tc.name: BoomerangServerTest
145 * @tc.desc: BoomerangServerTest04
146 * @tc.type: FUNC
147 * @tc.require:
148 */
149 HWTEST_F(BoomerangServerTest, BoomerangServerTest04, TestSize.Level1)
150 {
151 CALL_TEST_DEBUG;
152 CallingContext context {
153 .intention = intention_,
154 .tokenId = IPCSkeleton::GetCallingTokenID(),
155 .uid = IPCSkeleton::GetCallingUid(),
156 .pid = IPCSkeleton::GetCallingPid(),
157 };
158 char bundleName[MAX_STRING_LEN] = {0};
159 sptr<IRemoteBoomerangCallback> notifyCallback = new (std::nothrow) BoomerangServerTestCallback();
160 int32_t ret = boomerang_.NotifyMetadataBindingEvent(context, bundleName, notifyCallback);
161 EXPECT_EQ(ret, RET_OK);
162 }
163
164 /**
165 * @tc.name: BoomerangServerTest
166 * @tc.desc: BoomerangServerTest005
167 * @tc.type: FUNC
168 * @tc.require:
169 */
170 HWTEST_F(BoomerangServerTest, BoomerangServerTest005, TestSize.Level1)
171 {
172 CALL_TEST_DEBUG;
173 CallingContext context {
174 .intention = intention_,
175 .tokenId = IPCSkeleton::GetCallingTokenID(),
176 .uid = IPCSkeleton::GetCallingUid(),
177 .pid = IPCSkeleton::GetCallingPid(),
178 };
179 char metadata[MAX_STRING_LEN] = {0};
180 sptr<IRemoteBoomerangCallback> encodeCallback = nullptr;
181 std::shared_ptr<Media::PixelMap> pixelMap { nullptr };
182 int32_t ret = boomerang_.BoomerangEncodeImage(context, pixelMap, metadata, encodeCallback);
183 EXPECT_EQ(ret, RET_ERR);
184 }
185
186 /**
187 * @tc.name: BoomerangServerTest
188 * @tc.desc: BoomerangServerTest06
189 * @tc.type: FUNC
190 * @tc.require:
191 */
192 HWTEST_F(BoomerangServerTest, BoomerangServerTest06, TestSize.Level1)
193 {
194 CALL_TEST_DEBUG;
195 CallingContext context {
196 .intention = intention_,
197 .tokenId = IPCSkeleton::GetCallingTokenID(),
198 .uid = IPCSkeleton::GetCallingUid(),
199 .pid = IPCSkeleton::GetCallingPid(),
200 };
201 string metadata = "test";
202 sptr<IRemoteBoomerangCallback> encodeCallback = new (std::nothrow) BoomerangServerTestCallback();
203 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = CreateEmptyPixelMap();
204 int32_t ret = boomerang_.BoomerangEncodeImage(context, pixelMap, metadata, encodeCallback);
205 EXPECT_EQ(ret, RET_OK);
206 }
207
208 /**
209 * @tc.name: BoomerangServerTest
210 * @tc.desc: BoomerangServerTest007
211 * @tc.type: FUNC
212 * @tc.require:
213 */
214 HWTEST_F(BoomerangServerTest, BoomerangServerTest007, TestSize.Level1)
215 {
216 CALL_TEST_DEBUG;
217 CallingContext context {
218 .intention = intention_,
219 .tokenId = IPCSkeleton::GetCallingTokenID(),
220 .uid = IPCSkeleton::GetCallingUid(),
221 .pid = IPCSkeleton::GetCallingPid(),
222 };
223 sptr<IRemoteBoomerangCallback> decodeCallback { nullptr };
224 std::shared_ptr<Media::PixelMap> pixelMap { nullptr };
225 int32_t ret = boomerang_.BoomerangDecodeImage(context, pixelMap, decodeCallback);
226 EXPECT_EQ(ret, RET_ERR);
227 }
228
229 /**
230 * @tc.name: BoomerangServerTest
231 * @tc.desc: BoomerangServerTest008
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(BoomerangServerTest, BoomerangServerTest008, TestSize.Level1)
236 {
237 CALL_TEST_DEBUG;
238 CallingContext context {
239 .intention = intention_,
240 .tokenId = IPCSkeleton::GetCallingTokenID(),
241 .uid = IPCSkeleton::GetCallingUid(),
242 .pid = IPCSkeleton::GetCallingPid(),
243 };
244 sptr<IRemoteBoomerangCallback> decodeCallback = new (std::nothrow) BoomerangServerTestCallback();
245 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = CreateEmptyPixelMap();
246 int32_t ret = boomerang_.BoomerangDecodeImage(context, pixelMap, decodeCallback);
247 EXPECT_EQ(ret, RET_OK);
248 }
249
250 /**
251 * @tc.name: BoomerangServerTest
252 * @tc.desc: BoomerangServerTest009
253 * @tc.type: FUNC
254 * @tc.require:
255 */
256 HWTEST_F(BoomerangServerTest, BoomerangServerTest009, TestSize.Level1)
257 {
258 CALL_TEST_DEBUG;
259 CallingContext context {
260 .intention = intention_,
261 .tokenId = IPCSkeleton::GetCallingTokenID(),
262 .uid = IPCSkeleton::GetCallingUid(),
263 .pid = IPCSkeleton::GetCallingPid(),
264 };
265 int32_t type { BOOMERANG_TYPE_INVALID };
266 char bundleName[MAX_STRING_LEN] = {0};
267 sptr<IRemoteBoomerangCallback> unsubCallback { nullptr };
268 int32_t ret = boomerang_.UnsubscribeCallback(context, type, bundleName, unsubCallback);
269 EXPECT_EQ(ret, RET_ERR);
270 }
271
272 /**
273 * @tc.name: BoomerangServerTest
274 * @tc.desc: BoomerangServerTest10
275 * @tc.type: FUNC
276 * @tc.require:
277 */
278 HWTEST_F(BoomerangServerTest, BoomerangServerTest10, TestSize.Level1)
279 {
280 CALL_TEST_DEBUG;
281 CallingContext context {
282 .intention = intention_,
283 .tokenId = IPCSkeleton::GetCallingTokenID(),
284 .uid = IPCSkeleton::GetCallingUid(),
285 .pid = IPCSkeleton::GetCallingPid(),
286 };
287 char bundleName[MAX_STRING_LEN] = {0};
288 BoomerangType type { BOOMERANG_TYPE_BOOMERANG };
289 sptr<IRemoteBoomerangCallback> unsubCallback = new (std::nothrow) BoomerangServerTestCallback();
290 int32_t ret = boomerang_.UnsubscribeCallback(context, type, bundleName, unsubCallback);
291 EXPECT_EQ(ret, RET_OK);
292 }
293
294 /**
295 * @tc.name: BoomerangServerTest
296 * @tc.desc: BoomerangServerTest11
297 * @tc.type: FUNC
298 * @tc.require:
299 */
300 HWTEST_F(BoomerangServerTest, BoomerangServerTest11, TestSize.Level1)
301 {
302 CALL_TEST_DEBUG;
303 CallingContext context {
304 .intention = intention_,
305 .tokenId = IPCSkeleton::GetCallingTokenID(),
306 .uid = IPCSkeleton::GetCallingUid(),
307 .pid = IPCSkeleton::GetCallingPid(),
308 };
309 string metadata = "";
310 int32_t ret = boomerang_.SubmitMetadata(context, metadata);
311 EXPECT_EQ(ret, RET_OK);
312 }
313
314 /**
315 * @tc.name: BoomerangServerTest
316 * @tc.desc: BoomerangServerTest12
317 * @tc.type: FUNC
318 * @tc.require:
319 */
320 HWTEST_F(BoomerangServerTest, BoomerangServerTest12, TestSize.Level1)
321 {
322 CALL_TEST_DEBUG;
323 CallingContext context {
324 .intention = intention_,
325 .tokenId = IPCSkeleton::GetCallingTokenID(),
326 .uid = IPCSkeleton::GetCallingUid(),
327 .pid = IPCSkeleton::GetCallingPid(),
328 };
329 string metadata = "test";
330 int32_t ret = boomerang_.SubmitMetadata(context, metadata);
331 EXPECT_EQ(ret, RET_ERR);
332 }
333
334 /**
335 * @tc.name: BoomerangServerTest
336 * @tc.desc: BoomerangServerTest013
337 * @tc.type: FUNC
338 * @tc.require:
339 */
340 HWTEST_F(BoomerangServerTest, BoomerangServerTest013, TestSize.Level1)
341 {
342 CALL_TEST_DEBUG;
343 ASSERT_NO_FATAL_FAILURE(boomerang_.DumpCurrentDeviceStatus(FD));
344 }
345
346 /**
347 * @tc.name: BoomerangServerTest
348 * @tc.desc: BoomerangServerTest014
349 * @tc.type: FUNC
350 * @tc.require:
351 */
352 HWTEST_F(BoomerangServerTest, BoomerangServerTest014, TestSize.Level1)
353 {
354 CALL_TEST_DEBUG;
355 ASSERT_NO_FATAL_FAILURE(boomerang_.DumpDeviceStatusSubscriber(FD));
356 }
357
358 /**
359 * @tc.name: BoomerangServerTest
360 * @tc.desc: BoomerangServerTest015
361 * @tc.type: FUNC
362 * @tc.require:
363 */
364 HWTEST_F(BoomerangServerTest, BoomerangServerTest015, TestSize.Level1)
365 {
366 CALL_TEST_DEBUG;
367 ASSERT_NO_FATAL_FAILURE(boomerang_.DumpDeviceStatusChanges(FD));
368 }
369
370 /**
371 * @tc.name: BoomerangServerTest
372 * @tc.desc: BoomerangServerTest16
373 * @tc.type: FUNC
374 * @tc.require:
375 */
376 HWTEST_F(BoomerangServerTest, BoomerangServerTest16, TestSize.Level1)
377 {
378 CALL_TEST_DEBUG;
379 CallingContext context {
380 .intention = intention_,
381 .tokenId = IPCSkeleton::GetCallingTokenID(),
382 .uid = IPCSkeleton::GetCallingUid(),
383 .pid = IPCSkeleton::GetCallingPid(),
384 };
385 boomerang_.ReportSensorSysEvent(context, 2, true);
386 Data data = boomerang_.GetCache(context, Type::TYPE_STILL);
387 EXPECT_EQ(data.status, Status::STATUS_INVALID);
388 }
389 } // namespace DeviceStatus
390 } // namespace Msdp
391 } // namespace OHOS