1 /*
2 * Copyright (c) 2021 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 //gtest
17 #include <gtest/gtest.h>
18
19 #include "ability_context_impl.h"
20
21 #include "mock_session.h"
22 #include "window_scene_session_impl.h"
23 #include "window_test_utils.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
30 using Utils = WindowTestUtils;
31
32 class WindowStatusChangeTest : public testing::Test {
33 public:
34 void SetUp() override;
35 void TearDown() override;
36
37 private:
38 static constexpr uint32_t TEST_SLEEP_S = 1; // test sleep time
39 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
40 };
41
SetUp()42 void WindowStatusChangeTest::SetUp()
43 {
44 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
45 }
46
TearDown()47 void WindowStatusChangeTest::TearDown()
48 {
49 abilityContext_ = nullptr;
50 }
51
52 namespace {
53 /**
54 * @tc.name: ChangeWindowStatus01
55 * @tc.desc: one FLOATING MainWindow, maximize ImmersiveMode
56 * @tc.type: FUNC
57 */
58 HWTEST_F(WindowStatusChangeTest, ChangeWindowStatus01, Function | MediumTest | Level0)
59 {
60 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
61 option->SetWindowName("Window1_1");
62 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
63 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
64
65 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
66
67 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
68 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
69 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
70
71 window->property_->SetPersistentId(10011);
72 window->hostSession_ = session;
73 window->state_ = WindowState::STATE_CREATED;
74 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
75 ASSERT_EQ(WindowState::STATE_CREATED, window->GetWindowState());
76
77 ASSERT_EQ(WMError::WM_OK, window->Show());
78 sleep(TEST_SLEEP_S);
79 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
80
81 ASSERT_EQ(WMError::WM_OK, window->Maximize());
82 ASSERT_EQ(false, window->GetImmersiveModeEnabledState());
83
84 ASSERT_EQ(WMError::WM_OK, window->Maximize(MaximizePresentation::ENTER_IMMERSIVE));
85 ASSERT_EQ(true, window->GetImmersiveModeEnabledState());
86
87 ASSERT_EQ(WMError::WM_OK, window->Maximize(MaximizePresentation::EXIT_IMMERSIVE));
88 ASSERT_EQ(false, window->GetImmersiveModeEnabledState());
89
90 window->Destroy(true, true);
91 }
92
93 /**
94 * @tc.name: ChangeWindowStatus02
95 * @tc.desc: one FLOATING MainWindow, maximize and recover
96 * @tc.type: FUNC
97 */
98 HWTEST_F(WindowStatusChangeTest, ChangeWindowStatus02, Function | MediumTest | Level0)
99 {
100 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
101 option->SetWindowName("Window1_2");
102 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
103 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
104
105 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
106
107 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
108 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
109 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
110
111 window->property_->SetPersistentId(10012);
112 window->hostSession_ = session;
113 window->state_ = WindowState::STATE_CREATED;
114 ASSERT_EQ(WindowState::STATE_CREATED, window->GetWindowState());
115
116 ASSERT_EQ(WMError::WM_OK, window->Show());
117 sleep(TEST_SLEEP_S);
118 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
119
120 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
121 ASSERT_EQ(WMError::WM_OK, window->Maximize());
122 WindowStatus windowStatus1;
123 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus1));
124 ASSERT_NE(WindowStatus::WINDOW_STATUS_FULLSCREEN, windowStatus1);
125 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, window->Recover());
126 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
127
128 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
129 ASSERT_EQ(WMError::WM_OK, window->Maximize());
130 WindowStatus windowStatus2;
131 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus2));
132 ASSERT_EQ(WindowStatus::WINDOW_STATUS_FULLSCREEN, windowStatus2);
133 ASSERT_EQ(WMError::WM_OK, window->Recover());
134 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
135
136 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
137 ASSERT_EQ(WMError::WM_OK, window->Maximize());
138 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
139 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, window->Recover());
140 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
141
142 window->Destroy(true, true);
143 }
144
145 /**
146 * @tc.name: ChangeWindowStatus03
147 * @tc.desc: one FLOATING SubWindow, maximize and recover
148 * @tc.type: FUNC
149 */
150 HWTEST_F(WindowStatusChangeTest, ChangeWindowStatus03, Function | MediumTest | Level0)
151 {
152 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
153 option->SetWindowName("Window1_3");
154 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
155 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
156
157 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
158
159 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
160 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
161 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
162
163 window->property_->SetPersistentId(10013);
164 window->hostSession_ = session;
165 window->state_ = WindowState::STATE_CREATED;
166 ASSERT_EQ(WindowState::STATE_CREATED, window->GetWindowState());
167
168 ASSERT_EQ(WMError::WM_OK, window->Show());
169 sleep(TEST_SLEEP_S);
170 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
171
172 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
173 ASSERT_EQ(WMError::WM_OK, window->Maximize());
174 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
175 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->Recover());
176 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
177
178 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
179 ASSERT_EQ(WMError::WM_OK, window->Maximize());
180 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
181 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->Recover());
182 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
183
184 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
185 ASSERT_EQ(WMError::WM_OK, window->Maximize());
186 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
187 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->Recover());
188 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
189
190 window->Destroy(true, true);
191 }
192
193 /**
194 * @tc.name: ChangeWindowStatus04
195 * @tc.desc: one FULLSCREEN SubWindow, recover
196 * @tc.type: FUNC
197 */
198 HWTEST_F(WindowStatusChangeTest, ChangeWindowStatus04, Function | MediumTest | Level0)
199 {
200 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
201 option->SetWindowName("Window1_4");
202 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
203 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
204
205 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
206
207 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
208 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
209 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
210
211 window->property_->SetPersistentId(10014);
212 window->hostSession_ = session;
213 window->state_ = WindowState::STATE_CREATED;
214 ASSERT_EQ(WindowState::STATE_CREATED, window->GetWindowState());
215
216 ASSERT_EQ(WMError::WM_OK, window->Show());
217 sleep(TEST_SLEEP_S);
218 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
219
220 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
221 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->Recover());
222 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode());
223
224 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
225 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->Recover());
226 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode());
227
228 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
229 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->Recover());
230 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode());
231
232 window->Destroy(true, true);
233 }
234
235 /**
236 * @tc.name: ChangeWindowStatus05
237 * @tc.desc: one FLOATING MainWindow, minimize and restore
238 * @tc.type: FUNC
239 */
240 HWTEST_F(WindowStatusChangeTest, ChangeWindowStatus05, Function | MediumTest | Level0)
241 {
242 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
243 option->SetWindowName("Window2_1");
244 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
245 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
246
247 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
248
249 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
250 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
251 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
252
253 window->property_->SetPersistentId(10021);
254 window->hostSession_ = session;
255 window->state_ = WindowState::STATE_CREATED;
256 ASSERT_EQ(WindowState::STATE_CREATED, window->GetWindowState());
257
258 ASSERT_EQ(WMError::WM_OK, window->Show());
259 sleep(TEST_SLEEP_S);
260 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
261
262 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
263 ASSERT_EQ(WMError::WM_OK, window->Minimize());
264 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
265 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->Restore());
266
267 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
268 ASSERT_EQ(WMError::WM_OK, window->Minimize());
269 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
270 ASSERT_EQ(WMError::WM_OK, window->Restore());
271
272 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
273 ASSERT_EQ(WMError::WM_OK, window->Minimize());
274 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
275 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->Restore());
276
277 window->Destroy(true, true);
278 }
279
280 /**
281 * @tc.name: ChangeWindowStatus06
282 * @tc.desc: one FLOATING SubWindow, minimize and restore
283 * @tc.type: FUNC
284 */
285 HWTEST_F(WindowStatusChangeTest, ChangeWindowStatus06, Function | MediumTest | Level0)
286 {
287 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
288 option->SetWindowName("Window2_2");
289 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
290 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
291
292 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
293
294 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
295 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
296 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
297
298 window->property_->SetPersistentId(10022);
299 window->hostSession_ = session;
300 window->state_ = WindowState::STATE_CREATED;
301 ASSERT_EQ(WindowState::STATE_CREATED, window->GetWindowState());
302
303 ASSERT_EQ(WMError::WM_OK, window->Show());
304 sleep(TEST_SLEEP_S);
305 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
306
307 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
308 ASSERT_EQ(WMError::WM_DO_NOTHING, window->Minimize());
309 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
310 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->Restore());
311
312 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
313 ASSERT_EQ(WMError::WM_DO_NOTHING, window->Minimize());
314 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
315 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->Restore());
316
317 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
318 ASSERT_EQ(WMError::WM_DO_NOTHING, window->Minimize());
319 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
320 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->Restore());
321
322 window->Destroy(true, true);
323 }
324 }
325
326 } // namespace Rosen
327 } // namespace OHOSgit