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 <future>
17 #include <optional>
18
19 #include <unistd.h>
20 #include <utility>
21
22 #include <gtest/gtest.h>
23 #include <gmock/gmock.h>
24
25 #include "boomerang_callback_stub.h"
26 #include "boomerang_client.h"
27 #include "iremote_boomerang_callback.h"
28 #include "devicestatus_define.h"
29 #include "devicestatus_errors.h"
30 #include "i_hotarea_listener.h"
31 #include "i_event_listener.h"
32 #include "i_coordination_listener.h"
33
34
35 #undef LOG_TAG
36 #define LOG_TAG "BoomerangClientTest"
37
38 namespace OHOS {
39 namespace Msdp {
40 namespace DeviceStatus {
41 using namespace testing::ext;
42 using namespace testing;
43 namespace {
44 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
45 inline constexpr size_t MAX_STRING_LEN{1024};
46 } // namespace
47
CreateEmptyPixelMap()48 static std::unique_ptr<Media::PixelMap> CreateEmptyPixelMap()
49 {
50 Media::InitializationOptions initOptions;
51 initOptions.size = {1080, 1920};
52 initOptions.pixelFormat = Media::PixelFormat::BGRA_8888;
53 initOptions.editable = true;
54 std::unique_ptr<Media::PixelMap> pixmap = Media::PixelMap::Create(initOptions);
55 return pixmap;
56 }
57
58 class BoomerangClientTest : public testing::Test {
59 public:
60 void SetUp();
61 void TearDown();
62 static void SetUpTestCase();
63 static void TearDownTestCase();
64 class BoomerangClientTestCallback : public BoomerangCallbackStub {
65 public:
66 private:
67 BoomerangData data_;
68 };
69 };
70
SetUpTestCase()71 void BoomerangClientTest::SetUpTestCase() {}
72
TearDownTestCase()73 void BoomerangClientTest::TearDownTestCase() {}
74
SetUp()75 void BoomerangClientTest::SetUp() {}
76
TearDown()77 void BoomerangClientTest::TearDown()
78 {
79 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
80 }
81
82 class TestEventListener final : public IEventListener {
83 public:
TestEventListener()84 TestEventListener() : IEventListener() {};
85 ~TestEventListener() = default;
86
OnMouseLocationEvent(const std::string & networkId,const Event & event)87 void OnMouseLocationEvent(const std::string &networkId, const Event &event) override
88 {
89 (void) networkId;
90 (void) event;
91 };
92 };
93
94 /**
95 * @tc.name: BoomerangClientTest_001
96 * @tc.desc: BoomerangClientTest
97 * @tc.type: FUNC
98 * @tc.require:
99 */
100 HWTEST_F(BoomerangClientTest, BoomerangClientTest_001, TestSize.Level1)
101 {
102 CALL_TEST_DEBUG;
103 sptr<IRemoteBoomerangCallback> callback = new (std::nothrow) BoomerangClientTestCallback();
104 char bundleName[MAX_STRING_LEN] = {0};
105 BoomerangClient boomerangClient;
106 int32_t ret = boomerangClient.SubscribeCallback(
107 BoomerangType::BOOMERANG_TYPE_BOOMERANG, bundleName, callback);
108 ASSERT_EQ(ret, RET_OK);
109 ret = boomerangClient.UnsubscribeCallback(BoomerangType::BOOMERANG_TYPE_BOOMERANG, bundleName, callback);
110 ASSERT_EQ(ret, RET_OK);
111 }
112
113 /**
114 * @tc.name: BoomerangClientTest_002
115 * @tc.desc: BoomerangClientTest
116 * @tc.type: FUNC
117 * @tc.require:
118 */
119 HWTEST_F(BoomerangClientTest, BoomerangClientTest_002, TestSize.Level1)
120 {
121 CALL_TEST_DEBUG;
122 sptr<IRemoteBoomerangCallback> callback = new (std::nothrow) BoomerangClientTestCallback();
123 char bundleName[MAX_STRING_LEN] = {0};
124 BoomerangClient boomerangClient;
125 int32_t ret = boomerangClient.SubscribeCallback(
126 BoomerangType::BOOMERANG_TYPE_BOOMERANG, bundleName, callback);
127 ret = boomerangClient.NotifyMetadataBindingEvent(bundleName, callback);
128 ASSERT_EQ(ret, RET_OK);
129 }
130
131 /**
132 * @tc.name: BoomerangClientTest_003
133 * @tc.desc: BoomerangClientTest
134 * @tc.type: FUNC
135 * @tc.require:
136 */
137 HWTEST_F(BoomerangClientTest, BoomerangClientTest_003, TestSize.Level1)
138 {
139 CALL_TEST_DEBUG;
140 std::string metadata = "test";
141 BoomerangClient boomerangClient;
142 sptr<IRemoteBoomerangCallback> callback = new (std::nothrow) BoomerangClientTestCallback();
143 char bundleName[MAX_STRING_LEN] = {0};
144 int32_t ret = boomerangClient.SubscribeCallback(
145 BoomerangType::BOOMERANG_TYPE_BOOMERANG, bundleName, callback);
146 ASSERT_EQ(ret, RET_OK);
147 ret = boomerangClient.SubmitMetadata(metadata);
148 ASSERT_EQ(ret, RET_OK);
149 }
150
151 /**
152 * @tc.name: BoomerangClientTest_004
153 * @tc.desc: BoomerangClientTest
154 * @tc.type: FUNC
155 * @tc.require:
156 */
157 HWTEST_F(BoomerangClientTest, BoomerangClientTest_004, TestSize.Level1)
158 {
159 CALL_TEST_DEBUG;
160 std::string metadata = "test";
161 BoomerangClient boomerangClient;
162 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = CreateEmptyPixelMap();
163 sptr<IRemoteBoomerangCallback> callback = new (std::nothrow) BoomerangClientTestCallback();
164 int32_t ret = boomerangClient.BoomerangEncodeImage(pixelMap, metadata, callback);
165 ASSERT_EQ(ret, RET_OK);
166 }
167
168 /**
169 * @tc.name: BoomerangClientTest_005
170 * @tc.desc: BoomerangClientTest
171 * @tc.type: FUNC
172 * @tc.require:
173 */
174 HWTEST_F(BoomerangClientTest, BoomerangClientTest_005, TestSize.Level1)
175 {
176 CALL_TEST_DEBUG;
177 std::string metadata = "test";
178 BoomerangClient boomerangClient;
179 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = CreateEmptyPixelMap();
180 sptr<IRemoteBoomerangCallback> callback = new (std::nothrow) BoomerangClientTestCallback();
181 int32_t ret = boomerangClient.BoomerangDecodeImage(pixelMap, callback);
182 ASSERT_EQ(ret, RET_OK);
183 }
184
185 /**
186 * @tc.name: BoomerangClientTest_006
187 * @tc.desc: BoomerangClientTest
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(BoomerangClientTest, BoomerangClientTest_006, TestSize.Level1)
192 {
193 CALL_TEST_DEBUG;
194 sptr<IRemoteBoomerangCallback> callback1 = new (std::nothrow) BoomerangClientTestCallback();
195 sptr<IRemoteBoomerangCallback> callback2 = nullptr;
196 char bundleName[MAX_STRING_LEN] = {0};
197 BoomerangClient boomerangClient;
198 int32_t ret = boomerangClient.SubscribeCallback(
199 BoomerangType::BOOMERANG_TYPE_BOOMERANG, bundleName, callback1);
200 ASSERT_EQ(ret, RET_OK);
201 ret = boomerangClient.UnsubscribeCallback(BoomerangType::BOOMERANG_TYPE_BOOMERANG, bundleName, callback2);
202 ASSERT_NE(ret, RET_OK);
203 }
204
205 /**
206 * @tc.name: BoomerangClientTest_007
207 * @tc.desc: BoomerangClientTest
208 * @tc.type: FUNC
209 * @tc.require:
210 */
211 HWTEST_F(BoomerangClientTest, BoomerangClientTest_007, TestSize.Level1)
212 {
213 CALL_TEST_DEBUG;
214 sptr<IRemoteBoomerangCallback> callback1 = new (std::nothrow) BoomerangClientTestCallback();
215 sptr<IRemoteBoomerangCallback> callback2 = nullptr;
216 char bundleName[MAX_STRING_LEN] = {0};
217 BoomerangClient boomerangClient;
218 int32_t ret = boomerangClient.SubscribeCallback(
219 BoomerangType::BOOMERANG_TYPE_BOOMERANG, bundleName, callback1);
220 ASSERT_EQ(ret, RET_OK);
221 ret = boomerangClient.NotifyMetadataBindingEvent(bundleName, callback2);
222 ASSERT_NE(ret, RET_OK);
223 }
224
225 /**
226 * @tc.name: BoomerangClientTest_008
227 * @tc.desc: BoomerangClientTest
228 * @tc.type: FUNC
229 * @tc.require:
230 */
231 HWTEST_F(BoomerangClientTest, BoomerangClientTest_008, TestSize.Level1)
232 {
233 CALL_TEST_DEBUG;
234 std::string metadata;
235 BoomerangClient boomerangClient;
236 sptr<IRemoteBoomerangCallback> callback = new (std::nothrow) BoomerangClientTestCallback();
237 char bundleName[MAX_STRING_LEN] = {0};
238 int32_t ret = boomerangClient.SubscribeCallback(
239 BoomerangType::BOOMERANG_TYPE_BOOMERANG, bundleName, callback);
240 ASSERT_EQ(ret, RET_OK);
241 ret = boomerangClient.SubmitMetadata(metadata);
242 ASSERT_EQ(ret, RET_ERR);
243 }
244
245 /**
246 * @tc.name: BoomerangClientTest_009
247 * @tc.desc: BoomerangClientTest
248 * @tc.type: FUNC
249 * @tc.require:
250 */
251 HWTEST_F(BoomerangClientTest, BoomerangClientTest_009, TestSize.Level1)
252 {
253 CALL_TEST_DEBUG;
254 std::string metadata;
255 BoomerangClient boomerangClient;
256 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = CreateEmptyPixelMap();
257 sptr<IRemoteBoomerangCallback> callback = nullptr;
258 int32_t ret = boomerangClient.BoomerangEncodeImage(pixelMap, metadata, callback);
259 ASSERT_NE(ret, RET_OK);
260 }
261
262 /**
263 * @tc.name: BoomerangClientTest_010
264 * @tc.desc: BoomerangClientTest
265 * @tc.type: FUNC
266 * @tc.require:
267 */
268 HWTEST_F(BoomerangClientTest, BoomerangClientTest_010, TestSize.Level1)
269 {
270 CALL_TEST_DEBUG;
271 std::string metadata;
272 BoomerangClient boomerangClient;
273 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = CreateEmptyPixelMap();
274 sptr<IRemoteBoomerangCallback> callback = nullptr;
275 int32_t ret = boomerangClient.BoomerangDecodeImage(pixelMap, callback);
276 ASSERT_NE(ret, RET_OK);
277 }
278 } // namespace DeviceStatus
279 } // namespace Msdp
280 } // namespace OHOS
281