1 /*
2 * Copyright (c) 2022 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 <gtest/gtest.h>
17
18 #include <iremote_broker.h>
19 #include <iremote_object.h>
20 #include "iremote_object_mocker.h"
21 #include "window_transition_info.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 using RemoteMocker = IRemoteObjectMocker;
29 class WindowTransitionInfoTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp() override;
34 void TearDown() override;
35
36 void SetTransitionInfo(sptr<WindowTransitionInfo> info);
37 };
38
SetUpTestCase()39 void WindowTransitionInfoTest::SetUpTestCase() {}
40
TearDownTestCase()41 void WindowTransitionInfoTest::TearDownTestCase() {}
42
SetUp()43 void WindowTransitionInfoTest::SetUp() {}
44
TearDown()45 void WindowTransitionInfoTest::TearDown() {}
46
SetTransitionInfo(sptr<WindowTransitionInfo> info)47 void WindowTransitionInfoTest::SetTransitionInfo(sptr<WindowTransitionInfo> info)
48 {
49 info->bundleName_ = "bundleName";
50 info->abilityName_ = "abilityName";
51 info->mode_ = WindowMode::WINDOW_MODE_FULLSCREEN;
52 info->windowRect_ = { 10, 10, 10, 10 };
53 info->displayId_ = 0;
54 }
55
56 namespace {
57 /**
58 * @tc.name: WindowTransitionInfo01
59 * @tc.desc: WindowTransitionInfo::WindowTransitionInfo test
60 * @tc.type: FUNC
61 */
62 HWTEST_F(WindowTransitionInfoTest, WindowTransitionInfo01, TestSize.Level1)
63 {
64 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
65 ASSERT_NE(nullptr, info);
66 info->bundleName_ = "TestAbilityTransitionInfo1";
67 sptr<WindowTransitionInfo> winTransitionInfo1 = new (std::nothrow) WindowTransitionInfo(info);
68 ASSERT_NE(nullptr, winTransitionInfo1);
69 ASSERT_EQ(info->bundleName_, winTransitionInfo1->bundleName_);
70 ASSERT_EQ(3, winTransitionInfo1->supportWindowModes_.size());
71 ASSERT_EQ(AppExecFwk::SupportWindowMode::FULLSCREEN, winTransitionInfo1->supportWindowModes_[0]);
72 ASSERT_EQ(AppExecFwk::SupportWindowMode::SPLIT, winTransitionInfo1->supportWindowModes_[1]);
73 ASSERT_EQ(AppExecFwk::SupportWindowMode::FLOATING, winTransitionInfo1->supportWindowModes_[2]);
74
75 info->bundleName_ = "TestAbilityTransitionInfo2";
76 info->windowModes_.emplace_back(AppExecFwk::SupportWindowMode::SPLIT);
77 sptr<WindowTransitionInfo> winTransitionInfo2 = new (std::nothrow) WindowTransitionInfo(info);
78 ASSERT_NE(nullptr, winTransitionInfo2);
79 ASSERT_EQ(info->bundleName_, winTransitionInfo2->bundleName_);
80 ASSERT_EQ(1, winTransitionInfo2->supportWindowModes_.size());
81 ASSERT_EQ(AppExecFwk::SupportWindowMode::SPLIT, winTransitionInfo2->supportWindowModes_[0]);
82 }
83
84 /**
85 * @tc.name: Marshalling
86 * @tc.desc: WindowTransitionInfo::Marshalling test
87 * @tc.type: FUNC
88 */
89 HWTEST_F(WindowTransitionInfoTest, Marshalling01, TestSize.Level1)
90 {
91 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
92 ASSERT_NE(nullptr, info);
93
94 Parcel parcel;
95 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
96 ASSERT_NE(nullptr, winTransitionInfo);
97
98 winTransitionInfo->bundleName_ = "bundleNameValue";
99 winTransitionInfo->abilityName_ = "abilityNameValue";
100
101 bool result = winTransitionInfo->Marshalling(parcel);
102 ASSERT_EQ(true, result);
103
104 sptr<IRemoteObject> remote = new (std::nothrow) RemoteMocker();
105 winTransitionInfo->abilityToken_ = remote;
106 result = winTransitionInfo->Marshalling(parcel);
107 ASSERT_EQ(true, result);
108 }
109
110 /**
111 * @tc.name: Unmarshalling
112 * @tc.desc: WindowTransitionInfo::Unmarshalling test
113 * @tc.type: FUNC
114 */
115 HWTEST_F(WindowTransitionInfoTest, Unmarshalling, TestSize.Level1)
116 {
117 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
118 ASSERT_NE(nullptr, info);
119
120 Parcel parcel;
121 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
122 ASSERT_NE(nullptr, winTransitionInfo);
123
124 winTransitionInfo->bundleName_ = "bundleNameValue";
125 winTransitionInfo->abilityName_ = "abilityNameValue";
126
127 sptr<IRemoteObject> remote = new (std::nothrow) RemoteMocker();
128 winTransitionInfo->abilityToken_ = remote;
129 auto result = winTransitionInfo->Marshalling(parcel);
130 ASSERT_EQ(true, result);
131
132 auto transitionInfo = winTransitionInfo->Unmarshalling(parcel);
133 ASSERT_NE(transitionInfo, nullptr);
134 ASSERT_EQ(transitionInfo->bundleName_, "bundleNameValue");
135 ASSERT_EQ(transitionInfo->abilityName_, "abilityNameValue");
136 ASSERT_NE(transitionInfo->abilityToken_, nullptr);
137 }
138
139 /**
140 * @tc.name: GetBundleName
141 * @tc.desc: WindowTransitionInfo::GetBundleName test
142 * @tc.type: FUNC
143 */
144 HWTEST_F(WindowTransitionInfoTest, GetBundleName, TestSize.Level1)
145 {
146 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
147 ASSERT_NE(nullptr, info);
148
149 Parcel parcel;
150 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
151 ASSERT_NE(nullptr, winTransitionInfo);
152 std::string name = "bundleNameValue";
153 winTransitionInfo->SetBundleName(name);
154 auto ret = winTransitionInfo->GetBundleName();
155 ASSERT_EQ(ret, name);
156 }
157
158 /**
159 * @tc.name: GetAbilityName
160 * @tc.desc: WindowTransitionInfo::GetAbilityName test
161 * @tc.type: FUNC
162 */
163 HWTEST_F(WindowTransitionInfoTest, GetAbilityName, TestSize.Level1)
164 {
165 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
166 ASSERT_NE(nullptr, info);
167
168 Parcel parcel;
169 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
170 ASSERT_NE(nullptr, winTransitionInfo);
171 std::string name = "abilityNameValue";
172 winTransitionInfo->SetAbilityName(name);
173 auto ret = winTransitionInfo->GetAbilityName();
174 ASSERT_EQ(ret, name);
175 }
176
177 /**
178 * @tc.name: GetWindowMode
179 * @tc.desc: WindowTransitionInfo::GetWindowMode test
180 * @tc.type: FUNC
181 */
182 HWTEST_F(WindowTransitionInfoTest, GetWindowMode, TestSize.Level1)
183 {
184 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
185 ASSERT_NE(nullptr, info);
186
187 Parcel parcel;
188 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
189 ASSERT_NE(nullptr, winTransitionInfo);
190 WindowMode mode = WindowMode{ 1 };
191 winTransitionInfo->SetWindowMode(mode);
192 auto ret = winTransitionInfo->GetWindowMode();
193 ASSERT_EQ(ret, mode);
194 }
195
196 /**
197 * @tc.name: GetWindowRect
198 * @tc.desc: WindowTransitionInfo::GetWindowRect test
199 * @tc.type: FUNC
200 */
201 HWTEST_F(WindowTransitionInfoTest, GetWindowRect, TestSize.Level1)
202 {
203 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
204 ASSERT_NE(nullptr, info);
205
206 Parcel parcel;
207 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
208 ASSERT_NE(nullptr, winTransitionInfo);
209 Rect rect = { 0, 0, 50, 100 };
210 winTransitionInfo->SetWindowRect(rect);
211 auto ret = winTransitionInfo->GetWindowRect();
212 ASSERT_EQ(ret, rect);
213 }
214
215 /**
216 * @tc.name: GetAbilityToken
217 * @tc.desc: WindowTransitionInfo::GetAbilityToken test
218 * @tc.type: FUNC
219 */
220 HWTEST_F(WindowTransitionInfoTest, GetAbilityToken, TestSize.Level1)
221 {
222 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
223 ASSERT_NE(nullptr, info);
224
225 Parcel parcel;
226 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
227 ASSERT_NE(nullptr, winTransitionInfo);
228 sptr<IRemoteObject> abilityToken;
229 winTransitionInfo->SetAbilityToken(abilityToken);
230 auto ret = winTransitionInfo->GetAbilityToken();
231 ASSERT_EQ(ret, abilityToken);
232 }
233
234 /**
235 * @tc.name: GetDisplayId
236 * @tc.desc: WindowTransitionInfo::GetDisplayId test
237 * @tc.type: FUNC
238 */
239 HWTEST_F(WindowTransitionInfoTest, GetDisplayId, TestSize.Level1)
240 {
241 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
242 ASSERT_NE(nullptr, info);
243
244 Parcel parcel;
245 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
246 ASSERT_NE(nullptr, winTransitionInfo);
247 winTransitionInfo->SetDisplayId(0);
248 auto ret = winTransitionInfo->GetDisplayId();
249 ASSERT_EQ(ret, 0);
250 }
251
252 /**
253 * @tc.name: GetWindowType
254 * @tc.desc: WindowTransitionInfo::GetWindowType test
255 * @tc.type: FUNC
256 */
257 HWTEST_F(WindowTransitionInfoTest, GetWindowType, TestSize.Level1)
258 {
259 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
260 ASSERT_NE(nullptr, info);
261
262 Parcel parcel;
263 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
264 ASSERT_NE(nullptr, winTransitionInfo);
265 WindowType windowType = WindowType{ 1 };
266 winTransitionInfo->SetWindowType(windowType);
267 auto ret = winTransitionInfo->GetWindowType();
268 ASSERT_EQ(ret, windowType);
269 }
270
271 /**
272 * @tc.name: GetShowFlagWhenLocked
273 * @tc.desc: WindowTransitionInfo::GetShowFlagWhenLocked test
274 * @tc.type: FUNC
275 */
276 HWTEST_F(WindowTransitionInfoTest, GetShowFlagWhenLocked, TestSize.Level1)
277 {
278 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
279 ASSERT_NE(nullptr, info);
280
281 Parcel parcel;
282 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
283 ASSERT_NE(nullptr, winTransitionInfo);
284 winTransitionInfo->SetShowFlagWhenLocked(false);
285 auto ret = winTransitionInfo->GetShowFlagWhenLocked();
286 ASSERT_EQ(ret, false);
287 }
288
289 /**
290 * @tc.name: GetWindowSupportModes
291 * @tc.desc: WindowTransitionInfo::GetWindowSupportModes test
292 * @tc.type: FUNC
293 */
294 HWTEST_F(WindowTransitionInfoTest, GetWindowSupportModes, TestSize.Level1)
295 {
296 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
297 ASSERT_NE(nullptr, info);
298 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
299 ASSERT_NE(nullptr, winTransitionInfo);
300 std::vector<AppExecFwk::SupportWindowMode> supportModesIn = { AppExecFwk::SupportWindowMode::FULLSCREEN,
301 AppExecFwk::SupportWindowMode::SPLIT,
302 AppExecFwk::SupportWindowMode::FLOATING };
303 winTransitionInfo->SetWindowSupportModes(supportModesIn);
304 auto supportModesOut = winTransitionInfo->GetWindowSupportModes();
305 ASSERT_EQ(supportModesOut.size(), 3);
306 ASSERT_EQ(supportModesOut[0], AppExecFwk::SupportWindowMode::FULLSCREEN);
307 ASSERT_EQ(supportModesOut[1], AppExecFwk::SupportWindowMode::SPLIT);
308 ASSERT_EQ(supportModesOut[2], AppExecFwk::SupportWindowMode::FLOATING);
309 }
310
311 /**
312 * @tc.name: GetWindowSizeLimits
313 * @tc.desc: WindowTransitionInfo::GetWindowSizeLimits test
314 * @tc.type: FUNC
315 */
316 HWTEST_F(WindowTransitionInfoTest, GetWindowSizeLimits, TestSize.Level1)
317 {
318 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
319 ASSERT_NE(nullptr, info);
320 info->maxWindowRatio_ = 2.0f;
321 info->minWindowRatio_ = 1.0f;
322 info->maxWindowWidth_ = 2048;
323 info->minWindowWidth_ = 512;
324 info->maxWindowHeight_ = 2048;
325 info->minWindowHeight_ = 512;
326 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
327 ASSERT_NE(nullptr, winTransitionInfo);
328 auto windowSizeLimits = winTransitionInfo->GetWindowSizeLimits();
329 ASSERT_FLOAT_EQ(windowSizeLimits.maxRatio_, 2.0f);
330 ASSERT_FLOAT_EQ(windowSizeLimits.minRatio_, 1.0f);
331 ASSERT_EQ(windowSizeLimits.maxWidth_, 2048);
332 ASSERT_EQ(windowSizeLimits.minWidth_, 512);
333 ASSERT_EQ(windowSizeLimits.maxHeight_, 2048);
334 ASSERT_EQ(windowSizeLimits.minHeight_, 512);
335 }
336
337 /**
338 * @tc.name: GetTransitionReason
339 * @tc.desc: WindowTransitionInfo::GetTransitionReason test
340 * @tc.type: FUNC
341 */
342 HWTEST_F(WindowTransitionInfoTest, GetTransitionReason, TestSize.Level1)
343 {
344 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
345 ASSERT_NE(nullptr, info);
346 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
347 ASSERT_NE(nullptr, winTransitionInfo);
348
349 auto reasonIn = TransitionReason::MINIMIZE;
350 winTransitionInfo->SetTransitionReason(reasonIn);
351 auto reasonOut = winTransitionInfo->GetTransitionReason();
352 ASSERT_EQ(reasonOut, TransitionReason::MINIMIZE);
353
354 reasonIn = TransitionReason::CLOSE;
355 winTransitionInfo->SetTransitionReason(reasonIn);
356 reasonOut = winTransitionInfo->GetTransitionReason();
357 ASSERT_EQ(reasonOut, TransitionReason::CLOSE);
358
359 reasonIn = TransitionReason::ABILITY_TRANSITION;
360 winTransitionInfo->SetTransitionReason(reasonIn);
361 reasonOut = winTransitionInfo->GetTransitionReason();
362 ASSERT_EQ(reasonOut, TransitionReason::ABILITY_TRANSITION);
363
364 reasonIn = TransitionReason::BACK_TRANSITION;
365 winTransitionInfo->SetTransitionReason(reasonIn);
366 reasonOut = winTransitionInfo->GetTransitionReason();
367 ASSERT_EQ(reasonOut, TransitionReason::BACK_TRANSITION);
368
369 reasonIn = TransitionReason::CLOSE_BUTTON;
370 winTransitionInfo->SetTransitionReason(reasonIn);
371 reasonOut = winTransitionInfo->GetTransitionReason();
372 ASSERT_EQ(reasonOut, TransitionReason::CLOSE_BUTTON);
373
374 reasonIn = TransitionReason::BACKGROUND_TRANSITION;
375 winTransitionInfo->SetTransitionReason(reasonIn);
376 reasonOut = winTransitionInfo->GetTransitionReason();
377 ASSERT_EQ(reasonOut, TransitionReason::BACKGROUND_TRANSITION);
378 }
379
380 /**
381 * @tc.name: GetOrientation01
382 * @tc.desc: WindowTransitionInfo::GetOrientation test
383 * @tc.type: FUNC
384 */
385 HWTEST_F(WindowTransitionInfoTest, GetOrientation01, TestSize.Level1)
386 {
387 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
388 ASSERT_NE(nullptr, info);
389 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
390 ASSERT_NE(nullptr, winTransitionInfo);
391
392 auto orientationIn = AppExecFwk::DisplayOrientation::UNSPECIFIED;
393 winTransitionInfo->SetOrientation(orientationIn);
394 auto orientationOut = winTransitionInfo->GetOrientation();
395 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::UNSPECIFIED);
396
397 orientationIn = AppExecFwk::DisplayOrientation::LANDSCAPE;
398 winTransitionInfo->SetOrientation(orientationIn);
399 orientationOut = winTransitionInfo->GetOrientation();
400 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::LANDSCAPE);
401
402 orientationIn = AppExecFwk::DisplayOrientation::PORTRAIT;
403 winTransitionInfo->SetOrientation(orientationIn);
404 orientationOut = winTransitionInfo->GetOrientation();
405 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::PORTRAIT);
406
407 orientationIn = AppExecFwk::DisplayOrientation::FOLLOWRECENT;
408 winTransitionInfo->SetOrientation(orientationIn);
409 orientationOut = winTransitionInfo->GetOrientation();
410 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::FOLLOWRECENT);
411
412 orientationIn = AppExecFwk::DisplayOrientation::LANDSCAPE_INVERTED;
413 winTransitionInfo->SetOrientation(orientationIn);
414 orientationOut = winTransitionInfo->GetOrientation();
415 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::LANDSCAPE_INVERTED);
416
417 orientationIn = AppExecFwk::DisplayOrientation::PORTRAIT_INVERTED;
418 winTransitionInfo->SetOrientation(orientationIn);
419 orientationOut = winTransitionInfo->GetOrientation();
420 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::PORTRAIT_INVERTED);
421
422 orientationIn = AppExecFwk::DisplayOrientation::AUTO_ROTATION;
423 winTransitionInfo->SetOrientation(orientationIn);
424 orientationOut = winTransitionInfo->GetOrientation();
425 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::AUTO_ROTATION);
426 }
427
428 /**
429 * @tc.name: GetOrientation02
430 * @tc.desc: WindowTransitionInfo::GetOrientation test
431 * @tc.type: FUNC
432 */
433 HWTEST_F(WindowTransitionInfoTest, GetOrientation02, TestSize.Level1)
434 {
435 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
436 ASSERT_NE(nullptr, info);
437 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
438 ASSERT_NE(nullptr, winTransitionInfo);
439
440 auto orientationIn = AppExecFwk::DisplayOrientation::AUTO_ROTATION_LANDSCAPE;
441 winTransitionInfo->SetOrientation(orientationIn);
442 auto orientationOut = winTransitionInfo->GetOrientation();
443 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::AUTO_ROTATION_LANDSCAPE);
444
445 orientationIn = AppExecFwk::DisplayOrientation::AUTO_ROTATION_PORTRAIT;
446 winTransitionInfo->SetOrientation(orientationIn);
447 orientationOut = winTransitionInfo->GetOrientation();
448 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::AUTO_ROTATION_PORTRAIT);
449
450 orientationIn = AppExecFwk::DisplayOrientation::AUTO_ROTATION_RESTRICTED;
451 winTransitionInfo->SetOrientation(orientationIn);
452 orientationOut = winTransitionInfo->GetOrientation();
453 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::AUTO_ROTATION_RESTRICTED);
454
455 orientationIn = AppExecFwk::DisplayOrientation::AUTO_ROTATION_LANDSCAPE_RESTRICTED;
456 winTransitionInfo->SetOrientation(orientationIn);
457 orientationOut = winTransitionInfo->GetOrientation();
458 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::AUTO_ROTATION_LANDSCAPE_RESTRICTED);
459
460 orientationIn = AppExecFwk::DisplayOrientation::AUTO_ROTATION_PORTRAIT_RESTRICTED;
461 winTransitionInfo->SetOrientation(orientationIn);
462 orientationOut = winTransitionInfo->GetOrientation();
463 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::AUTO_ROTATION_PORTRAIT_RESTRICTED);
464
465 orientationIn = AppExecFwk::DisplayOrientation::LOCKED;
466 winTransitionInfo->SetOrientation(orientationIn);
467 orientationOut = winTransitionInfo->GetOrientation();
468 ASSERT_EQ(orientationOut, AppExecFwk::DisplayOrientation::LOCKED);
469 }
470
471 /**
472 * @tc.name: GetIsRecent
473 * @tc.desc: WindowTransitionInfo::GetIsRecent test
474 * @tc.type: FUNC
475 */
476 HWTEST_F(WindowTransitionInfoTest, GetIsRecent, TestSize.Level1)
477 {
478 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
479 ASSERT_NE(nullptr, info);
480
481 Parcel parcel;
482 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
483 ASSERT_NE(nullptr, winTransitionInfo);
484 winTransitionInfo->SetIsRecent(false);
485 auto ret = winTransitionInfo->GetIsRecent();
486 ASSERT_EQ(ret, false);
487 }
488
489 /**
490 * @tc.name: GetApiCompatibleVersion
491 * @tc.desc: WindowTransitionInfo::GetApiCompatibleVersion test
492 * @tc.type: FUNC
493 */
494 HWTEST_F(WindowTransitionInfoTest, GetApiCompatibleVersion, TestSize.Level1)
495 {
496 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
497 ASSERT_NE(nullptr, info);
498
499 Parcel parcel;
500 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
501 ASSERT_NE(nullptr, winTransitionInfo);
502 winTransitionInfo->SetApiCompatibleVersion(100);
503 auto ret = winTransitionInfo->GetApiCompatibleVersion();
504 ASSERT_EQ(ret, 100);
505 }
506
507 /**
508 * @tc.name: GetMissionId
509 * @tc.desc: WindowTransitionInfo::GetMissionId test
510 * @tc.type: FUNC
511 */
512 HWTEST_F(WindowTransitionInfoTest, GetMissionId, TestSize.Level1)
513 {
514 sptr<AAFwk::AbilityTransitionInfo> info = new (std::nothrow) AAFwk::AbilityTransitionInfo();
515 ASSERT_NE(nullptr, info);
516
517 Parcel parcel;
518 sptr<WindowTransitionInfo> winTransitionInfo = new (std::nothrow) WindowTransitionInfo(info);
519 ASSERT_NE(nullptr, winTransitionInfo);
520 winTransitionInfo->SetMissionId(0);
521 auto ret = winTransitionInfo->GetMissionId();
522 ASSERT_EQ(ret, 0);
523 }
524 } // namespace
525 } // namespace Rosen
526 } // namespace OHOS