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 = sptr<SceneSession>::MakeSptr(info, nullptr);
67 if (result != nullptr) {
68 result->property_ = sptr<WindowSessionProperty>::MakeSptr();
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
WallPaperTest(sptr<SceneSessionManager> ssm_)267 void WallPaperTest(sptr<SceneSessionManager> ssm_)
268 {
269 int32_t order = 100;
270 int32_t id = 1;
271 auto sceneSession1 = GetSceneSession("wallpaperTest");
272 ASSERT_NE(sceneSession1, nullptr);
273 sceneSession1->property_->SetWindowType(WindowType::WINDOW_TYPE_WALLPAPER);
274 sceneSession1->zOrder_ = order;
275 sceneSession1->persistentId_ = id;
276 sceneSession1->isVisible_ = true;
277 sceneSession1->state_ = SessionState::STATE_ACTIVE;
278 ssm_->sceneSessionMap_.insert({ sceneSession1->GetPersistentId(), sceneSession1 });
279 AnomalyDetection::SceneZOrderCheckProcess();
280 ssm_->sceneSessionMap_.clear();
281 }
282
283 /**
284 * @tc.name: SceneZOrderCheckProcess
285 * @tc.desc: check func SceneZOrderCheckProcess
286 * @tc.type: FUNC
287 */
288 HWTEST_F(AnomalyDetectionTest, SceneZOrderCheckProcess, TestSize.Level1)
289 {
290 GTEST_LOG_(INFO) << "AnomalyDetectionTest: SceneZOrderCheckProcess start";
291 int ret = 0;
292 AnomalyDetection::SceneZOrderCheckProcess();
293
294 SessionVisibleTest(ssm_);
295 ZeroOrderTest(ssm_);
296 EQOrderTest(ssm_);
297 WindowTypeTest(ssm_);
298 SubWindowTest(ssm_);
299 KeyGUARDTest(ssm_);
300 IsShowWhenLockedTest(ssm_);
301 WallPaperTest(ssm_);
302 ASSERT_EQ(ret, 0);
303 GTEST_LOG_(INFO) << "AnomalyDetectionTest: SceneZOrderCheckProcess end";
304 }
305
FocusNullTest(sptr<SceneSessionManager> ssm_)306 void FocusNullTest(sptr<SceneSessionManager> ssm_)
307 {
308 ssm_->sceneSessionMap_.insert({0, nullptr});
309 AnomalyDetection::FocusCheckProcess(0, 1);
310 ssm_->sceneSessionMap_.clear();
311 }
312
IsFocusedTest(sptr<SceneSessionManager> ssm_)313 void IsFocusedTest(sptr<SceneSessionManager> ssm_)
314 {
315 auto sceneSession = GetSceneSession("IsFocusedTest");
316 ASSERT_NE(sceneSession, nullptr);
317 sceneSession->isFocused_ = true;
318 ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
319 AnomalyDetection::FocusCheckProcess(0, 1);
320
321 ssm_->sceneSessionMap_.clear();
322 }
323
324 /**
325 * @tc.name: FocusCheckProcess
326 * @tc.desc: check func FocusCheckProcess
327 * @tc.type: FUNC
328 */
329 HWTEST_F(AnomalyDetectionTest, FocusCheckProcess, TestSize.Level1)
330 {
331 GTEST_LOG_(INFO) << "AnomalyDetectionTest: FocusCheckProcess start";
332 int ret = 0;
333
334 AnomalyDetection::FocusCheckProcess(0, INVALID_SESSION_ID);
335
336 FocusNullTest(ssm_);
337 IsFocusedTest(ssm_);
338
339 ASSERT_EQ(ret, 0);
340 GTEST_LOG_(INFO) << "AnomalyDetectionTest: FocusCheckProcess end";
341 }
342
343 }
344 }
345 }