1 /*
2  * Copyright (c) 2024 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 "common/include/window_session_property.h"
16 #include <gtest/gtest.h>
17 #include "input_manager.h"
18 #include <parameter.h>
19 #include <parameters.h>
20 #include "session_manager/include/scene_session_dirty_manager.h"
21 #include "screen_session_manager/include/screen_session_manager_client.h"
22 #include "scene_input_manager.h"
23 #include "session/host/include/scene_session.h"
24 #include "session_manager/include/scene_session_manager.h"
25 #include "transaction/rs_uiextension_data.h"
26 #include "window_helper.h"
27 
28 using namespace testing;
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 namespace Rosen {
33 
34 class SceneSessionDirtyManagerTest2 : public testing::Test {
35 public:
36     static void SetUpTestCase();
37     static void TearDownTestCase();
38     void SetUp() override;
39     void TearDown() override;
40     static constexpr uint32_t WAIT_SYNC_IN_NS = 500000;
41 };
42 
43 std::shared_ptr<SceneSessionDirtyManager> manager_;
44 sptr<SceneSessionManager> ssm_;
45 std::shared_ptr<SceneInputManager> sim_;
46 
SetUpTestCase()47 void SceneSessionDirtyManagerTest2::SetUpTestCase()
48 {
49     ssm_ = &SceneSessionManager::GetInstance();
50     ssm_->sceneSessionMap_.clear();
51     sim_ = std::make_shared<SceneInputManager>();
52 }
53 
TearDownTestCase()54 void SceneSessionDirtyManagerTest2::TearDownTestCase()
55 {
56     ssm_ = nullptr;
57 }
58 
SetUp()59 void SceneSessionDirtyManagerTest2::SetUp()
60 {
61     manager_ = std::make_shared<SceneSessionDirtyManager>();
62 }
63 
TearDown()64 void SceneSessionDirtyManagerTest2::TearDown()
65 {
66     usleep(WAIT_SYNC_IN_NS);
67     manager_ = nullptr;
68 }
69 
70 namespace {
71 
InitSessionInfo(MMI::DisplayInfo & displayedInfo,MMI::WindowInfo & windowInfo)72 void InitSessionInfo(MMI::DisplayInfo& displayedInfo, MMI::WindowInfo& windowInfo)
73 {
74     displayedInfo = {
75         .id = 42,
76         .x = 0,
77         .y = 0,
78         .width = 1270,
79         .height = 2240
80     };
81 
82     windowInfo = {
83         .id = 43,
84         .pid = 433,
85         .displayId = 42,
86         .zOrder = 30.0,
87         .area = {0, 0, 1000, 1200}
88     };
89 }
90 
91 /**
92  * @tc.name: Init sceneSession
93  * @tc.desc: Init sceneSession
94  * @tc.type: FUNC
95  */
InitSceneSession(sptr<SceneSession> & sceneSession,int32_t pid,int windowId,WindowType propertyType)96 void InitSceneSession(sptr<SceneSession> &sceneSession, int32_t pid, int windowId, WindowType propertyType)
97 {
98     sptr<WindowSessionProperty> windowSessionProperty = new (std::nothrow) WindowSessionProperty();
99     ASSERT_NE(windowSessionProperty, nullptr);
100     uint64_t displayId = 1;
101     windowSessionProperty->SetDisplayId(displayId);
102     windowSessionProperty->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
103     windowSessionProperty->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
104     windowSessionProperty->SetWindowType(propertyType);
105     windowSessionProperty->topmost_ = false;
106     windowSessionProperty->SetPersistentId(windowId);
107     sceneSession->SetSessionProperty(windowSessionProperty);
108 
109     WSRect windowRect = {0, 0, 1270, 2700};
110     sceneSession->SetSessionRect(windowRect);
111 
112     sceneSession->SetCallingPid(pid);
113     int32_t uid = 1315;
114     sceneSession->SetCallingUid(uid);
115 }
116 
117 /**
118  * @tc.name: GetWindowInfoWithoutHotArea
119  * @tc.desc: windowInfo without hotAreas information
120  * @tc.type: FUNC
121  */
122 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithoutHotArea, Function | SmallTest | Level2)
123 {
124     SessionInfo info;
125     info.abilityName_ = "TestWithoutHotArea";
126     info.bundleName_ = "TestWithoutHotArea";
127     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
128     ASSERT_NE(sceneSession, nullptr);
129     sptr<WindowSessionProperty> windowSessionProperty = new (std::nothrow) WindowSessionProperty();
130     ASSERT_NE(windowSessionProperty, nullptr);
131     windowSessionProperty->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
132     sceneSession->InitSystemSessionDragEnable(windowSessionProperty);
133     WSRect windowRect = {0, 0, 1270, 2700};
134     sceneSession->SetSessionRect(windowRect);
135     sceneSession->globalRect_ = windowRect;
136     // set hotArea without info
137     std::vector<MMI::Rect> touchHotAreas;
138     std::vector<MMI::Rect> pointerHotAreas;
139     manager_->UpdateHotAreas(sceneSession, touchHotAreas, pointerHotAreas);
140     bool touchHotResult = touchHotAreas[0].x == 0 && touchHotAreas[0].y == 0 &&
141                           touchHotAreas[0].width == 1270 && touchHotAreas[0].height == 2700;
142     ASSERT_NE(touchHotResult, true);
143     bool pointerHotResult = pointerHotAreas[0].x == 0 && pointerHotAreas[0].y == 0 &&
144                             pointerHotAreas[0].width == 1270 && pointerHotAreas[0].height == 2700;
145     ASSERT_NE(pointerHotResult, true);
146 }
147 
148 /**
149  * @tc.name: GetWindowInfoWithHotArea
150  * @tc.desc: windowInfo with hotAreas information
151  * @tc.type: FUNC
152  */
153 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithHotArea, Function | SmallTest | Level2)
154 {
155     SessionInfo info;
156     info.abilityName_ = "TestWithHotArea";
157     info.bundleName_ = "TestWithHotArea";
158     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
159     ASSERT_NE(sceneSession, nullptr);
160     sptr<WindowSessionProperty> windowSessionProperty = new (std::nothrow) WindowSessionProperty();
161     ASSERT_NE(windowSessionProperty, nullptr);
162     windowSessionProperty->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
163     Rect rect = {0, 0, 300, 500};
164     std::vector<Rect> rects;
165     rects.emplace_back(rect);
166     // set touchHotArea and pointerHotArea info
167     windowSessionProperty->SetTouchHotAreas(rects);
168     sceneSession->InitSystemSessionDragEnable(windowSessionProperty);
169     WSRect windowRect = {0, 0, 1270, 2700};
170     sceneSession->SetSessionRect(windowRect);
171     std::vector<MMI::Rect> touchHotAreas;
172     std::vector<MMI::Rect> pointerHotAreas;
173     manager_->UpdateHotAreas(sceneSession, touchHotAreas, pointerHotAreas);
174     bool touchHotResult = touchHotAreas[0].x == 0 && touchHotAreas[0].y == 0 &&
175                           touchHotAreas[0].width == 300 && touchHotAreas[0].height == 500;
176     ASSERT_NE(touchHotResult, true);
177     bool pointerHotResult = pointerHotAreas[0].x == 0 && pointerHotAreas[0].y == 0 &&
178                             pointerHotAreas[0].width == 300 && pointerHotAreas[0].height == 500;
179     ASSERT_NE(pointerHotResult, true);
180 }
181 
182 /**
183  * @tc.name: GetWindowInfoWithWindowTypeDialog
184  * @tc.desc: windowInfo with windowType dialog
185  * @tc.type: FUNC
186  */
187 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithWindowTypeDialog, Function | SmallTest | Level2)
188 {
189     // init main window info
190     SessionInfo mainWindowInfo;
191     mainWindowInfo.abilityName_ = "TestMainWithType";
192     mainWindowInfo.bundleName_ = "TestMainWithType";
193     int32_t mainWindowId = 30;
194     sptr<SceneSession> sceneSessionMainWindow = new (std::nothrow) SceneSession(mainWindowInfo, nullptr);
195     ASSERT_NE(sceneSessionMainWindow, nullptr);
196     sceneSessionMainWindow->zOrder_ = 55.0f;
197     sceneSessionMainWindow->persistentId_ = mainWindowId;
198     sceneSessionMainWindow->isVisible_ = true;
199     int32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
200     sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
201     int32_t mainWindowPid = 50;
202     InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
203     // init sub window with window type dialog
204     SessionInfo dialogWindowInfo;
205     dialogWindowInfo.abilityName_ = "TestDialogWithType";
206     dialogWindowInfo.bundleName_ = "TestDialogWithType";
207     int32_t dialogWindowId = 31;
208     sptr<SceneSession> sceneSessionDialogWindow = new (std::nothrow) SceneSession(dialogWindowInfo, nullptr);
209     ASSERT_NE(sceneSessionDialogWindow, nullptr);
210     sceneSessionDialogWindow->zOrder_ = 56.0f;
211     sceneSessionDialogWindow->persistentId_ = dialogWindowId;
212     sceneSessionDialogWindow->isVisible_ = true;
213     uint32_t flags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_IS_MODAL);
214     sceneSessionDialogWindow->property_->SetWindowFlags(flags);
215     int32_t dialogWindowPid = 51;
216     InitSceneSession(sceneSessionDialogWindow, dialogWindowPid, dialogWindowId, WindowType::WINDOW_TYPE_DIALOG);
217     sceneSessionDialogWindow->SetParentSession(sceneSessionMainWindow);
218     std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
219     retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
220     retSceneSessionMap.insert(std::make_pair(dialogWindowPid, sceneSessionDialogWindow));
221     ssm_->sceneSessionMap_ = retSceneSessionMap;
222     auto [windowInfoList, pixelMapList] = manager_->GetFullWindowInfoList();
223     ASSERT_EQ(windowInfoList.size(), 2);
224     bool windowTypeDialogResult = false;
225     for (MMI::WindowInfo windowInfo : windowInfoList) {
226         if (windowInfo.id == mainWindowId && windowInfo.agentWindowId == dialogWindowId &&
227             windowInfo.pid == dialogWindowPid) {
228             windowTypeDialogResult = true;
229         }
230     }
231     ASSERT_EQ(windowTypeDialogResult, true);
232 }
233 
234 /**
235  * @tc.name: GetWindowInfoWithWindowTypeAppSub
236  * @tc.desc: windowInfo with window_Type_app_sub
237  * @tc.type: FUNC
238  */
239 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithWindowTypeAppSub, Function | SmallTest | Level2)
240 {
241     // init main window info
242     SessionInfo mainWindowInfo;
243     mainWindowInfo.abilityName_ = "TestMainWithType";
244     mainWindowInfo.bundleName_ = "TestMainWithType";
245     int32_t mainWindowId = 32;
246     sptr<SceneSession> sceneSessionMainWindow = new (std::nothrow) SceneSession(mainWindowInfo, nullptr);
247     ASSERT_NE(sceneSessionMainWindow, nullptr);
248     sceneSessionMainWindow->persistentId_ = mainWindowId;
249     sceneSessionMainWindow->isVisible_ = true;
250     int32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
251     sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
252     int32_t mainWindowPid = 52;
253     InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
254     // init sub window with window type float
255     SessionInfo subWindowInfo;
256     subWindowInfo.abilityName_ = "TestSubWithType";
257     subWindowInfo.bundleName_ = "TestSubWithType";
258     int32_t subWindowId = 33;
259     sptr<SceneSession> sceneSessionSubWindow = new (std::nothrow) SceneSession(subWindowInfo, nullptr);
260     ASSERT_NE(sceneSessionSubWindow, nullptr);
261     sceneSessionSubWindow->persistentId_ = subWindowId;
262     sceneSessionSubWindow->isVisible_ = true;
263     uint32_t flags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_IS_MODAL);
264     sceneSessionSubWindow->property_->SetWindowFlags(flags);
265     int32_t subWindowPid = 53;
266     InitSceneSession(sceneSessionSubWindow, subWindowPid, subWindowId, WindowType::WINDOW_TYPE_FLOAT);
267     sceneSessionSubWindow->SetParentSession(sceneSessionMainWindow);
268     std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
269     retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
270     retSceneSessionMap.insert(std::make_pair(subWindowPid, sceneSessionSubWindow));
271     ssm_->sceneSessionMap_ = retSceneSessionMap;
272     auto [windowInfoList, pixelMapList] = manager_->GetFullWindowInfoList();
273     ASSERT_EQ(windowInfoList.size(), 2);
274     bool windowTypeDialogResult = false;
275     for (MMI::WindowInfo windowInfo : windowInfoList) {
276         if (windowInfo.id == mainWindowId && windowInfo.agentWindowId == subWindowId &&
277             windowInfo.pid == subWindowPid) {
278             windowTypeDialogResult = true;
279         }
280     }
281     ASSERT_EQ(windowTypeDialogResult, false);
282 }
283 
284 /**
285  * @tc.name: GetWindowInfoWithTypeKeyboardPanel
286  * @tc.desc: windowInfo with window_Type_keyboard panel
287  * @tc.type: FUNC
288  */
289 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithTypeKeyboardPanel, Function | SmallTest | Level2)
290 {
291     SessionInfo mainWindowInfo;
292     mainWindowInfo.abilityName_ = "TestMainWithType";
293     mainWindowInfo.bundleName_ = "TestMainWithType";
294     int32_t mainWindowId = 34;
295     sptr<SceneSession> sceneSessionMainWindow = new (std::nothrow) SceneSession(mainWindowInfo, nullptr);
296     ASSERT_NE(sceneSessionMainWindow, nullptr);
297     sceneSessionMainWindow->persistentId_ = mainWindowId;
298     sceneSessionMainWindow->isVisible_ = false;
299     uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
300     sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
301     int32_t mainWindowPid = 54;
302     // init sceneSession with windowType is window_type_keyBoard_panel
303     InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_KEYBOARD_PANEL);
304     std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
305     retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
306     ssm_->sceneSessionMap_ = retSceneSessionMap;
307     std::map<int32_t, sptr<SceneSession>> sceneSessionMap =
308         Rosen::SceneSessionManager::GetInstance().GetSceneSessionMap();
309     int32_t windowInfoSize = sceneSessionMap.size();
310     ASSERT_EQ(windowInfoSize, 0);
311 }
312 
313 /**
314  * @tc.name: GetWindowInfoWithoutParentWindow
315  * @tc.desc: windowInfo without parent window
316  * @tc.type: FUNC
317  */
318 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithoutParentWindow, Function | SmallTest | Level2)
319 {
320     SessionInfo subWindowInfo;
321     subWindowInfo.abilityName_ = "TestSubWithType";
322     subWindowInfo.bundleName_ = "TestSubWithType";
323     int32_t subWindowId = 35;
324     sptr<SceneSession> sceneSessionSubWindow = new (std::nothrow) SceneSession(subWindowInfo, nullptr);
325     ASSERT_NE(sceneSessionSubWindow, nullptr);
326     sceneSessionSubWindow->persistentId_ = subWindowId;
327     sceneSessionSubWindow->isVisible_ = false;
328     uint32_t subFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
329     sceneSessionSubWindow->property_->SetWindowFlags(subFlags);
330     int32_t subWindowPid = 55;
331     InitSceneSession(sceneSessionSubWindow, subWindowPid, subWindowId, WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
332     sceneSessionSubWindow->SetParentSession(nullptr);
333     std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
334     retSceneSessionMap.insert(std::make_pair(subWindowPid, sceneSessionSubWindow));
335     ssm_->sceneSessionMap_ = retSceneSessionMap;
336     std::map<int32_t, sptr<SceneSession>> sceneSessionMap =
337         Rosen::SceneSessionManager::GetInstance().GetSceneSessionMap();
338     int32_t windowInfoSize = sceneSessionMap.size();
339     ASSERT_EQ(windowInfoSize, 0);
340 }
341 
342 /**
343  * @tc.name: GetWindowInfoWithoutParentWindowAndStateActive
344  * @tc.desc: windowInfo without parent window and state active
345  * @tc.type: FUNC
346  */
347 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithoutParentWindowAndStateActive, Function | SmallTest | Level2)
348 {
349     SessionInfo subWindowInfo;
350     subWindowInfo.abilityName_ = "TestSubWithType";
351     subWindowInfo.bundleName_ = "TestSubWithType";
352     int32_t subWindowId = 36;
353     sptr<SceneSession> sceneSessionSubWindow = new (std::nothrow) SceneSession(subWindowInfo, nullptr);
354     ASSERT_NE(sceneSessionSubWindow, nullptr);
355     sceneSessionSubWindow->persistentId_ = subWindowId;
356     sceneSessionSubWindow->isVisible_ = false;
357     uint32_t subFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
358     sceneSessionSubWindow->property_->SetWindowFlags(subFlags);
359     int32_t subWindowPid = 56;
360     InitSceneSession(sceneSessionSubWindow, subWindowPid, subWindowId, WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
361     sceneSessionSubWindow->SetParentSession(nullptr);
362     sceneSessionSubWindow->SetSessionState(SessionState::STATE_ACTIVE);
363     std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
364     retSceneSessionMap.insert(std::make_pair(subWindowPid, sceneSessionSubWindow));
365     ssm_->sceneSessionMap_ = retSceneSessionMap;
366     std::map<int32_t, sptr<SceneSession>> sceneSessionMap =
367         Rosen::SceneSessionManager::GetInstance().GetSceneSessionMap();
368     int32_t windowInfoSize = sceneSessionMap.size();
369     ASSERT_EQ(windowInfoSize, 0);
370 }
371 
372 /**
373  * @tc.name: GetWindowInfoWithNotSystemTouchable
374  * @tc.desc: windowInfo with systemtouchable is false
375  * @tc.type: FUNC
376  */
377 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithNotSystemTouchable, Function | SmallTest | Level2)
378 {
379     SessionInfo mainWindowInfo;
380     mainWindowInfo.abilityName_ = "TestMainWithType";
381     mainWindowInfo.bundleName_ = "TestMainWithType";
382     int32_t mainWindowId = 37;
383     sptr<SceneSession> sceneSessionMainWindow = new (std::nothrow) SceneSession(mainWindowInfo, nullptr);
384     ASSERT_NE(sceneSessionMainWindow, nullptr);
385     sceneSessionMainWindow->persistentId_ = mainWindowId;
386     sceneSessionMainWindow->isVisible_ = true;
387     uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
388     sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
389     bool isTouchable = false;
390     // set systemTouchable false;
391     sceneSessionMainWindow->SetSystemTouchable(isTouchable);
392     int32_t mainWindowPid = 57;
393     InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
394     std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
395     retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
396     ssm_->sceneSessionMap_ = retSceneSessionMap;
397     MMI::WindowInfo windowInfo;
398     ScreenId screenId = 37;
399     ScreenSessionConfig config;
400     sptr<ScreenSession> screenSession = new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
401     ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(screenId, screenSession));
402     manager_->UpdateWindowFlags(screenId, sceneSessionMainWindow, windowInfo);
403     bool windowFlagResult = false;
404     if (windowInfo.flags == 1) {
405         windowFlagResult = true;
406     }
407     ASSERT_EQ(windowFlagResult, true);
408 }
409 
410 /**
411  * @tc.name: GetWindowInfoWithNotIsTouchEnable
412  * @tc.desc: windowInfo with isTouchenable is false
413  * @tc.type: FUNC
414  */
415 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithNotIsTouchEnable, Function | SmallTest | Level2)
416 {
417     SessionInfo mainWindowInfo;
418     mainWindowInfo.abilityName_ = "TestMainWithType";
419     mainWindowInfo.bundleName_ = "TestMainWithType";
420     int32_t mainWindowId = 38;
421     sptr<SceneSession> sceneSessionMainWindow = new (std::nothrow) SceneSession(mainWindowInfo, nullptr);
422     ASSERT_NE(sceneSessionMainWindow, nullptr);
423     sceneSessionMainWindow->persistentId_ = mainWindowId;
424     sceneSessionMainWindow->isVisible_ = true;
425     uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
426     sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
427     bool isTouchable = true;
428     sceneSessionMainWindow->SetSystemTouchable(isTouchable);
429     int32_t mainWindowPid = 58;
430     InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
431     std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
432     retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
433     ssm_->sceneSessionMap_ = retSceneSessionMap;
434     MMI::WindowInfo windowInfo;
435     ScreenId screenId = 38;
436     ScreenSessionConfig config;
437     sptr<ScreenSession> screenSession = new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
438     // set screenSession touchenable_ true
439     screenSession->touchEnabled_.store(false);
440     ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
441     ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(screenId, screenSession));
442     manager_->UpdateWindowFlags(screenId, sceneSessionMainWindow, windowInfo);
443     bool windowFlagResult = false;
444     if (windowInfo.flags == MMI::WindowInfo::FLAG_BIT_UNTOUCHABLE) {
445         windowFlagResult = true;
446     }
447     ASSERT_EQ(windowFlagResult, true);
448 }
449 
450 /**
451  * @tc.name: GetWindowInfoWithNotIsForceTouchEnable
452  * @tc.desc: windowInfo with isForeTouchenable is false
453  * @tc.type: FUNC
454  */
455 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithNotIsForceTouchEnable, Function | SmallTest | Level2)
456 {
457     SessionInfo mainWindowInfo;
458     mainWindowInfo.abilityName_ = "TestMainWithType";
459     mainWindowInfo.bundleName_ = "TestMainWithType";
460     int32_t mainWindowId = 39;
461     sptr<SceneSession> sceneSessionMainWindow = new (std::nothrow) SceneSession(mainWindowInfo, nullptr);
462     ASSERT_NE(sceneSessionMainWindow, nullptr);
463     sceneSessionMainWindow->persistentId_ = mainWindowId;
464     sceneSessionMainWindow->isVisible_ = true;
465     uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
466     sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
467     // set isForceTouchable false
468     bool isForceTouchable = false;
469     sceneSessionMainWindow->SetForceTouchable(isForceTouchable);
470     int32_t mainWindowPid = 59;
471     InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
472     std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
473     retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
474     ssm_->sceneSessionMap_ = retSceneSessionMap;
475     MMI::WindowInfo windowInfo;
476     ScreenId screenId = 39;
477     ScreenSessionConfig config;
478     sptr<ScreenSession> screenSession = new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
479     screenSession->touchEnabled_.store(true);
480     ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(screenId, screenSession));
481     manager_->UpdateWindowFlags(screenId, sceneSessionMainWindow, windowInfo);
482     bool windowFlagResult = false;
483     if (windowInfo.flags == 1) {
484         windowFlagResult = true;
485     }
486     ASSERT_EQ(windowFlagResult, true);
487 }
488 
489 /**
490  * @tc.name: GetWindowInfoWithNotForegroundInteractiveStatus
491  * @tc.desc: windowInfo with foregroundInteractiveStatus_ is false
492  * @tc.type: FUNC
493  */
494 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithNotForegroundInteractiveStatus, Function | SmallTest | Level2)
495 {
496     SessionInfo mainWindowInfo;
497     mainWindowInfo.abilityName_ = "TestMainWithType";
498     mainWindowInfo.bundleName_ = "TestMainWithType";
499     int32_t mainWindowId = 40;
500     sptr<SceneSession> sceneSessionMainWindow = new (std::nothrow) SceneSession(mainWindowInfo, nullptr);
501     ASSERT_NE(sceneSessionMainWindow, nullptr);
502     sceneSessionMainWindow->persistentId_ = mainWindowId;
503     sceneSessionMainWindow->isVisible_ = true;
504     // set foregroundInterativeStatus_ false
505     sceneSessionMainWindow->foregroundInteractiveStatus_.store(false);
506     uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
507     sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
508     int32_t mainWindowPid = 60;
509     InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
510     std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
511     retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
512     ssm_->sceneSessionMap_ = retSceneSessionMap;
513     MMI::WindowInfo windowInfo;
514     ScreenId screenId = 40;
515     ScreenSessionConfig config;
516     sptr<ScreenSession> screenSession = new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
517     ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(screenId, screenSession));
518     manager_->UpdateWindowFlags(screenId, sceneSessionMainWindow, windowInfo);
519     bool windowFlagResult = false;
520     if (windowInfo.flags == 1) {
521         windowFlagResult = true;
522     }
523     ASSERT_EQ(windowFlagResult, true);
524 }
525 
526 /**
527  * @tc.name: GetWindowInfoWithNotPropertyTouchable
528  * @tc.desc: windowInfo with property touchable false
529  * @tc.type: FUNC
530  */
531 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithNotPropertyTouchable, Function | SmallTest | Level2)
532 {
533     SessionInfo mainWindowInfo;
534     mainWindowInfo.abilityName_ = "TestMainWithType";
535     mainWindowInfo.bundleName_ = "TestMainWithType";
536     int32_t mainWindowId = 41;
537     sptr<SceneSession> sceneSessionMainWindow = new (std::nothrow) SceneSession(mainWindowInfo, nullptr);
538     ASSERT_NE(sceneSessionMainWindow, nullptr);
539     sceneSessionMainWindow->persistentId_ = mainWindowId;
540     sceneSessionMainWindow->foregroundInteractiveStatus_.store(false);
541     uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
542     sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
543     // set property_.touchEnable_ false
544     sceneSessionMainWindow->property_->touchable_ = false;
545     int32_t mainWindowPid = 61;
546     InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
547     std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
548     retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
549     ssm_->sceneSessionMap_ = retSceneSessionMap;
550     MMI::WindowInfo windowInfo;
551     ScreenId screenId = 41;
552     ScreenSessionConfig config;
553     sptr<ScreenSession> screenSession = new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
554     ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(screenId, screenSession));
555     manager_->UpdateWindowFlags(screenId, sceneSessionMainWindow, windowInfo);
556     bool windowFlagResult = false;
557     if (windowInfo.flags == 1) {
558         windowFlagResult = true;
559     }
560     ASSERT_EQ(windowFlagResult, true);
561 }
562 
563 /**
564  * @tc.name: GetWindowInfoWithSameInfo
565  * @tc.desc: windowInfo with same displayInfos and windowInfos
566  * @tc.type: FUNC
567  */
568 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithSameInfo, Function | SmallTest | Level2)
569 {
570     MMI::DisplayInfo lastDisplayedInfo;
571     MMI::WindowInfo lastWindowInfo;
572     InitSessionInfo(lastDisplayedInfo, lastWindowInfo);
573     int32_t focusedSession = 42;
574     sim_->focusedSessionId_ = focusedSession;
575     int32_t lastFocusedSession = 42;
576     sim_->lastFocusId_ = lastFocusedSession;
577     std::vector<MMI::DisplayInfo> lastDisplayInfos;
578     std::vector<MMI::WindowInfo> lastWindowInfoList;
579     lastDisplayInfos.emplace_back(lastDisplayedInfo);
580     lastWindowInfoList.emplace_back(lastWindowInfo);
581     sim_->lastDisplayInfos_ = lastDisplayInfos;
582     sim_->lastWindowInfoList_ = lastWindowInfoList;
583     MMI::DisplayInfo currDisplayedInfo;
584     MMI::WindowInfo currWindowInfo;
585     InitSessionInfo(currDisplayedInfo, currWindowInfo);
586     std::vector<MMI::DisplayInfo> currDisplayInfos;
587     std::vector<MMI::WindowInfo> currWindowInfoList;
588     currDisplayInfos.emplace_back(currDisplayedInfo);
589     currWindowInfoList.emplace_back(currWindowInfo);
590     ssm_->focusedSessionId_ = focusedSession;
591     bool checkNeedUpdateFlag = true;
592     // check the same information
593     checkNeedUpdateFlag = sim_->CheckNeedUpdate(currDisplayInfos, currWindowInfoList);
594     ASSERT_EQ(checkNeedUpdateFlag, false);
595 }
596 
597 /**
598  * @tc.name: GetWindowInfoWithPidDiff
599  * @tc.desc: windowInfo with different pid
600  * @tc.type: FUNC
601  */
602 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithPidDiff, Function | SmallTest | Level2)
603 {
604     MMI::DisplayInfo lastDisplayedInfo;
605     MMI::WindowInfo lastWindowInfo;
606     InitSessionInfo(lastDisplayedInfo, lastWindowInfo);
607     int32_t focusedSession = 43;
608     sim_->focusedSessionId_ = focusedSession;
609     int32_t lastFocusedSession = 43;
610     sim_->lastFocusId_ = lastFocusedSession;
611     std::vector<MMI::DisplayInfo> lastDisplayInfos;
612     std::vector<MMI::WindowInfo> lastWindowInfoList;
613     lastDisplayInfos.emplace_back(lastDisplayedInfo);
614     lastWindowInfoList.emplace_back(lastWindowInfo);
615     sim_->lastDisplayInfos_ = lastDisplayInfos;
616     sim_->lastWindowInfoList_ = lastWindowInfoList;
617     MMI::DisplayInfo currDisplayedInfo;
618     MMI::WindowInfo currWindowInfo;
619     InitSessionInfo(currDisplayedInfo, currWindowInfo);
620     // set different pid number
621     currWindowInfo.pid = 434;
622     std::vector<MMI::DisplayInfo> currDisplayInfos;
623     std::vector<MMI::WindowInfo> currWindowInfoList;
624     currDisplayInfos.emplace_back(currDisplayedInfo);
625     currWindowInfoList.emplace_back(currWindowInfo);
626     ssm_->focusedSessionId_ = focusedSession;
627     bool checkNeedUpdateFlag = false;
628     checkNeedUpdateFlag = sim_->CheckNeedUpdate(currDisplayInfos, currWindowInfoList);
629     ASSERT_EQ(checkNeedUpdateFlag, true);
630 }
631 
632 /**
633  * @tc.name: GetWindowInfoWithAreaDiff
634  * @tc.desc: windowInfo with different area
635  * @tc.type: FUNC
636  */
637 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithAreaDiff, Function | SmallTest | Level2)
638 {
639     MMI::DisplayInfo lastDisplayedInfo;
640     MMI::WindowInfo lastWindowInfo;
641     InitSessionInfo(lastDisplayedInfo, lastWindowInfo);
642     int32_t focusedSession = 44;
643     sim_->focusedSessionId_ = focusedSession;
644     int32_t lastFocusedSession = 44;
645     sim_->lastFocusId_ = lastFocusedSession;
646     std::vector<MMI::DisplayInfo> lastDisplayInfos;
647     std::vector<MMI::WindowInfo> lastWindowInfoList;
648     lastDisplayInfos.emplace_back(lastDisplayedInfo);
649     lastWindowInfoList.emplace_back(lastWindowInfo);
650     sim_->lastDisplayInfos_ = lastDisplayInfos;
651     sim_->lastWindowInfoList_ = lastWindowInfoList;
652     MMI::DisplayInfo currDisplayedInfo;
653     MMI::WindowInfo currWindowInfo;
654     InitSessionInfo(currDisplayedInfo, currWindowInfo);
655     // set different area number
656     currWindowInfo.area = {0, 0, 500, 600};
657     std::vector<MMI::DisplayInfo> currDisplayInfos;
658     std::vector<MMI::WindowInfo> currWindowInfoList;
659     currDisplayInfos.emplace_back(currDisplayedInfo);
660     currWindowInfoList.emplace_back(currWindowInfo);
661     ssm_->focusedSessionId_ = focusedSession;
662     bool checkNeedUpdateFlag = false;
663     checkNeedUpdateFlag = sim_->CheckNeedUpdate(currDisplayInfos, currWindowInfoList);
664     ASSERT_EQ(checkNeedUpdateFlag, true);
665 }
666 
667 /**
668  * @tc.name: GetWindowInfoWithzOrderDiff
669  * @tc.desc: windowInfo with different zOrder
670  * @tc.type: FUNC
671  */
672 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithzOrderDiff, Function | SmallTest | Level2)
673 {
674     MMI::DisplayInfo lastDisplayedInfo;
675     MMI::WindowInfo lastWindowInfo;
676     InitSessionInfo(lastDisplayedInfo, lastWindowInfo);
677     int32_t focusedSession = 45;
678     sim_->focusedSessionId_ = focusedSession;
679     int32_t lastFocusedSession = 45;
680     sim_->lastFocusId_ = lastFocusedSession;
681     std::vector<MMI::DisplayInfo> lastDisplayInfos;
682     std::vector<MMI::WindowInfo> lastWindowInfoList;
683     lastDisplayInfos.emplace_back(lastDisplayedInfo);
684     lastWindowInfoList.emplace_back(lastWindowInfo);
685     sim_->lastDisplayInfos_ = lastDisplayInfos;
686     sim_->lastWindowInfoList_ = lastWindowInfoList;
687     MMI::DisplayInfo currDisplayedInfo;
688     MMI::WindowInfo currWindowInfo;
689     InitSessionInfo(currDisplayedInfo, currWindowInfo);
690     // set different zOrder number
691     currWindowInfo.zOrder = 40.0;
692     std::vector<MMI::DisplayInfo> currDisplayInfos;
693     std::vector<MMI::WindowInfo> currWindowInfoList;
694     currDisplayInfos.emplace_back(currDisplayedInfo);
695     currWindowInfoList.emplace_back(currWindowInfo);
696     ssm_->focusedSessionId_ = focusedSession;
697     bool checkNeedUpdateFlag = false;
698     checkNeedUpdateFlag = sim_->CheckNeedUpdate(currDisplayInfos, currWindowInfoList);
699     ASSERT_EQ(checkNeedUpdateFlag, true);
700 }
701 
702 } // namespace
703 } // namespace Rosen
704 } // namespace OHOS