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 
16 #include "pixel_map.h"
17 #include "session_listener_controller.h"
18 
19 #include <gtest/gtest.h>
20 
21 #include "display_manager_adapter.h"
22 #include "mission_listener_stub.h"
23 #include "singleton_container.h"
24 
25 using namespace testing;
26 using namespace testing::ext;
27 using namespace OHOS::Media;
28 namespace OHOS {
29 namespace Rosen {
30 class MyMissionListener : public AAFwk::MissionListenerStub {
31 public:
32     MyMissionListener() = default;
33     ~MyMissionListener() = default;
34 
OnMissionCreated(int32_t missionId)35     void OnMissionCreated(int32_t missionId) override
36     {
37         isMissionCreated_ = true;
38     }
39 
OnMissionDestroyed(int32_t missionId)40     void OnMissionDestroyed(int32_t missionId) override
41     {
42         isMissionDestroyed_ = true;
43     }
44 
OnMissionSnapshotChanged(int32_t missionId)45     void OnMissionSnapshotChanged(int32_t missionId) override
46     {
47         isMissionSnapshotChanged_ = true;
48     }
49 
OnMissionMovedToFront(int32_t missionId)50     void OnMissionMovedToFront(int32_t missionId) override
51     {
52         isMissionMovedToFront_ = true;
53     }
54 
55 #ifdef SUPPORT_GRAPHICS
OnMissionIconUpdated(int32_t missionId,const std::shared_ptr<OHOS::Media::PixelMap> & icon)56     void OnMissionIconUpdated(int32_t missionId, const std::shared_ptr<OHOS::Media::PixelMap>& icon) override
57     {
58         isMissionIconUpdated_ = true;
59     }
60 #endif
61 
OnMissionClosed(int32_t missionId)62     void OnMissionClosed(int32_t missionId) override
63     {
64         isMissionClosed_ = true;
65     }
66 
OnMissionLabelUpdated(int32_t missionId)67     void OnMissionLabelUpdated(int32_t missionId) override
68     {
69         isMissionLabelUpdated_ = true;
70     }
71 
IsMissionCreated() const72     bool IsMissionCreated() const
73     {
74         return isMissionCreated_;
75     }
76 
IsMissionDestroyed() const77     bool IsMissionDestroyed() const
78     {
79         return isMissionDestroyed_;
80     }
81 
IsMissionSnapshotChanged() const82     bool IsMissionSnapshotChanged() const
83     {
84         return isMissionSnapshotChanged_;
85     }
86 
IsMissionMovedToFront() const87     bool IsMissionMovedToFront() const
88     {
89         return isMissionMovedToFront_;
90     }
91 
IsMissionIconUpdated() const92     bool IsMissionIconUpdated() const
93     {
94         return isMissionIconUpdated_;
95     }
96 
IsMissionClosed() const97     bool IsMissionClosed() const
98     {
99         return isMissionClosed_;
100     }
101 
IsMissionLabelUpdated() const102     bool IsMissionLabelUpdated() const
103     {
104         return isMissionLabelUpdated_;
105     }
106 
107 private:
108     bool isMissionCreated_ = false;
109     bool isMissionDestroyed_ = false;
110     bool isMissionSnapshotChanged_ = false;
111     bool isMissionMovedToFront_ = false;
112     bool isMissionIconUpdated_ = false;
113     bool isMissionClosed_ = false;
114     bool isMissionLabelUpdated_ = false;
115 };
116 
117 class SessionListenerControllerTest : public testing::Test {
118   public:
119     static void SetUpTestCase();
120     static void TearDownTestCase();
121     void SetUp() override;
122     void TearDown() override;
123     std::shared_ptr<SessionListenerController> slController;
124 private:
125     static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
126 };
127 
128 
SetUpTestCase()129 void SessionListenerControllerTest::SetUpTestCase()
130 {
131 }
132 
TearDownTestCase()133 void SessionListenerControllerTest::TearDownTestCase()
134 {
135 }
136 
SetUp()137 void SessionListenerControllerTest::SetUp()
138 {
139     slController = std::make_shared<SessionListenerController>();
140 }
141 
TearDown()142 void SessionListenerControllerTest::TearDown()
143 {
144     usleep(WAIT_SYNC_IN_NS);
145 }
146 
147 namespace {
148 /**
149  * @tc.name: AddSessionListener
150  * @tc.desc: normal function
151  * @tc.type: FUNC
152  */
153 HWTEST_F(SessionListenerControllerTest, AddSessionListener, Function | SmallTest | Level2)
154 {
155     sptr<ISessionListener> listener;
156     ASSERT_EQ(listener, nullptr);
157     WSError res = slController->AddSessionListener(listener);
158     ASSERT_EQ(res, WSError::WS_ERROR_INVALID_PARAM);
159 
160     slController->Init();
161     listener = new MyMissionListener();
162     EXPECT_NE(nullptr, listener);
163     res = slController->AddSessionListener(listener);
164     EXPECT_EQ(WSError::WS_OK, res);
165 
166     auto iSession = listener;
167     WSError newRes = slController->AddSessionListener(iSession);
168     EXPECT_EQ(WSError::WS_OK, newRes);
169 }
170 
171 /**
172  * @tc.name: DelSessionListener
173  * @tc.desc: normal function
174  * @tc.type: FUNC
175  */
176 HWTEST_F(SessionListenerControllerTest, DelSessionListener, Function | SmallTest | Level2)
177 {
178     sptr<ISessionListener> listener;
179     ASSERT_EQ(listener, nullptr);
180     slController->DelSessionListener(listener);
181     int32_t persistentId = 1;
182     slController->NotifySessionLabelUpdated(persistentId);
183     ASSERT_EQ(persistentId, 1);
184 
185     slController->Init();
186     listener = new MyMissionListener();
187     slController->DelSessionListener(listener);
188     EXPECT_NE(nullptr, listener);
189 }
190 
191 /**
192  * @tc.name: NotifySessionCreated
193  * @tc.desc: normal function
194  * @tc.type: FUNC
195  */
196 HWTEST_F(SessionListenerControllerTest, NotifySessionCreated, Function | SmallTest | Level2)
197 {
198     int32_t persistentId = -1;
199     ASSERT_NE(slController, nullptr);
200     slController->NotifySessionCreated(persistentId);
201 
202     persistentId = 1;
203     slController->NotifySessionCreated(persistentId);
204 
205     slController->Init();
206     slController->NotifySessionCreated(persistentId);
207 }
208 
209 /**
210  * @tc.name: NotifySessionDestroyed
211  * @tc.desc: normal function
212  * @tc.type: FUNC
213  */
214 HWTEST_F(SessionListenerControllerTest, NotifySessionDestroyed, Function | SmallTest | Level2)
215 {
216     int32_t persistentId = -1;
217     ASSERT_NE(slController, nullptr);
218     slController->NotifySessionDestroyed(persistentId);
219 
220     persistentId = 1;
221     slController->NotifySessionDestroyed(persistentId);
222 
223     slController->Init();
224     slController->NotifySessionDestroyed(persistentId);
225 }
226 
227 /**
228  * @tc.name: HandleUnInstallApp1
229  * @tc.desc: normal function
230  * @tc.type: FUNC
231  */
232 HWTEST_F(SessionListenerControllerTest, HandleUnInstallApp1, Function | SmallTest | Level2)
233 {
234     std::list<int32_t> sessions;
235     slController->HandleUnInstallApp(sessions);
236     EXPECT_EQ(0, sessions.size());
237 }
238 
239 /**
240  * @tc.name: HandleUnInstallApp2
241  * @tc.desc: normal function
242  * @tc.type: FUNC
243  */
244 HWTEST_F(SessionListenerControllerTest, HandleUnInstallApp2, Function | SmallTest | Level2)
245 {
246     std::list<int32_t> sessions;
247     sessions.push_front(1);
248     slController->HandleUnInstallApp(sessions);
249     slController->Init();
250     slController->HandleUnInstallApp(sessions);
251     EXPECT_NE(0, sessions.size());
252     int32_t persistentId = 1;
253     slController->NotifySessionLabelUpdated(persistentId);
254     ASSERT_EQ(persistentId, 1);
255 }
256 
257 /**
258  * @tc.name: NotifySessionSnapshotChanged
259  * @tc.desc: normal function
260  * @tc.type: FUNC
261  */
262 HWTEST_F(SessionListenerControllerTest, NotifySessionSnapshotChanged, Function | SmallTest | Level2)
263 {
264     int32_t persistentId = -1;
265     ASSERT_NE(slController, nullptr);
266     slController->NotifySessionSnapshotChanged(persistentId);
267 
268     persistentId = 1;
269     slController->NotifySessionSnapshotChanged(persistentId);
270 
271     slController->Init();
272     slController->NotifySessionSnapshotChanged(persistentId);
273 }
274 
275 /**
276  * @tc.name: NotifySessionMovedToFront
277  * @tc.desc: normal function
278  * @tc.type: FUNC
279  */
280 HWTEST_F(SessionListenerControllerTest, NotifySessionMovedToFront, Function | SmallTest | Level2)
281 {
282     int32_t persistentId = -1;
283     ASSERT_NE(slController, nullptr);
284     slController->NotifySessionMovedToFront(persistentId);
285 
286     persistentId = 1;
287     slController->NotifySessionMovedToFront(persistentId);
288 
289     slController->Init();
290     slController->NotifySessionSnapshotChanged(persistentId);
291 }
292 
293 /**
294  * @tc.name: NotifySessionFocused
295  * @tc.desc: normal function
296  * @tc.type: FUNC
297  */
298 HWTEST_F(SessionListenerControllerTest, NotifySessionFocused, Function | SmallTest | Level2)
299 {
300     int32_t persistentId = -1;
301     ASSERT_NE(slController, nullptr);
302     slController->NotifySessionFocused(persistentId);
303 
304     persistentId = 1;
305     slController->NotifySessionFocused(persistentId);
306 
307     slController->Init();
308     slController->NotifySessionSnapshotChanged(persistentId);
309 }
310 
311 /**
312  * @tc.name: NotifySessionUnfocused
313  * @tc.desc: normal function
314  * @tc.type: FUNC
315  */
316 HWTEST_F(SessionListenerControllerTest, NotifySessionUnfocused, Function | SmallTest | Level2)
317 {
318     int32_t persistentId = -1;
319     ASSERT_NE(slController, nullptr);
320     slController->NotifySessionUnfocused(persistentId);
321 
322     persistentId = 1;
323     slController->NotifySessionUnfocused(persistentId);
324 
325     slController->Init();
326     slController->NotifySessionSnapshotChanged(persistentId);
327 }
328 
329 /**
330  * @tc.name: NotifySessionClosed
331  * @tc.desc: normal function
332  * @tc.type: FUNC
333  */
334 HWTEST_F(SessionListenerControllerTest, NotifySessionClosed, Function | SmallTest | Level2)
335 {
336     int32_t persistentId = -1;
337     ASSERT_NE(slController, nullptr);
338     slController->NotifySessionClosed(persistentId);
339 
340     persistentId = 1;
341     slController->NotifySessionClosed(persistentId);
342 
343     slController->Init();
344     slController->NotifySessionSnapshotChanged(persistentId);
345 }
346 
347 /**
348  * @tc.name: NotifySessionLabelUpdated
349  * @tc.desc: normal function
350  * @tc.type: FUNC
351  */
352 HWTEST_F(SessionListenerControllerTest, NotifySessionLabelUpdated, Function | SmallTest | Level2)
353 {
354     int32_t persistentId = -1;
355     ASSERT_NE(slController, nullptr);
356     slController->NotifySessionLabelUpdated(persistentId);
357 
358     persistentId = 1;
359     slController->NotifySessionLabelUpdated(persistentId);
360 
361     slController->Init();
362     slController->NotifySessionSnapshotChanged(persistentId);
363 }
364 
365 /**
366  * @tc.name: OnListenerDied
367  * @tc.desc: normal function
368  * @tc.type: FUNC
369  */
370 HWTEST_F(SessionListenerControllerTest, OnListenerDied, Function | SmallTest | Level2)
371 {
372     sptr<IRemoteObject> remote;
373     if (slController == nullptr) {
374         return;
375     }
376     slController->OnListenerDied(remote);
377     EXPECT_EQ(nullptr, remote);
378 
379     if (SingletonContainer::Get<ScreenManagerAdapter>().InitDMSProxy()) {
380         remote = SingletonContainer::Get<ScreenManagerAdapter>().displayManagerServiceProxy_->AsObject();
381         slController->OnListenerDied(remote);
382         EXPECT_NE(nullptr, remote);
383     }
384 }
385 
386 /**
387  * @tc.name: NotifySessionIconChanged
388  * @tc.desc: normal function
389  * @tc.type: FUNC
390  */
391 HWTEST_F(SessionListenerControllerTest, NotifySessionIconChanged, Function | SmallTest | Level2)
392 {
393     int32_t persistentId = -1;
394 
395     int32_t pixelMapWidth = 4;
396     int32_t pixelMapHeight = 3;
397     std::unique_ptr<OHOS::Media::PixelMap> pixelMap = std::make_unique<OHOS::Media::PixelMap>();
398     OHOS::Media::ImageInfo info;
399     info.size.width = pixelMapWidth;
400     info.size.height = pixelMapHeight;
401     info.pixelFormat = OHOS::Media::PixelFormat::RGB_888;
402     pixelMap->SetImageInfo(info);
403     std::shared_ptr<OHOS::Media::PixelMap> icon = std::move(pixelMap);
404     slController->NotifySessionIconChanged(persistentId, icon);
405 
406     persistentId = 1;
407     slController->NotifySessionIconChanged(persistentId, icon);
408 
409     slController->Init();
410     slController->NotifySessionIconChanged(persistentId, icon);
411     EXPECT_NE(nullptr, slController->taskScheduler_);
412 }
413 
414 /**
415  * @tc.name: ListenerDeathRecipient
416  * @tc.desc: ListenerDeathRecipient class test
417  * @tc.type: CLASS
418  */
419 HWTEST_F(SessionListenerControllerTest, ListenerDeathRecipient, Function | SmallTest | Level2)
420 {
421     GTEST_LOG_(INFO) << "TaskSchedulerText: task_scheduler_test001 start";
422     EXPECT_EQ(nullptr,  slController->listenerDeathRecipient_);
423     slController->Init();
424     sptr<ISessionListener> listener = new MyMissionListener();
425     slController->AddSessionListener(listener);
426     EXPECT_NE(nullptr,  slController->listenerDeathRecipient_);
427 
428     if (SingletonContainer::Get<ScreenManagerAdapter>().InitDMSProxy()) {
429         sptr<IRemoteObject> remote;
430         remote = SingletonContainer::Get<ScreenManagerAdapter>().displayManagerServiceProxy_->AsObject();
431         slController->listenerDeathRecipient_->OnRemoteDied(remote);
432         EXPECT_NE(nullptr, remote);
433     }
434     GTEST_LOG_(INFO) << "TaskSchedulerText: task_scheduler_test001 end";
435 }
436 } // namespace
437 } // namespace Rosen
438 } // namespace OHOS