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 "window_property.h"
19#include "wm_common_inner.h"
20
21using namespace testing;
22using namespace testing::ext;
23
24namespace OHOS {
25namespace Rosen {
26class WindowPropertyTest : public testing::Test {
27public:
28    static void SetUpTestCase();
29    static void TearDownTestCase();
30    virtual void SetUp() override;
31    virtual void TearDown() override;
32};
33
34void WindowPropertyTest::SetUpTestCase()
35{
36}
37
38void WindowPropertyTest::TearDownTestCase()
39{
40}
41
42void WindowPropertyTest::SetUp()
43{
44}
45
46void WindowPropertyTest::TearDown()
47{
48}
49
50namespace {
51/**
52 * @tc.name: MarshallingUnmarshalling
53 * @tc.desc: Marshalling Unmarshalling test
54 * @tc.type: FUNC
55 */
56HWTEST_F(WindowPropertyTest, MarshallingUnmarshalling, Function | SmallTest | Level2)
57{
58    WindowProperty winPropSrc;
59    winPropSrc.SetPrivacyMode(true);
60    winPropSrc.SetTransparent(true);
61    winPropSrc.SetTransform(Transform::Identity());
62
63    Parcel parcel;
64    winPropSrc.Marshalling(parcel);
65    WindowProperty* winPropDst = winPropSrc.Unmarshalling(parcel);
66
67    ASSERT_EQ(winPropDst->GetPrivacyMode(), true);
68    ASSERT_EQ(winPropDst->GetTransparent(), true);
69    ASSERT_EQ(winPropDst->GetTransform(), Transform::Identity());
70    delete winPropDst;
71}
72
73/**
74 * @tc.name: CopyFrom
75 * @tc.desc: CopyFrom test
76 * @tc.type: FUNC
77 */
78HWTEST_F(WindowPropertyTest, CopyFrom, Function | SmallTest | Level2)
79{
80    const sptr<WindowProperty> winPropSrc = new(std::nothrow) WindowProperty();
81    winPropSrc->SetPrivacyMode(true);
82    winPropSrc->SetTransparent(true);
83    winPropSrc->SetTransform(Transform::Identity());
84
85    WindowProperty winPropDst(winPropSrc); // winPropDst.CopyFrom(winPropSrc);
86
87    ASSERT_EQ(winPropSrc->GetPrivacyMode(), winPropDst.GetPrivacyMode());
88    ASSERT_EQ(winPropSrc->GetTransparent(), winPropDst.GetTransparent());
89    ASSERT_EQ(winPropSrc->GetTransform(), winPropDst.GetTransform());
90}
91
92/**
93 * @tc.name: Read
94 * @tc.desc: Read test
95 * @tc.type: FUNC
96 */
97HWTEST_F(WindowPropertyTest, Read, Function | SmallTest | Level2)
98{
99    WindowProperty winPropSrc;
100    winPropSrc.SetPrivacyMode(true);
101    winPropSrc.SetTransparent(true);
102
103    Parcel parcel;
104    winPropSrc.Marshalling(parcel);
105
106    WindowProperty winPropDst;
107    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_RECT);
108    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_MODE);
109    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_FLAGS);
110    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_OTHER_PROPS);
111    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_FOCUSABLE);
112    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_TOUCHABLE);
113    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_CALLING_WINDOW);
114    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_ORIENTATION);
115    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_TURN_SCREEN_ON);
116    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_KEEP_SCREEN_ON);
117    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_SET_BRIGHTNESS);
118    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_MODE_SUPPORT_INFO);
119    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_TOUCH_HOT_AREA);
120    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_TRANSFORM_PROPERTY);
121    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_ANIMATION_FLAG);
122    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_PRIVACY_MODE);
123    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_SYSTEM_PRIVACY_MODE);
124
125    ASSERT_EQ(false, winPropDst.GetPrivacyMode());
126    ASSERT_EQ(false, winPropDst.GetTransparent());
127}
128
129/**
130 * @tc.name: Write
131 * @tc.desc: Write test
132 * @tc.type: FUNC
133 */
134HWTEST_F(WindowPropertyTest, Write, Function | SmallTest | Level2)
135{
136    Parcel parcel;
137    WindowProperty winPropDst;
138    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_RECT));
139    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_MODE));
140    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_FLAGS));
141    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_OTHER_PROPS));
142    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_FOCUSABLE));
143    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_TOUCHABLE));
144    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_CALLING_WINDOW));
145    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_ORIENTATION));
146    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_TURN_SCREEN_ON));
147    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_KEEP_SCREEN_ON));
148    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_SET_BRIGHTNESS));
149    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_MODE_SUPPORT_INFO));
150    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_TOUCH_HOT_AREA));
151    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_TRANSFORM_PROPERTY));
152    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_ANIMATION_FLAG));
153}
154
155/**
156 * @tc.name: SetAbilityInfo
157 * @tc.desc: Test SetAbilityInfo and GetAbilityInfo
158 * @tc.type: FUNC
159 */
160HWTEST_F(WindowPropertyTest, SetAbilityInfo, Function | SmallTest | Level2)
161{
162    WindowProperty winPropDst;
163    AbilityInfo info;
164    info.bundleName_ = "testBundleName";
165    info.abilityName_ = "testAbilityName";
166    winPropDst.SetAbilityInfo(info);
167    ASSERT_EQ("testBundleName", winPropDst.GetAbilityInfo().bundleName_);
168    ASSERT_EQ("testAbilityName", winPropDst.GetAbilityInfo().abilityName_);
169}
170
171/**
172 * @tc.name: ResumeLastWindowMode
173 * @tc.desc: Test ResumeLastWindowMode
174 * @tc.type: FUNC
175 */
176HWTEST_F(WindowPropertyTest, ResumeLastWindowMode, Function | SmallTest | Level2)
177{
178    WindowProperty winPropDst;
179    winPropDst.modeSupportInfo_ =  WindowModeSupport::WINDOW_MODE_SUPPORT_PIP;
180    winPropDst.lastMode_ =  WindowMode::WINDOW_MODE_PIP;
181    winPropDst.mode_ = WindowMode::WINDOW_MODE_UNDEFINED;
182    winPropDst.ResumeLastWindowMode();
183    ASSERT_EQ(WindowMode::WINDOW_MODE_PIP, winPropDst.mode_);
184
185    winPropDst.modeSupportInfo_ =  WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_SECONDARY;
186    winPropDst.lastMode_ =  WindowMode::WINDOW_MODE_PIP;
187    winPropDst.mode_ = WindowMode::WINDOW_MODE_UNDEFINED;
188    winPropDst.ResumeLastWindowMode();
189    ASSERT_EQ(WindowMode::WINDOW_MODE_UNDEFINED, winPropDst.mode_);
190
191    winPropDst.modeSupportInfo_ =  WindowModeSupport::WINDOW_MODE_SUPPORT_FLOATING;
192    winPropDst.lastMode_ =  WindowMode::WINDOW_MODE_PIP;
193    winPropDst.mode_ = WindowMode::WINDOW_MODE_UNDEFINED;
194    winPropDst.ResumeLastWindowMode();
195    ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, winPropDst.mode_);
196}
197
198/**
199 * @tc.name: AddWindowFlag001
200 * @tc.desc: AddWindowFlag test
201 * @tc.type: FUNC
202 */
203HWTEST_F(WindowPropertyTest, AddWindowFlag001, Function | SmallTest | Level2)
204{
205    WindowProperty winPropSrc;
206    int resultValue = 0;
207    WindowFlag flag = WindowFlag::WINDOW_FLAG_NEED_AVOID;
208    std::function<void()> func = [&]() {
209        winPropSrc.AddWindowFlag(flag);
210        resultValue = 1;
211    };
212    func();
213    ASSERT_EQ(resultValue, 1);
214}
215
216/**
217 * @tc.name: GetRequestRect002
218 * @tc.desc: GetRequestRect test
219 * @tc.type: FUNC
220 */
221HWTEST_F(WindowPropertyTest, GetRequestRect001, Function | SmallTest | Level2)
222{
223    WindowProperty winPropSrc;
224    Rect requestRect { 0, 0, 0, 0 };
225    winPropSrc.SetRequestRect(requestRect);
226    Rect res = winPropSrc.GetRequestRect();
227    ASSERT_EQ(res, requestRect);
228}
229
230/**
231 * @tc.name: GetWindowSizeChangeReason003
232 * @tc.desc: GetWindowSizeChangeReason test
233 * @tc.type: FUNC
234 */
235HWTEST_F(WindowPropertyTest, GetWindowSizeChangeReason003, Function | SmallTest | Level2)
236{
237    WindowProperty winPropSrc;
238    WindowSizeChangeReason reason = WindowSizeChangeReason::UNDEFINED;
239    winPropSrc.SetWindowSizeChangeReason(reason);
240    WindowSizeChangeReason res = winPropSrc.GetWindowSizeChangeReason();
241    ASSERT_EQ(res, reason);
242}
243
244/**
245 * @tc.name: GetFullScreen004
246 * @tc.desc: GetFullScreen test
247 * @tc.type: FUNC
248 */
249HWTEST_F(WindowPropertyTest, GetFullScreen004, Function | SmallTest | Level2)
250{
251    WindowProperty winPropSrc;
252    bool isFullScreen = true;
253    winPropSrc.SetFullScreen(isFullScreen);
254    bool res = winPropSrc.GetFullScreen();
255    ASSERT_EQ(res, isFullScreen);
256}
257
258/**
259 * @tc.name: GetFocusable005
260 * @tc.desc: GetFocusable test
261 * @tc.type: FUNC
262 */
263HWTEST_F(WindowPropertyTest, GetFocusable005, Function | SmallTest | Level2)
264{
265    WindowProperty winPropSrc;
266    bool isFocusable = true;
267    winPropSrc.SetFocusable(isFocusable);
268    bool res = winPropSrc.GetFocusable();
269    ASSERT_EQ(res, isFocusable);
270}
271
272/**
273 * @tc.name: GetTouchable006
274 * @tc.desc: GetTouchable test
275 * @tc.type: FUNC
276 */
277HWTEST_F(WindowPropertyTest, GetTouchable006, Function | SmallTest | Level2)
278{
279    WindowProperty winPropSrc;
280    bool isTouchable = true;
281    winPropSrc.SetTouchable(isTouchable);
282    bool res = winPropSrc.GetFocusable();
283    ASSERT_EQ(res, isTouchable);
284}
285
286/**
287 * @tc.name: GetCallingWindow007
288 * @tc.desc: GetCallingWindow test
289 * @tc.type: FUNC
290 */
291HWTEST_F(WindowPropertyTest, GetCallingWindow007, Function | SmallTest | Level2)
292{
293    WindowProperty winPropSrc;
294    uint32_t windowId = 1;
295    winPropSrc.SetCallingWindow(windowId);
296    uint32_t res = winPropSrc.GetCallingWindow();
297    ASSERT_EQ(res, windowId);
298}
299
300/**
301 * @tc.name: GetPrivacyMode008
302 * @tc.desc: GetPrivacyMode test
303 * @tc.type: FUNC
304 */
305HWTEST_F(WindowPropertyTest, GetPrivacyMode008, Function | SmallTest | Level2)
306{
307    WindowProperty winPropSrc;
308    bool isPrivate = true;
309    winPropSrc.SetPrivacyMode(isPrivate);
310    bool res = winPropSrc.GetPrivacyMode();
311    ASSERT_EQ(res, isPrivate);
312}
313
314/**
315 * @tc.name: GetSystemPrivacyMode009
316 * @tc.desc: GetSystemPrivacyMode test
317 * @tc.type: FUNC
318 */
319HWTEST_F(WindowPropertyTest, GetSystemPrivacyMode009, Function | SmallTest | Level2)
320{
321    WindowProperty winPropSrc;
322    bool isSystemPrivate = true;
323    winPropSrc.SetSystemPrivacyMode(isSystemPrivate);
324    bool res = winPropSrc.GetSystemPrivacyMode();
325    ASSERT_EQ(res, isSystemPrivate);
326}
327
328/**
329 * @tc.name: GetSnapshotSkip010
330 * @tc.desc: GetSnapshotSkip test
331 * @tc.type: FUNC
332 */
333HWTEST_F(WindowPropertyTest, GetSnapshotSkip010, Function | SmallTest | Level2)
334{
335    WindowProperty winPropSrc;
336    bool isSkip = true;
337    winPropSrc.SetSnapshotSkip(isSkip);
338    bool res = winPropSrc.GetSnapshotSkip();
339    ASSERT_EQ(res, isSkip);
340}
341
342/**
343 * @tc.name: GetAlpha011
344 * @tc.desc: GetAlpha test
345 * @tc.type: FUNC
346 */
347HWTEST_F(WindowPropertyTest, GetAlpha011, Function | SmallTest | Level2)
348{
349    WindowProperty winPropSrc;
350    float alpha = 1;
351    winPropSrc.SetAlpha(alpha);
352    float res = winPropSrc.GetAlpha();
353    ASSERT_EQ(res, alpha);
354}
355
356/**
357 * @tc.name: GetBrightness012
358 * @tc.desc: GetBrightness test
359 * @tc.type: FUNC
360 */
361HWTEST_F(WindowPropertyTest, GetBrightness012, Function | SmallTest | Level2)
362{
363    WindowProperty winPropSrc;
364    float brightness = 1;
365    winPropSrc.SetBrightness(brightness);
366    float res = winPropSrc.GetBrightness();
367    ASSERT_EQ(res, brightness);
368}
369
370/**
371 * @tc.name: IsTurnScreenOn013
372 * @tc.desc: IsTurnScreenOn test
373 * @tc.type: FUNC
374 */
375HWTEST_F(WindowPropertyTest, IsTurnScreenOn013, Function | SmallTest | Level2)
376{
377    WindowProperty winPropSrc;
378    bool turnScreenOn = true;
379    winPropSrc.SetTurnScreenOn(turnScreenOn);
380    bool res = winPropSrc.IsTurnScreenOn();
381    ASSERT_EQ(res, turnScreenOn);
382}
383
384/**
385 * @tc.name: IsKeepScreenOn014
386 * @tc.desc: IsKeepScreenOn test
387 * @tc.type: FUNC
388 */
389HWTEST_F(WindowPropertyTest, IsKeepScreenOn014, Function | SmallTest | Level2)
390{
391    WindowProperty winPropSrc;
392    bool keepScreenOn = true;
393    winPropSrc.SetKeepScreenOn(keepScreenOn);
394    bool res = winPropSrc.IsKeepScreenOn();
395    ASSERT_EQ(res, keepScreenOn);
396}
397
398/**
399 * @tc.name: GetWindowFlags015
400 * @tc.desc: GetWindowFlags test
401 * @tc.type: FUNC
402 */
403HWTEST_F(WindowPropertyTest, GetWindowFlags015, Function | SmallTest | Level2)
404{
405    WindowProperty winPropSrc;
406    uint32_t flags = 1;
407    winPropSrc.SetWindowFlags(flags);
408    uint32_t res = winPropSrc.GetWindowFlags();
409    ASSERT_EQ(res, flags);
410}
411
412/**
413 * @tc.name: GetSystemBarProperty016
414 * @tc.desc: GetSystemBarProperty test
415 * @tc.type: FUNC
416 */
417HWTEST_F(WindowPropertyTest, GetSystemBarProperty016, Function | SmallTest | Level2)
418{
419    WindowProperty winPropSrc;
420    SystemBarProperty property;
421    WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
422    winPropSrc.SetSystemBarProperty(type, property);
423    std::unordered_map<WindowType, SystemBarProperty> res = winPropSrc.GetSystemBarProperty();
424    ASSERT_EQ(res[type], property);
425}
426
427/**
428 * @tc.name: GetStretchable017
429 * @tc.desc: GetHitOffset test
430 * @tc.type: FUNC
431 */
432HWTEST_F(WindowPropertyTest, GetStretchable017, Function | SmallTest | Level2)
433{
434    WindowProperty winPropSrc;
435    bool stretchable = true;
436    winPropSrc.SetStretchable(stretchable);
437    bool res = winPropSrc.GetStretchable();
438    ASSERT_EQ(res, stretchable);
439}
440
441/**
442 * @tc.name: GetAnimationFlag018
443 * @tc.desc: GetAnimationFlag test
444 * @tc.type: FUNC
445 */
446HWTEST_F(WindowPropertyTest, GetAnimationFlag018, Function | SmallTest | Level2)
447{
448    WindowProperty winPropSrc;
449    uint32_t animationFlag = 1;
450    winPropSrc.SetAnimationFlag(animationFlag);
451    uint32_t res = winPropSrc.GetAnimationFlag();
452    ASSERT_EQ(res, animationFlag);
453}
454
455/**
456 * @tc.name: GetModeSupportInfo019
457 * @tc.desc: GetModeSupportInfo test
458 * @tc.type: FUNC
459 */
460HWTEST_F(WindowPropertyTest, GetModeSupportInfo019, Function | SmallTest | Level2)
461{
462    WindowProperty winPropSrc;
463    uint32_t modeSupportInfo = 1;
464    winPropSrc.SetModeSupportInfo(modeSupportInfo);
465    uint32_t res = winPropSrc.GetModeSupportInfo();
466    ASSERT_EQ(res, modeSupportInfo);
467}
468
469/**
470 * @tc.name: GetRequestModeSupportInfo020
471 * @tc.desc: GetRequestModeSupportInfo test
472 * @tc.type: FUNC
473 */
474HWTEST_F(WindowPropertyTest, GetRequestModeSupportInfo020, Function | SmallTest | Level2)
475{
476    WindowProperty winPropSrc;
477    uint32_t requestModeSupportInfo = 1;
478    winPropSrc.SetRequestModeSupportInfo(requestModeSupportInfo);
479    uint32_t res = winPropSrc.GetRequestModeSupportInfo();
480    ASSERT_EQ(res, requestModeSupportInfo);
481}
482
483/**
484 * @tc.name: GetTokenState021
485 * @tc.desc: GetTokenState test
486 * @tc.type: FUNC
487 */
488HWTEST_F(WindowPropertyTest, GetTokenState021, Function | SmallTest | Level2)
489{
490    WindowProperty winPropSrc;
491    bool hasToken = true;
492    winPropSrc.SetTokenState(hasToken);
493    bool res = winPropSrc.GetTokenState();
494    ASSERT_EQ(res, hasToken);
495}
496
497/**
498 * @tc.name: GetDragType022
499 * @tc.desc: GetDragType test
500 * @tc.type: FUNC
501 */
502HWTEST_F(WindowPropertyTest, GetDragType022, Function | SmallTest | Level2)
503{
504    WindowProperty winPropSrc;
505    DragType dragType = DragType::DRAG_UNDEFINED;
506    winPropSrc.SetDragType(dragType);
507    DragType res = winPropSrc.GetDragType();
508    ASSERT_EQ(res, dragType);
509}
510
511/**
512 * @tc.name: GetOriginRect023
513 * @tc.desc: GetOriginRect test
514 * @tc.type: FUNC
515 */
516HWTEST_F(WindowPropertyTest, GetOriginRect023, Function | SmallTest | Level2)
517{
518    WindowProperty winPropSrc;
519    Rect rect = { 0, 0, 0, 0 };
520    winPropSrc.SetOriginRect(rect);
521    Rect res = winPropSrc.GetOriginRect();
522    ASSERT_EQ(res, rect);
523}
524
525/**
526 * @tc.name: SetTouchHotAreas028
527 * @tc.desc: SetTouchHotAreas test
528 * @tc.type: FUNC
529 */
530HWTEST_F(WindowPropertyTest, SetTouchHotAreas028, Function | SmallTest | Level2)
531{
532    WindowProperty winPropSrc;
533    std::vector<Rect> rects;
534    winPropSrc.SetTouchHotAreas(rects);
535    winPropSrc.GetTouchHotAreas(rects);
536    ASSERT_EQ(rects, winPropSrc.touchHotAreas_);
537}
538
539/**
540 * @tc.name: SetAspectRatio029
541 * @tc.desc: SetAspectRatio test
542 * @tc.type: FUNC
543 */
544HWTEST_F(WindowPropertyTest, SetAspectRatio029, Function | SmallTest | Level2)
545{
546    WindowProperty winPropSrc;
547    float ratio = 1;
548    winPropSrc.SetAspectRatio(ratio);
549    float res = winPropSrc.GetAspectRatio();
550    ASSERT_EQ(res, ratio);
551}
552
553/**
554 * @tc.name: SetMaximizeMode030
555 * @tc.desc: SetMaximizeMode test
556 * @tc.type: FUNC
557 */
558HWTEST_F(WindowPropertyTest, SetMaximizeMode030, Function | SmallTest | Level2)
559{
560    WindowProperty winPropSrc;
561    MaximizeMode maximizeMode = { MaximizeMode::MODE_RECOVER };
562    winPropSrc.SetMaximizeMode(maximizeMode);
563    MaximizeMode res = winPropSrc.GetMaximizeMode();
564    ASSERT_EQ(res, maximizeMode);
565}
566
567/**
568 * @tc.name: GetAccessTokenId031
569 * @tc.desc: GetAccessTokenId test
570 * @tc.type: FUNC
571 */
572HWTEST_F(WindowPropertyTest, GetAccessTokenId031, Function | SmallTest | Level2)
573{
574    WindowProperty winPropSrc;
575    uint32_t accessTokenId = 1;
576    winPropSrc.SetAccessTokenId(accessTokenId);
577    uint32_t res = winPropSrc.GetAccessTokenId();
578    ASSERT_EQ(res, accessTokenId);
579}
580
581/**
582 * @tc.name: SetWindowGravity032
583 * @tc.desc: SetWindowGravity test
584 * @tc.type: FUNC
585 */
586HWTEST_F(WindowPropertyTest, GetAccessTokenId032, Function | SmallTest | Level2)
587{
588    WindowProperty winPropSrc;
589    WindowGravity gravity = WindowGravity::WINDOW_GRAVITY_FLOAT;
590    uint32_t percent = 1;
591    winPropSrc.SetWindowGravity(gravity, percent);
592    winPropSrc.GetWindowGravity(gravity, percent);
593    ASSERT_EQ(gravity, winPropSrc.windowGravity_);
594    ASSERT_EQ(percent, winPropSrc.windowGravitySizePercent_);
595}
596
597/**
598 * @tc.name: Write033
599 * @tc.desc: Write test
600 * @tc.type: FUNC
601 */
602HWTEST_F(WindowPropertyTest, Write033, Function | SmallTest | Level2)
603{
604    WindowProperty winPropDst;
605    Parcel parcel;
606    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_PRIVACY_MODE));
607    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_SYSTEM_PRIVACY_MODE));
608    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_SNAPSHOT_SKIP));
609    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO));
610    ASSERT_EQ(true, winPropDst.Write(parcel, PropertyChangeAction::ACTION_UPDATE_MAXIMIZE_STATE));
611}
612
613/**
614 * @tc.name: Read034
615 * @tc.desc: Read test
616 * @tc.type: FUNC
617 */
618HWTEST_F(WindowPropertyTest, Read034, Function | SmallTest | Level2)
619{
620    WindowProperty winPropSrc;
621    winPropSrc.SetPrivacyMode(true);
622    winPropSrc.SetTransparent(true);
623
624    Parcel parcel;
625    winPropSrc.Marshalling(parcel);
626
627    WindowProperty winPropDst;
628    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_SNAPSHOT_SKIP);
629    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO);
630    winPropDst.Read(parcel, PropertyChangeAction::ACTION_UPDATE_MAXIMIZE_STATE);
631
632    ASSERT_EQ(false, winPropDst.GetPrivacyMode());
633    ASSERT_EQ(false, winPropDst.GetTransparent());
634}
635
636/**
637 * @tc.name: GetTextFieldPositionY035
638 * @tc.desc: GetTextFieldPositionY test
639 * @tc.type: FUNC
640 */
641HWTEST_F(WindowPropertyTest, GetTextFieldPositionY035, Function | SmallTest | Level2)
642{
643    WindowProperty winPropSrc;
644    double textFieldPositionY = 1;
645    winPropSrc.SetTextFieldPositionY(textFieldPositionY);
646    double res = winPropSrc.GetTextFieldPositionY();
647    ASSERT_EQ(res, textFieldPositionY);
648}
649
650/**
651 * @tc.name: GetTextFieldHeight036
652 * @tc.desc: GetTextFieldHeight test
653 * @tc.type: FUNC
654 */
655HWTEST_F(WindowPropertyTest, GetTextFieldHeight36, Function | SmallTest | Level2)
656{
657    WindowProperty winPropSrc;
658    double textFieldHeight = 1;
659    winPropSrc.SetTextFieldHeight(textFieldHeight);
660    double res = winPropSrc.GetTextFieldHeight();
661    ASSERT_EQ(res, textFieldHeight);
662}
663}
664} // namespace Rosen
665} // namespace OHOS