1 /*
2 * Copyright (c) 2025 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 #include "window_session_property.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace Rosen {
24
25 class CompatibleModePropertyTest : public testing::Test {
26 public:
27 static void SetUpTestCase();
28 static void TearDownTestCase();
29 };
30
SetUpTestCase()31 void CompatibleModePropertyTest::SetUpTestCase() {}
32
TearDownTestCase()33 void CompatibleModePropertyTest::TearDownTestCase() {}
34
35 namespace {
36 /**
37 * @tc.name: SetIsAdaptToImmersive
38 * @tc.desc: SetIsAdaptToImmersive
39 * @tc.type: FUNC
40 */
41 HWTEST_F(CompatibleModePropertyTest, SetIsAdaptToImmersive, TestSize.Level1)
42 {
43 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
44 property->SetIsAdaptToImmersive(true);
45 EXPECT_EQ(property->isAdaptToImmersive_, true);
46 property->SetIsAdaptToImmersive(false);
47 EXPECT_EQ(property->isAdaptToImmersive_, false);
48 }
49
50 /**
51 * @tc.name: IsAdaptToImmersive
52 * @tc.desc: IsAdaptToImmersive
53 * @tc.type: FUNC
54 */
55 HWTEST_F(CompatibleModePropertyTest, IsAdaptToImmersive, TestSize.Level1)
56 {
57 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
58 EXPECT_EQ(property->IsAdaptToImmersive(), false);
59 property->isAdaptToImmersive_ = true;
60 EXPECT_EQ(property->IsAdaptToImmersive(), true);
61 }
62
63 /**
64 * @tc.name: SetIsAdaptToEventMapping
65 * @tc.desc: SetIsAdaptToEventMapping
66 * @tc.type: FUNC
67 */
68 HWTEST_F(CompatibleModePropertyTest, SetIsAdaptToEventMapping, TestSize.Level1)
69 {
70 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
71 property->SetIsAdaptToEventMapping(true);
72 EXPECT_EQ(property->isAdaptToEventMapping_, true);
73 property->SetIsAdaptToEventMapping(false);
74 EXPECT_EQ(property->isAdaptToEventMapping_, false);
75 }
76
77 /**
78 * @tc.name: IsAdaptToEventMapping
79 * @tc.desc: IsAdaptToEventMapping
80 * @tc.type: FUNC
81 */
82 HWTEST_F(CompatibleModePropertyTest, IsAdaptToEventMapping, TestSize.Level1)
83 {
84 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
85 EXPECT_EQ(property->IsAdaptToEventMapping(), false);
86 property->isAdaptToEventMapping_ = true;
87 EXPECT_EQ(property->IsAdaptToEventMapping(), true);
88 }
89
90 /**
91 * @tc.name: SetIsAdaptToProportionalScale
92 * @tc.desc: SetIsAdaptToProportionalScale
93 * @tc.type: FUNC
94 */
95 HWTEST_F(CompatibleModePropertyTest, SetIsAdaptToProportionalScale, TestSize.Level1)
96 {
97 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
98 property->SetIsAdaptToProportionalScale(true);
99 EXPECT_EQ(property->isAdaptToProportionalScale_, true);
100 property->SetIsAdaptToProportionalScale(false);
101 EXPECT_EQ(property->isAdaptToProportionalScale_, false);
102 }
103
104 /**
105 * @tc.name: IsAdaptToProportionalScale
106 * @tc.desc: IsAdaptToProportionalScale
107 * @tc.type: FUNC
108 */
109 HWTEST_F(CompatibleModePropertyTest, IsAdaptToProportionalScale, TestSize.Level1)
110 {
111 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
112 EXPECT_EQ(property->IsAdaptToProportionalScale(), false);
113 property->isAdaptToProportionalScale_ = true;
114 EXPECT_EQ(property->IsAdaptToProportionalScale(), true);
115 }
116
117 /**
118 * @tc.name: SetIsAdaptToBackButton
119 * @tc.desc: SetIsAdaptToBackButton
120 * @tc.type: FUNC
121 */
122 HWTEST_F(CompatibleModePropertyTest, SetIsAdaptToBackButton, TestSize.Level1)
123 {
124 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
125 property->SetIsAdaptToBackButton(true);
126 EXPECT_EQ(property->isAdaptToBackButton_, true);
127 property->SetIsAdaptToBackButton(false);
128 EXPECT_EQ(property->isAdaptToBackButton_, false);
129 }
130
131 /**
132 * @tc.name: IsAdaptToBackButton
133 * @tc.desc: IsAdaptToBackButton
134 * @tc.type: FUNC
135 */
136 HWTEST_F(CompatibleModePropertyTest, IsAdaptToBackButton, TestSize.Level1)
137 {
138 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
139 EXPECT_EQ(property->IsAdaptToBackButton(), false);
140 property->isAdaptToBackButton_ = true;
141 EXPECT_EQ(property->IsAdaptToBackButton(), true);
142 }
143
144 /**
145 *@tc.name: SetIsAdaptToDragScale
146 *@tc.desc: SetIsAdaptToDragScale
147 *@tc.type: FUNC
148 */
149 HWTEST_F(CompatibleModePropertyTest, SetIsAdaptToDragScale, TestSize.Level1)
150 {
151 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
152 property->SetIsAdaptToDragScale(true);
153 EXPECT_EQ(property->IsAdaptToDragScale(), true);
154 property->SetIsAdaptToDragScale(false);
155 EXPECT_EQ(property->IsAdaptToDragScale(), false);
156 }
157
158 /**
159 *@tc.name: IsAdaptToDragScale
160 *@tc.desc: IsAdaptToDragScale
161 *@tc.type: FUNC
162 */
163 HWTEST_F(CompatibleModePropertyTest, IsAdaptToDragScale, TestSize.Level1)
164 {
165 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
166 EXPECT_EQ(property->IsAdaptToDragScale(), false);
167 property->SetIsAdaptToDragScale(true);
168 EXPECT_EQ(property->IsAdaptToDragScale(), true);
169 }
170
171 /**
172 * @tc.name: SetDisableDragResize
173 * @tc.desc: SetDisableDragResize
174 * @tc.type: FUNC
175 */
176 HWTEST_F(CompatibleModePropertyTest, SetDisableDragResize, TestSize.Level1)
177 {
178 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
179 property->SetDisableDragResize(true);
180 EXPECT_EQ(property->disableDragResize_, true);
181 property->SetDisableDragResize(false);
182 EXPECT_EQ(property->disableDragResize_, false);
183 }
184
185 /**
186 * @tc.name: IsDragResizeDisabled
187 * @tc.desc: IsDragResizeDisabled
188 * @tc.type: FUNC
189 */
190 HWTEST_F(CompatibleModePropertyTest, IsDragResizeDisabled, TestSize.Level1)
191 {
192 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
193 EXPECT_EQ(property->IsDragResizeDisabled(), false);
194 property->disableDragResize_ = true;
195 EXPECT_EQ(property->IsDragResizeDisabled(), true);
196 }
197
198 /**
199 * @tc.name: SetDisableResizeWithDpi
200 * @tc.desc: SetDisableResizeWithDpi
201 * @tc.type: FUNC
202 */
203 HWTEST_F(CompatibleModePropertyTest, SetDisableResizeWithDpi, TestSize.Level1)
204 {
205 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
206 property->SetDisableResizeWithDpi(true);
207 EXPECT_EQ(property->disableResizeWithDpi_, true);
208 property->SetDisableResizeWithDpi(false);
209 EXPECT_EQ(property->disableResizeWithDpi_, false);
210 }
211
212 /**
213 * @tc.name: IsResizeWithDpiDisabled
214 * @tc.desc: IsResizeWithDpiDisabled
215 * @tc.type: FUNC
216 */
217 HWTEST_F(CompatibleModePropertyTest, IsResizeWithDpiDisabled, TestSize.Level1)
218 {
219 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
220 EXPECT_EQ(property->IsResizeWithDpiDisabled(), false);
221 property->disableResizeWithDpi_ = true;
222 EXPECT_EQ(property->IsResizeWithDpiDisabled(), true);
223 }
224
225 /**
226 * @tc.name: SetDisableFullScreen
227 * @tc.desc: SetDisableFullScreen
228 * @tc.type: FUNC
229 */
230 HWTEST_F(CompatibleModePropertyTest, SetDisableFullScreen, TestSize.Level1)
231 {
232 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
233 property->SetDisableFullScreen(true);
234 EXPECT_EQ(property->disableFullScreen_, true);
235 property->SetDisableFullScreen(false);
236 EXPECT_EQ(property->disableFullScreen_, false);
237 }
238
239 /**
240 * @tc.name: IsFullScreenDisabled
241 * @tc.desc: IsFullScreenDisabled
242 * @tc.type: FUNC
243 */
244 HWTEST_F(CompatibleModePropertyTest, IsFullScreenDisabled, TestSize.Level1)
245 {
246 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
247 EXPECT_EQ(property->IsFullScreenDisabled(), false);
248 property->disableFullScreen_ = true;
249 EXPECT_EQ(property->IsFullScreenDisabled(), true);
250 }
251
252 /**
253 * @tc.name: SetDisableWindowLimit
254 * @tc.desc: SetDisableWindowLimit
255 * @tc.type: FUNC
256 */
257 HWTEST_F(CompatibleModePropertyTest, SetDisableWindowLimit, TestSize.Level1)
258 {
259 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
260 property->SetDisableWindowLimit(true);
261 EXPECT_EQ(property->disableWindowLimit_, true);
262 property->SetDisableWindowLimit(false);
263 EXPECT_EQ(property->disableWindowLimit_, false);
264 }
265
266 /**
267 * @tc.name: IsWindowLimitDisabled
268 * @tc.desc: IsWindowLimitDisabled
269 * @tc.type: FUNC
270 */
271 HWTEST_F(CompatibleModePropertyTest, IsWindowLimitDisabled, TestSize.Level1)
272 {
273 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
274 EXPECT_EQ(property->IsWindowLimitDisabled(), false);
275 property->disableWindowLimit_ = true;
276 EXPECT_EQ(property->IsWindowLimitDisabled(), true);
277 }
278
279 /**
280 * @tc.name: SetDisableDecorFullscreen
281 * @tc.desc: SetDisableDecorFullscreen
282 * @tc.type: FUNC
283 */
284 HWTEST_F(CompatibleModePropertyTest, SetDisableDecorFullscreen, TestSize.Level1)
285 {
286 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
287 property->SetDisableDecorFullscreen(true);
288 EXPECT_EQ(property->disableDecorFullscreen_, true);
289 property->SetDisableDecorFullscreen(false);
290 EXPECT_EQ(property->disableDecorFullscreen_, false);
291 }
292
293 /**
294 * @tc.name: IsDecorFullscreenDisabled
295 * @tc.desc: IsDecorFullscreenDisabled
296 * @tc.type: FUNC
297 */
298 HWTEST_F(CompatibleModePropertyTest, IsDecorFullscreenDisabled, TestSize.Level1)
299 {
300 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
301 EXPECT_EQ(property->IsDecorFullscreenDisabled(), false);
302 property->disableDecorFullscreen_ = true;
303 EXPECT_EQ(property->IsDecorFullscreenDisabled(), true);
304 }
305
306 /**
307 * @tc.name: SetIsAdaptToSimulationScale
308 * @tc.desc: SetIsAdaptToSimulationScale
309 * @tc.type: FUNC
310 */
311 HWTEST_F(CompatibleModePropertyTest, SetIsAdaptToSimulationScale, TestSize.Level1)
312 {
313 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
314 property->SetIsAdaptToSimulationScale(true);
315 EXPECT_EQ(property->isAdaptToSimulationScale_, true);
316 property->SetIsAdaptToSimulationScale(false);
317 EXPECT_EQ(property->isAdaptToSimulationScale_, false);
318 }
319
320 /**
321 * @tc.name: IsAdaptToSimulationScale
322 * @tc.desc: IsAdaptToSimulationScale
323 * @tc.type: FUNC
324 */
325 HWTEST_F(CompatibleModePropertyTest, IsAdaptToSimulationScale, TestSize.Level1)
326 {
327 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
328 EXPECT_EQ(property->IsAdaptToSimulationScale(), false);
329 property->isAdaptToSimulationScale_ = true;
330 EXPECT_EQ(property->IsAdaptToSimulationScale(), true);
331 }
332
333 /**
334 * @tc.name: CopyFrom
335 * @tc.desc: CopyFrom
336 * @tc.type: FUNC
337 */
338 HWTEST_F(CompatibleModePropertyTest, CopyFrom, TestSize.Level1)
339 {
340 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
341 sptr<CompatibleModeProperty> copyProperty = nullptr;
342 property->CopyFrom(copyProperty);
343 EXPECT_EQ(property->IsAdaptToSimulationScale(), false);
344 copyProperty = sptr<CompatibleModeProperty>::MakeSptr();
345 copyProperty->SetIsAdaptToSimulationScale(true);
346 property->CopyFrom(copyProperty);
347 EXPECT_EQ(property->IsAdaptToSimulationScale(), true);
348 }
349
350
351 /**
352 * @tc.name: SetIsSupportRotateFullScreen
353 * @tc.desc: SetIsSupportRotateFullScreen
354 * @tc.type: FUNC
355 */
356 HWTEST_F(CompatibleModePropertyTest, SetIsSupportRotateFullScreen, TestSize.Level1)
357 {
358 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
359 property->SetIsSupportRotateFullScreen(true);
360 EXPECT_EQ(property->isSupportRotateFullScreen_, true);
361 property->SetIsSupportRotateFullScreen(false);
362 EXPECT_EQ(property->isSupportRotateFullScreen_, false);
363 }
364
365 /**
366 * @tc.name: IsSupportRotateFullScreen
367 * @tc.desc: IsSupportRotateFullScreen
368 * @tc.type: FUNC
369 */
370 HWTEST_F(CompatibleModePropertyTest, IsSupportRotateFullScreen, TestSize.Level1)
371 {
372 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
373 EXPECT_EQ(property->IsSupportRotateFullScreen(), false);
374 property->isSupportRotateFullScreen_ = true;
375 EXPECT_EQ(property->IsSupportRotateFullScreen(), true);
376 }
377
378 /**
379 * @tc.name: SetIsAdaptToSubWindow
380 * @tc.desc: SetIsAdaptToSubWindow
381 * @tc.type: FUNC
382 */
383 HWTEST_F(CompatibleModePropertyTest, SetIsAdaptToSubWindow, TestSize.Level1)
384 {
385 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
386 property->SetIsAdaptToSubWindow(true);
387 EXPECT_EQ(property->isAdaptToSubWindow_, true);
388 property->SetIsAdaptToSubWindow(false);
389 EXPECT_EQ(property->isAdaptToSubWindow_, false);
390 }
391
392 /**
393 * @tc.name: IsAdaptToSubWindow
394 * @tc.desc: IsAdaptToSubWindow
395 * @tc.type: FUNC
396 */
397 HWTEST_F(CompatibleModePropertyTest, IsAdaptToSubWindow, TestSize.Level1)
398 {
399 sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
400 EXPECT_EQ(property->IsAdaptToSubWindow(), false);
401 property->isAdaptToSubWindow_ = true;
402 EXPECT_EQ(property->IsAdaptToSubWindow(), true);
403 }
404 } // namespace
405 } // namespace Rosen
406 } // namespace OHOS
407