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 
16 #include "anomaly_detection.h"
17 #include <gtest/gtest.h>
18 #include "session_manager/include/scene_session_manager.h"
19 #include "interfaces/include/ws_common.h"
20 #include "session/host/include/session.h"
21 #include "session/host/include/scene_session.h"
22 #include "common/include/window_session_property.h"
23 
24 
25 using namespace testing;
26 using namespace testing::ext;
27 
28 namespace OHOS {
29 namespace Rosen {
30 class AnomalyDetectionTest : public testing::Test {
31 public:
32     static void SetUpTestCase();
33     static void TearDownTestCase();
34     void SetUp() override;
35     void TearDown() override;
36     static sptr<SceneSessionManager> ssm_;
37 };
38 
39 sptr<SceneSessionManager> AnomalyDetectionTest::ssm_ = nullptr;
40 
SetUpTestCase()41 void AnomalyDetectionTest::SetUpTestCase()
42 {
43     ssm_ = &SceneSessionManager::GetInstance();
44     ssm_->sceneSessionMap_.clear();
45 }
46 
TearDownTestCase()47 void AnomalyDetectionTest::TearDownTestCase()
48 {
49     ssm_ = nullptr;
50 }
51 
SetUp()52 void AnomalyDetectionTest::SetUp()
53 {
54 }
55 
TearDown()56 void AnomalyDetectionTest::TearDown()
57 {
58 }
59 
60 namespace {
GetSceneSession(std::string name)61 sptr<SceneSession> GetSceneSession(std::string name)
62 {
63     SessionInfo info;
64     info.abilityName_ = name;
65     info.bundleName_ = name;
66     auto result = new (std::nothrow) SceneSession(info, nullptr);
67     if (result != nullptr) {
68         result->property_ = new (std::nothrow) WindowSessionProperty();
69         if (result->property_ == nullptr) {
70             return nullptr;
71         }
72     }
73 
74     return result;
75 }
76 
SessionVisibleTest(sptr<SceneSessionManager> ssm_)77 void SessionVisibleTest(sptr<SceneSessionManager> ssm_)
78 {
79     ssm_->sceneSessionMap_.insert({0, nullptr});
80     AnomalyDetection::SceneZOrderCheckProcess();
81     ssm_->sceneSessionMap_.clear();
82 
83     auto sceneSession = GetSceneSession("SessionVisibleTest");
84     ASSERT_NE(sceneSession, nullptr);
85     sceneSession->isVisible_ = false;
86     sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
87     ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
88     AnomalyDetection::SceneZOrderCheckProcess();
89     ssm_->sceneSessionMap_.clear();
90 }
91 
ZeroOrderTest(sptr<SceneSessionManager> ssm_)92 void ZeroOrderTest(sptr<SceneSessionManager> ssm_)
93 {
94     auto sceneSession = GetSceneSession("ZeroOrderTest");
95     ASSERT_NE(sceneSession, nullptr);
96     sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
97     sceneSession->isVisible_ = true;
98     sceneSession->state_ = SessionState::STATE_ACTIVE;
99     sceneSession->zOrder_ = 0;
100     ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
101     AnomalyDetection::SceneZOrderCheckProcess();
102     ssm_->sceneSessionMap_.clear();
103 }
104 
EQOrderTest(sptr<SceneSessionManager> ssm_)105 void EQOrderTest(sptr<SceneSessionManager> ssm_)
106 {
107     int32_t sameOrder = 1;
108     int32_t persistentId1 = 1;
109 
110     auto sceneSession1 = GetSceneSession("EQOrderTest1");
111     ASSERT_NE(sceneSession1, nullptr);
112     sceneSession1->isVisible_ = true;
113     sceneSession1->state_ = SessionState::STATE_ACTIVE;
114     sceneSession1->sessionInfo_.persistentId_ = persistentId1;
115     sceneSession1->zOrder_ = sameOrder;
116     sceneSession1->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
117     ssm_->sceneSessionMap_.insert({sceneSession1->GetPersistentId(), sceneSession1});
118 
119     int32_t persistentId2 = 2;
120     auto sceneSession2 = GetSceneSession("EQOrderTest2");
121     ASSERT_NE(sceneSession2, nullptr);
122     sceneSession2->isVisible_ = true;
123     sceneSession2->state_ = SessionState::STATE_ACTIVE;
124     sceneSession2->sessionInfo_.persistentId_ = persistentId2;
125     sceneSession2->zOrder_ = sameOrder;
126     sceneSession2->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
127     ssm_->sceneSessionMap_.insert({sceneSession2->GetPersistentId(), sceneSession2});
128 
129     AnomalyDetection::SceneZOrderCheckProcess();
130     ssm_->sceneSessionMap_.clear();
131 }
132 
WindowTypeTest(sptr<SceneSessionManager> ssm_)133 void WindowTypeTest(sptr<SceneSessionManager> ssm_)
134 {
135     int32_t order = 1;
136     int32_t callingId = 1;
137     int32_t persistentId = 2;
138     auto sceneSession = GetSceneSession("WindowTypeTest");
139     ASSERT_NE(sceneSession, nullptr);
140     sceneSession->persistentId_ = persistentId;
141     sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
142     sceneSession->isVisible_ = true;
143     sceneSession->state_ = SessionState::STATE_ACTIVE;
144     sceneSession->zOrder_ = order;
145     sceneSession->property_->SetCallingSessionId(callingId);
146     ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
147     AnomalyDetection::SceneZOrderCheckProcess();
148 
149     auto callingSession = GetSceneSession("WindowTypeTestCalling");
150     ASSERT_NE(callingSession, nullptr);
151     callingSession->persistentId_ = callingId;
152     callingSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
153     callingSession->isVisible_ = true;
154     callingSession->state_ = SessionState::STATE_ACTIVE;
155     callingSession->zOrder_ = sceneSession->GetZOrder() + 1;
156     ssm_->sceneSessionMap_.insert({callingSession->GetPersistentId(), callingSession});
157     AnomalyDetection::SceneZOrderCheckProcess();
158 
159     callingSession->zOrder_ = sceneSession->GetZOrder() - 1;
160     AnomalyDetection::SceneZOrderCheckProcess();
161 
162     ssm_->sceneSessionMap_.insert({callingSession->GetPersistentId(), nullptr});
163     AnomalyDetection::SceneZOrderCheckProcess();
164     ssm_->sceneSessionMap_.clear();
165 }
166 
SubWindowTest(sptr<SceneSessionManager> ssm_)167 void SubWindowTest(sptr<SceneSessionManager> ssm_)
168 {
169     int32_t order = 100;
170     int32_t mainId = 1;
171     int32_t persistentId = 2;
172     auto sceneSession = GetSceneSession("SubWindowTest");
173     ASSERT_NE(sceneSession, nullptr);
174     sceneSession->persistentId_ = persistentId;
175     sceneSession->zOrder_ = order;
176     sceneSession->property_->SetCallingSessionId(mainId);
177     sceneSession->isVisible_ = true;
178     sceneSession->state_ = SessionState::STATE_ACTIVE;
179     sceneSession->property_->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
180     ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
181     AnomalyDetection::SceneZOrderCheckProcess();
182 
183     sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
184     AnomalyDetection::SceneZOrderCheckProcess();
185 
186     auto mainSession = GetSceneSession("SubWindowMainTest");
187     ASSERT_NE(mainSession, nullptr);
188     mainSession->persistentId_ = mainId;
189     mainSession->isVisible_ = true;
190     mainSession->state_ = SessionState::STATE_ACTIVE;
191     mainSession->zOrder_ = sceneSession->GetZOrder() + 1;
192     mainSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
193     ssm_->sceneSessionMap_.insert({mainSession->GetPersistentId(), mainSession});
194     AnomalyDetection::SceneZOrderCheckProcess();
195 
196     sceneSession->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
197     AnomalyDetection::SceneZOrderCheckProcess();
198 
199     sceneSession->parentSession_ = nullptr;
200     AnomalyDetection::SceneZOrderCheckProcess();
201 
202     sceneSession->parentSession_ = mainSession;
203     AnomalyDetection::SceneZOrderCheckProcess();
204 
205     mainSession->zOrder_ = sceneSession->GetZOrder() - 1;
206     AnomalyDetection::SceneZOrderCheckProcess();
207 
208     sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
209     AnomalyDetection::SceneZOrderCheckProcess();
210 
211     ssm_->sceneSessionMap_.clear();
212 }
213 
KeyGUARDTest(sptr<SceneSessionManager> ssm_)214 void KeyGUARDTest(sptr<SceneSessionManager> ssm_)
215 {
216     int32_t order = 100;
217     auto sceneSession = GetSceneSession("KeyGUARDTest");
218     ASSERT_NE(sceneSession, nullptr);
219     sceneSession->persistentId_ = 1;
220     sceneSession->zOrder_ = order;
221     sceneSession->isVisible_ = true;
222     sceneSession->state_ = SessionState::STATE_ACTIVE;
223     sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_KEYGUARD);
224     ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
225     AnomalyDetection::SceneZOrderCheckProcess();
226 
227     sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
228     AnomalyDetection::SceneZOrderCheckProcess();
229     ssm_->sceneSessionMap_.clear();
230 }
231 
IsShowWhenLockedTest(sptr<SceneSessionManager> ssm_)232 void IsShowWhenLockedTest(sptr<SceneSessionManager> ssm_)
233 {
234     int32_t order = 100;
235     int32_t id = 1;
236 
237     auto sceneSession1 = GetSceneSession("IsShowWhenLockedTest1");
238     ASSERT_NE(sceneSession1, nullptr);
239     sceneSession1->property_->SetWindowType(WindowType::WINDOW_TYPE_KEYGUARD);
240     sceneSession1->zOrder_ = order--;
241     sceneSession1->persistentId_ = id++;
242     sceneSession1->isVisible_ = true;
243     sceneSession1->state_ = SessionState::STATE_ACTIVE;
244     ssm_->sceneSessionMap_.insert({sceneSession1->GetPersistentId(), sceneSession1});
245 
246     auto sceneSession2 = GetSceneSession("IsShowWhenLockedTest2");
247     ASSERT_NE(sceneSession2, nullptr);
248     sceneSession2->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
249     sceneSession2->isVisible_ = true;
250     sceneSession2->state_ = SessionState::STATE_ACTIVE;
251     sceneSession2->zOrder_ = order--;
252     sceneSession2->persistentId_ = id++;
253     ssm_->sceneSessionMap_.insert({sceneSession2->GetPersistentId(), sceneSession2});
254     AnomalyDetection::SceneZOrderCheckProcess();
255 
256     sceneSession2->property_->AddWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
257     AnomalyDetection::SceneZOrderCheckProcess();
258 
259     sceneSession2->property_->AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
260     AnomalyDetection::SceneZOrderCheckProcess();
261 
262     sceneSession2->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
263     AnomalyDetection::SceneZOrderCheckProcess();
264     ssm_->sceneSessionMap_.clear();
265 }
266 
267 /**
268 * @tc.name: SceneZOrderCheckProcess
269 * @tc.desc: check func SceneZOrderCheckProcess
270 * @tc.type: FUNC
271 */
272 HWTEST_F(AnomalyDetectionTest, SceneZOrderCheckProcess, Function | SmallTest | Level1)
273 {
274     GTEST_LOG_(INFO) << "AnomalyDetectionTest: SceneZOrderCheckProcess start";
275     int ret = 0;
276     AnomalyDetection::SceneZOrderCheckProcess();
277 
278     SessionVisibleTest(ssm_);
279     ZeroOrderTest(ssm_);
280     EQOrderTest(ssm_);
281     WindowTypeTest(ssm_);
282     SubWindowTest(ssm_);
283     KeyGUARDTest(ssm_);
284     IsShowWhenLockedTest(ssm_);
285     ASSERT_EQ(ret, 0);
286     GTEST_LOG_(INFO) << "AnomalyDetectionTest: SceneZOrderCheckProcess end";
287 }
288 
FocusNullTest(sptr<SceneSessionManager> ssm_)289 void FocusNullTest(sptr<SceneSessionManager> ssm_)
290 {
291     ssm_->sceneSessionMap_.insert({0, nullptr});
292     AnomalyDetection::FocusCheckProcess(0, 1);
293     ssm_->sceneSessionMap_.clear();
294 }
295 
IsFocusedTest(sptr<SceneSessionManager> ssm_)296 void IsFocusedTest(sptr<SceneSessionManager> ssm_)
297 {
298     auto sceneSession = GetSceneSession("IsFocusedTest");
299     ASSERT_NE(sceneSession, nullptr);
300     sceneSession->isFocused_ = true;
301     ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
302     AnomalyDetection::FocusCheckProcess(0, 1);
303 
304     ssm_->sceneSessionMap_.clear();
305 }
306 
307 /**
308 * @tc.name: FocusCheckProcess
309 * @tc.desc: check func FocusCheckProcess
310 * @tc.type: FUNC
311 */
312 HWTEST_F(AnomalyDetectionTest, FocusCheckProcess, Function | SmallTest | Level1)
313 {
314     GTEST_LOG_(INFO) << "AnomalyDetectionTest: FocusCheckProcess start";
315     int ret = 0;
316 
317     AnomalyDetection::FocusCheckProcess(0, INVALID_SESSION_ID);
318 
319     FocusNullTest(ssm_);
320     IsFocusedTest(ssm_);
321 
322     ASSERT_EQ(ret, 0);
323     GTEST_LOG_(INFO) << "AnomalyDetectionTest: FocusCheckProcess end";
324 }
325 
326 }
327 }
328 }