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