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