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
18 #include "start_options.h"
19
20 #include <cstring>
21 #include "hilog_tag_wrapper.h"
22 #ifdef START_WINDOW_OPTIONS_WITH_PIXELMAP
23 #include "pixelmap_native_impl.h"
24 #endif
25 #include "start_options_impl.h"
26
27 using namespace testing::ext;
28 namespace OHOS {
29 namespace AAFwk {
30 constexpr int MAX_SUPPOPRT_WINDOW_MODES_SIZE = 10;
31
32 class AbilityRuntimeStartOptionsTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase()40 void AbilityRuntimeStartOptionsTest::SetUpTestCase()
41 {}
42
TearDownTestCase()43 void AbilityRuntimeStartOptionsTest::TearDownTestCase()
44 {}
45
SetUp()46 void AbilityRuntimeStartOptionsTest::SetUp()
47 {}
48
TearDown()49 void AbilityRuntimeStartOptionsTest::TearDown()
50 {}
51
52 /**
53 * @tc.name: OH_AbilityRuntime_CreateStartOptions_001
54 * @tc.desc: OH_AbilityRuntime_CreateStartOptions
55 * @tc.type: FUNC
56 */
57 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_CreateStartOptions_001, TestSize.Level1)
58 {
59 // Arrange
60 AbilityRuntime_StartOptions* startOptions = OH_AbilityRuntime_CreateStartOptions();
61
62 // Act & Assert
63 ASSERT_NE(startOptions, nullptr);
64 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
65 }
66
67 /**
68 * @tc.name: OH_AbilityRuntime_DestroyStartOptions_001
69 * @tc.desc: OH_AbilityRuntime_DestroyStartOptions
70 * @tc.type: FUNC
71 */
72 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_DestroyStartOptions_001, TestSize.Level1)
73 {
74 AbilityRuntime_StartOptions* startOptions = nullptr;
75 EXPECT_EQ(OH_AbilityRuntime_DestroyStartOptions(&startOptions), ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
76 EXPECT_EQ(startOptions, nullptr);
77 }
78
79 /**
80 * @tc.name: OH_AbilityRuntime_DestroyStartOptions_002
81 * @tc.desc: OH_AbilityRuntime_DestroyStartOptions
82 * @tc.type: FUNC
83 */
84 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_DestroyStartOptions_002, TestSize.Level1)
85 {
86 AbilityRuntime_StartOptions* startOptions = OH_AbilityRuntime_CreateStartOptions();
87 EXPECT_EQ(OH_AbilityRuntime_DestroyStartOptions(&startOptions), ABILITY_RUNTIME_ERROR_CODE_NO_ERROR);
88 EXPECT_EQ(startOptions, nullptr);
89 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
90 }
91
92 /**
93 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowMode_001
94 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowMode
95 * @tc.type: FUNC
96 */
97 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowMode_001, TestSize.Level1)
98 {
99 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowMode(nullptr,
100 ABILITY_RUNTIME_WINDOW_MODE_FULL_SCREEN);
101 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
102 }
103
104 /**
105 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowMode_002
106 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowMode
107 * @tc.type: FUNC
108 */
109 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowMode_002, TestSize.Level1)
110 {
111 AbilityRuntime_StartOptions* startOptions = OH_AbilityRuntime_CreateStartOptions();
112 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowMode(startOptions,
113 ABILITY_RUNTIME_WINDOW_MODE_FULL_SCREEN);
114 // Assuming SetStartOptionsWindowMode returns ABILITY_RUNTIME_OK on success
115 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
116 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
117 }
118
119 /**
120 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowMode_003
121 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowMode
122 * @tc.type: FUNC
123 */
124 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowMode_003, TestSize.Level1)
125 {
126 AbilityRuntime_StartOptions* startOptions = OH_AbilityRuntime_CreateStartOptions();
127 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowMode(startOptions,
128 static_cast<AbilityRuntime_WindowMode>(-1));
129 // Assuming ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID is returned for invalid window mode
130 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
131 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
132 }
133
134 /**
135 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowMode_001
136 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowMode
137 * @tc.type: FUNC
138 */
139 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowMode_001, TestSize.Level0)
140 {
141 AbilityRuntime_WindowMode windowMode;
142 AbilityRuntime_ErrorCode errorCode = OH_AbilityRuntime_GetStartOptionsWindowMode(nullptr, windowMode);
143 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, errorCode);
144 }
145
146 /**
147 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowMode_002
148 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowMode
149 * @tc.type: FUNC
150 */
151 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowMode_002, TestSize.Level0)
152 {
153 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
154 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowMode(startOptions,
155 ABILITY_RUNTIME_WINDOW_MODE_FULL_SCREEN);
156 // Assuming SetStartOptionsWindowMode returns ABILITY_RUNTIME_OK on success
157 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
158
159 AbilityRuntime_WindowMode windowMode;
160 AbilityRuntime_ErrorCode errorCode = OH_AbilityRuntime_GetStartOptionsWindowMode(startOptions, windowMode);
161 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, errorCode);
162 EXPECT_EQ(ABILITY_RUNTIME_WINDOW_MODE_FULL_SCREEN, windowMode);
163 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
164 }
165
166 /**
167 * @tc.name: OH_AbilityRuntime_SetStartOptionsDisplayId_001
168 * @tc.desc: OH_AbilityRuntime_SetStartOptionsDisplayId
169 * @tc.type: FUNC
170 */
171 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsDisplayId_001, TestSize.Level1)
172 {
173 AbilityRuntime_StartOptions* startOptions = nullptr;
174 int32_t displayId = 1;
175 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsDisplayId(startOptions, displayId),
176 ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
177 }
178
179 /**
180 * @tc.name: OH_AbilityRuntime_SetStartOptionsDisplayId_002
181 * @tc.desc: OH_AbilityRuntime_SetStartOptionsDisplayId
182 * @tc.type: FUNC
183 */
184 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsDisplayId_002, TestSize.Level1)
185 {
186 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
187 int32_t displayId = 1;
188 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsDisplayId(startOptions, displayId),
189 startOptions->SetStartOptionsDisplayId(displayId));
190 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
191 }
192
193 /**
194 * @tc.name: OH_AbilityRuntime_SetStartOptionsDisplayId_003
195 * @tc.desc: OH_AbilityRuntime_SetStartOptionsDisplayId
196 * @tc.type: FUNC
197 */
198 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsDisplayId_003, TestSize.Level1)
199 {
200 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
201 int32_t displayId = -1;
202 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsDisplayId(startOptions, displayId),
203 startOptions->SetStartOptionsDisplayId(displayId));
204 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
205 }
206
207 /**
208 * @tc.name: OH_AbilityRuntime_SetStartOptionsDisplayId_004
209 * @tc.desc: OH_AbilityRuntime_SetStartOptionsDisplayId
210 * @tc.type: FUNC
211 */
212 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsDisplayId_004, TestSize.Level1)
213 {
214 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
215 int32_t displayId = 0;
216 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsDisplayId(startOptions, displayId),
217 startOptions->SetStartOptionsDisplayId(displayId));
218 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
219 }
220
221 /**
222 * @tc.name: OH_AbilityRuntime_GetStartOptionsDisplayId_001
223 * @tc.desc: OH_AbilityRuntime_GetStartOptionsDisplayId
224 * @tc.type: FUNC
225 */
226 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsDisplayId_001, TestSize.Level1)
227 {
228 // Arrange
229 AbilityRuntime_StartOptions *startOptions = nullptr;
230 int32_t displayId;
231
232 // Act
233 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsDisplayId(startOptions, displayId);
234
235 // Assert
236 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
237 }
238
239 /**
240 * @tc.name: OH_AbilityRuntime_GetStartOptionsDisplayId_002
241 * @tc.desc: OH_AbilityRuntime_GetStartOptionsDisplayId
242 * @tc.type: FUNC
243 */
244 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsDisplayId_002, TestSize.Level1)
245 {
246 // Arrange
247 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
248 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsDisplayId(startOptions, 1);
249 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
250 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
251
252 int32_t displayId;
253
254 // Act
255 result = OH_AbilityRuntime_GetStartOptionsDisplayId(startOptions, displayId);
256
257 // Assert
258 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
259 EXPECT_EQ(1, displayId);
260 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
261 }
262
263 /**
264 * @tc.name: OH_AbilityRuntime_GetStartOptionsDisplayId_003
265 * @tc.desc: OH_AbilityRuntime_GetStartOptionsDisplayId
266 * @tc.type: FUNC
267 */
268 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsDisplayId_003, TestSize.Level1)
269 {
270 // Arrange
271 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
272 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsDisplayId(startOptions, -1);
273 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
274 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
275
276 int32_t displayId;
277
278 // Act
279 result = OH_AbilityRuntime_GetStartOptionsDisplayId(startOptions, displayId);
280
281 // Assert
282 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
283 EXPECT_EQ(-1, displayId);
284 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
285 }
286
287 /**
288 * @tc.name: OH_AbilityRuntime_SetStartOptionsWithAnimation_001
289 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWithAnimation
290 * @tc.type: FUNC
291 */
292 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWithAnimation_001, TestSize.Level1)
293 {
294 // Arrange
295 AbilityRuntime_StartOptions *startOptions = nullptr;
296 bool withAnimation = true;
297
298 // Act
299 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWithAnimation(startOptions, withAnimation);
300
301 // Assert
302 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
303 }
304
305 /**
306 * @tc.name: OH_AbilityRuntime_SetStartOptionsWithAnimation_002
307 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWithAnimation
308 * @tc.type: FUNC
309 */
310 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWithAnimation_002, TestSize.Level1)
311 {
312 // Arrange
313 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
314
315 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWithAnimation(startOptions, true);
316
317 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
318
319 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
320 }
321
322 /**
323 * @tc.name: OH_AbilityRuntime_SetStartOptionsWithAnimation_003
324 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWithAnimation
325 * @tc.type: FUNC
326 */
327 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWithAnimation_003, TestSize.Level1)
328 {
329 // Arrange
330 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
331
332 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWithAnimation(startOptions, false);
333
334 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
335
336 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
337 }
338
339 /**
340 * @tc.name: OH_AbilityRuntime_GetStartOptionsWithAnimation_001
341 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWithAnimation
342 * @tc.type: FUNC
343 */
344 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWithAnimation_001, TestSize.Level1)
345 {
346 // Arrange
347 AbilityRuntime_StartOptions *startOptions = nullptr;
348 bool withAnimation;
349
350 // Act
351 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsWithAnimation(startOptions, withAnimation);
352
353 // Assert
354 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
355 }
356
357 /**
358 * @tc.name: OH_AbilityRuntime_GetStartOptionsWithAnimation_002
359 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWithAnimation
360 * @tc.type: FUNC
361 */
362 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWithAnimation_002, TestSize.Level1)
363 {
364 // Arrange
365 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
366 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWithAnimation(startOptions, true);
367 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
368 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
369
370 bool withAnimation;
371
372 // Act
373 result = OH_AbilityRuntime_GetStartOptionsWithAnimation(startOptions, withAnimation);
374
375 // Assert
376 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
377 EXPECT_EQ(true, withAnimation);
378 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
379 }
380
381 /**
382 * @tc.name: OH_AbilityRuntime_GetStartOptionsWithAnimation_003
383 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWithAnimation
384 * @tc.type: FUNC
385 */
386 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWithAnimation_003, TestSize.Level1)
387 {
388 // Arrange
389 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
390 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWithAnimation(startOptions, false);
391 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
392 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
393
394 bool withAnimation;
395
396 // Act
397 result = OH_AbilityRuntime_GetStartOptionsWithAnimation(startOptions, withAnimation);
398
399 // Assert
400 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
401 EXPECT_EQ(false, withAnimation);
402 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
403 }
404
405 /**
406 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowLeft_001
407 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowLeft
408 * @tc.type: FUNC
409 */
410 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowLeft_001, TestSize.Level1)
411 {
412 AbilityRuntime_StartOptions* startOptions = nullptr;
413 int32_t windowLeft = 100;
414 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowLeft(startOptions, windowLeft),
415 ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
416 }
417
418 /**
419 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowLeft_002
420 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowLeft
421 * @tc.type: FUNC
422 */
423 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowLeft_002, TestSize.Level1)
424 {
425 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
426 int32_t windowLeft = 100;
427 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowLeft(startOptions, windowLeft),
428 startOptions->SetStartOptionsWindowLeft(windowLeft));
429 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
430 }
431
432 /**
433 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowLeft_003
434 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowLeft
435 * @tc.type: FUNC
436 */
437 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowLeft_003, TestSize.Level1)
438 {
439 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
440 int32_t windowLeft = -100;
441 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowLeft(startOptions, windowLeft),
442 startOptions->SetStartOptionsWindowLeft(windowLeft));
443 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
444 }
445
446 /**
447 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowLeft_004
448 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowLeft
449 * @tc.type: FUNC
450 */
451 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowLeft_004, TestSize.Level1)
452 {
453 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
454 int32_t windowLeft = 0;
455 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowLeft(startOptions, windowLeft),
456 startOptions->SetStartOptionsWindowLeft(windowLeft));
457 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
458 }
459
460 /**
461 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowLeft_001
462 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowLeft
463 * @tc.type: FUNC
464 */
465 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowLeft_001, TestSize.Level1)
466 {
467 // Arrange
468 AbilityRuntime_StartOptions *startOptions = nullptr;
469 int32_t windowLeft;
470
471 // Act
472 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsWindowLeft(startOptions, windowLeft);
473
474 // Assert
475 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
476 }
477
478 /**
479 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowLeft_002
480 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowLeft
481 * @tc.type: FUNC
482 */
483 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowLeft_002, TestSize.Level1)
484 {
485 // Arrange
486 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
487 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowLeft(startOptions, 100);
488 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
489 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
490
491 int32_t windowLeft;
492
493 // Act
494 result = OH_AbilityRuntime_GetStartOptionsWindowLeft(startOptions, windowLeft);
495
496 // Assert
497 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
498 EXPECT_EQ(100, windowLeft);
499 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
500 }
501
502 /**
503 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowLeft_003
504 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowLeft
505 * @tc.type: FUNC
506 */
507 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowLeft_003, TestSize.Level1)
508 {
509 // Arrange
510 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
511 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowLeft(startOptions, -100);
512 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
513 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
514
515 int32_t windowLeft;
516
517 // Act
518 result = OH_AbilityRuntime_GetStartOptionsWindowLeft(startOptions, windowLeft);
519
520 // Assert
521 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
522 EXPECT_EQ(-100, windowLeft);
523 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
524 }
525
526 /**
527 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowTop_001
528 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowTop
529 * @tc.type: FUNC
530 */
531 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowTop_001, TestSize.Level1)
532 {
533 AbilityRuntime_StartOptions* startOptions = nullptr;
534 int32_t windowTop = 100;
535 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowTop(startOptions, windowTop),
536 ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
537 }
538
539 /**
540 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowTop_002
541 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowTop
542 * @tc.type: FUNC
543 */
544 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowTop_002, TestSize.Level1)
545 {
546 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
547 int32_t windowTop = 100;
548 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowTop(startOptions, windowTop),
549 startOptions->SetStartOptionsWindowTop(windowTop));
550 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
551 }
552
553 /**
554 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowTop_003
555 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowTop
556 * @tc.type: FUNC
557 */
558 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowTop_003, TestSize.Level1)
559 {
560 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
561 int32_t windowTop = -100;
562 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowTop(startOptions, windowTop),
563 startOptions->SetStartOptionsWindowTop(windowTop));
564 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
565 }
566
567 /**
568 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowTop_004
569 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowTop
570 * @tc.type: FUNC
571 */
572 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowTop_004, TestSize.Level1)
573 {
574 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
575 int32_t windowTop = 0;
576 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowTop(startOptions, windowTop),
577 startOptions->SetStartOptionsWindowTop(windowTop));
578 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
579 }
580
581 /**
582 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowTop_001
583 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowTop
584 * @tc.type: FUNC
585 */
586 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowTop_001, TestSize.Level1)
587 {
588 // Arrange
589 AbilityRuntime_StartOptions *startOptions = nullptr;
590 int32_t windowTop;
591
592 // Act
593 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsWindowTop(startOptions, windowTop);
594
595 // Assert
596 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
597 }
598
599 /**
600 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowTop_002
601 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowTop
602 * @tc.type: FUNC
603 */
604 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowTop_002, TestSize.Level1)
605 {
606 // Arrange
607 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
608 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowTop(startOptions, 100);
609 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
610 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
611
612 int32_t windowTop;
613
614 // Act
615 result = OH_AbilityRuntime_GetStartOptionsWindowTop(startOptions, windowTop);
616
617 // Assert
618 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
619 EXPECT_EQ(100, windowTop);
620 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
621 }
622
623 /**
624 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowTop_003
625 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowTop
626 * @tc.type: FUNC
627 */
628 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowTop_003, TestSize.Level1)
629 {
630 // Arrange
631 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
632 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowTop(startOptions, -100);
633 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
634 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
635
636 int32_t windowTop;
637
638 // Act
639 result = OH_AbilityRuntime_GetStartOptionsWindowTop(startOptions, windowTop);
640
641 // Assert
642 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
643 EXPECT_EQ(-100, windowTop);
644 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
645 }
646
647 /**
648 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowHeight_001
649 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowHeight
650 * @tc.type: FUNC
651 */
652 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowHeight_001, TestSize.Level1)
653 {
654 AbilityRuntime_StartOptions* startOptions = nullptr;
655 int32_t windowHeight = 100;
656 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowHeight(startOptions, windowHeight),
657 ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
658 }
659
660 /**
661 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowHeight_002
662 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowHeight
663 * @tc.type: FUNC
664 */
665 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowHeight_002, TestSize.Level1)
666 {
667 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
668 int32_t windowHeight = 100;
669 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowHeight(startOptions, windowHeight),
670 startOptions->SetStartOptionsWindowHeight(windowHeight));
671 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
672 }
673
674 /**
675 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowHeight_003
676 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowHeight
677 * @tc.type: FUNC
678 */
679 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowHeight_003, TestSize.Level1)
680 {
681 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
682 int32_t windowHeight = -100;
683 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowHeight(startOptions, windowHeight),
684 startOptions->SetStartOptionsWindowHeight(windowHeight));
685 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
686 }
687
688 /**
689 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowHeight_004
690 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowHeight
691 * @tc.type: FUNC
692 */
693 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowHeight_004, TestSize.Level1)
694 {
695 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
696 int32_t windowHeight = 0;
697 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowHeight(startOptions, windowHeight),
698 startOptions->SetStartOptionsWindowHeight(windowHeight));
699 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
700 }
701
702 /**
703 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowHeight_001
704 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowHeight
705 * @tc.type: FUNC
706 */
707 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowHeight_001, TestSize.Level1)
708 {
709 // Arrange
710 AbilityRuntime_StartOptions *startOptions = nullptr;
711 int32_t windowHeight;
712
713 // Act
714 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsWindowHeight(startOptions, windowHeight);
715
716 // Assert
717 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
718 }
719
720 /**
721 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowHeight_002
722 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowHeight
723 * @tc.type: FUNC
724 */
725 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowHeight_002, TestSize.Level1)
726 {
727 // Arrange
728 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
729 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowHeight(startOptions, 100);
730 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
731 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
732
733 int32_t windowHeight;
734
735 // Act
736 result = OH_AbilityRuntime_GetStartOptionsWindowHeight(startOptions, windowHeight);
737
738 // Assert
739 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
740 EXPECT_EQ(100, windowHeight);
741 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
742 }
743
744 /**
745 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowHeight_003
746 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowHeight
747 * @tc.type: FUNC
748 */
749 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowHeight_003, TestSize.Level1)
750 {
751 // Arrange
752 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
753 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowHeight(startOptions, -100);
754 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
755 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
756
757 int32_t windowHeight;
758
759 // Act
760 result = OH_AbilityRuntime_GetStartOptionsWindowHeight(startOptions, windowHeight);
761
762 // Assert
763 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
764 EXPECT_EQ(-100, windowHeight);
765 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
766 }
767
768 /**
769 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowWidth_001
770 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowWidth
771 * @tc.type: FUNC
772 */
773 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowWidth_001, TestSize.Level1)
774 {
775 AbilityRuntime_StartOptions* startOptions = nullptr;
776 int32_t windowWidth = 100;
777 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowWidth(startOptions, windowWidth),
778 ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
779 }
780
781 /**
782 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowWidth_002
783 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowWidth
784 * @tc.type: FUNC
785 */
786 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowWidth_002, TestSize.Level1)
787 {
788 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
789 int32_t windowWidth = 100;
790 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowWidth(startOptions, windowWidth),
791 startOptions->SetStartOptionsWindowWidth(windowWidth));
792 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
793 }
794
795 /**
796 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowWidth_003
797 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowWidth
798 * @tc.type: FUNC
799 */
800 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowWidth_003, TestSize.Level1)
801 {
802 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
803 int32_t windowWidth = -100;
804 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowWidth(startOptions, windowWidth),
805 startOptions->SetStartOptionsWindowWidth(windowWidth));
806 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
807 }
808
809 /**
810 * @tc.name: OH_AbilityRuntime_SetStartOptionsWindowWidth_004
811 * @tc.desc: OH_AbilityRuntime_SetStartOptionsWindowWidth
812 * @tc.type: FUNC
813 */
814 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsWindowWidth_004, TestSize.Level1)
815 {
816 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
817 int32_t windowWidth = 0;
818 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowWidth(startOptions, windowWidth),
819 startOptions->SetStartOptionsWindowWidth(windowWidth));
820 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
821 }
822
823 /**
824 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowWidth_001
825 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowWidth
826 * @tc.type: FUNC
827 */
828 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowWidth_001, TestSize.Level1)
829 {
830 // Arrange
831 AbilityRuntime_StartOptions *startOptions = nullptr;
832 int32_t windowWidth;
833
834 // Act
835 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsWindowWidth(startOptions, windowWidth);
836
837 // Assert
838 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
839 }
840
841 /**
842 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowWidth_002
843 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowWidth
844 * @tc.type: FUNC
845 */
846 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowWidth_002, TestSize.Level1)
847 {
848 // Arrange
849 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
850 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowWidth(startOptions, 100);
851 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
852 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
853
854 int32_t windowWidth;
855
856 // Act
857 result = OH_AbilityRuntime_GetStartOptionsWindowWidth(startOptions, windowWidth);
858
859 // Assert
860 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
861 EXPECT_EQ(100, windowWidth);
862 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
863 }
864
865 /**
866 * @tc.name: OH_AbilityRuntime_GetStartOptionsWindowWidth_003
867 * @tc.desc: OH_AbilityRuntime_GetStartOptionsWindowWidth
868 * @tc.type: FUNC
869 */
870 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsWindowWidth_003, TestSize.Level1)
871 {
872 // Arrange
873 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
874 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsWindowWidth(startOptions, -100);
875 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
876 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
877
878 int32_t windowWidth;
879
880 // Act
881 result = OH_AbilityRuntime_GetStartOptionsWindowWidth(startOptions, windowWidth);
882
883 // Assert
884 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
885 EXPECT_EQ(-100, windowWidth);
886 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
887 }
888
889 /**
890 * @tc.name: OH_AbilityRuntime_SetStartOptionsStartVisibility_001
891 * @tc.desc: OH_AbilityRuntime_SetStartOptionsStartVisibility
892 * @tc.type: FUNC
893 */
894 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsStartVisibility_001, TestSize.Level1)
895 {
896 AbilityRuntime_StartOptions* startOptions = nullptr;
897 AbilityRuntime_StartVisibility startVisibility = AbilityRuntime_StartVisibility::ABILITY_RUNTIME_HIDE_UPON_START;
898 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsWindowWidth(startOptions, startVisibility),
899 ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
900 }
901
902 /**
903 * @tc.name: OH_AbilityRuntime_SetStartOptionsStartVisibility_002
904 * @tc.desc: OH_AbilityRuntime_SetStartOptionsStartVisibility
905 * @tc.type: FUNC
906 */
907 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsStartVisibility_002, TestSize.Level1)
908 {
909 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
910 AbilityRuntime_StartVisibility startVisibility = AbilityRuntime_StartVisibility::ABILITY_RUNTIME_HIDE_UPON_START;
911 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsStartVisibility(startOptions, startVisibility),
912 startOptions->SetStartOptionsStartVisibility(startVisibility));
913 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
914 }
915
916 /**
917 * @tc.name: OH_AbilityRuntime_GetStartOptionsStartVisibility_001
918 * @tc.desc: OH_AbilityRuntime_GetStartOptionsStartVisibility
919 * @tc.type: FUNC
920 */
921 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsStartVisibility_001, TestSize.Level1)
922 {
923 // Arrange
924 AbilityRuntime_StartOptions *startOptions = nullptr;
925 AbilityRuntime_StartVisibility startVisibility;
926
927 // Act
928 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsStartVisibility(startOptions, startVisibility);
929
930 // Assert
931 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
932 }
933
934 /**
935 * @tc.name: OH_AbilityRuntime_GetStartOptionsStartVisibility_002
936 * @tc.desc: OH_AbilityRuntime_GetStartOptionsStartVisibility
937 * @tc.type: FUNC
938 */
939 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsStartVisibility_002, TestSize.Level1)
940 {
941 // Arrange
942 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
943 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsStartVisibility(startOptions,
944 AbilityRuntime_StartVisibility::ABILITY_RUNTIME_SHOW_UPON_START);
945 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
946 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
947
948 AbilityRuntime_StartVisibility startVisibility;
949
950 // Act
951 result = OH_AbilityRuntime_GetStartOptionsStartVisibility(startOptions, startVisibility);
952
953 // Assert
954 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
955 EXPECT_EQ(AbilityRuntime_StartVisibility::ABILITY_RUNTIME_SHOW_UPON_START, startVisibility);
956 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
957
958 result = OH_AbilityRuntime_GetStartOptionsStartVisibility(startOptions, startVisibility);
959 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
960 }
961
962 /**
963 * @tc.name: OH_AbilityRuntime_GetStartOptionsStartVisibility_003
964 * @tc.desc: OH_AbilityRuntime_GetStartOptionsStartVisibility
965 * @tc.type: FUNC
966 */
967 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsStartVisibility_003, TestSize.Level1)
968 {
969 // Arrange
970 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
971 AbilityRuntime_StartVisibility startVisibility;
972
973 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsStartVisibility(startOptions, startVisibility);
974 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
975 }
976
977 /**
978 * @tc.name: OH_AbilityRuntime_SetStartOptionsMinWindowWidth_001
979 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMinWindowWidth
980 * @tc.type: FUNC
981 */
982 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMinWindowWidth_001, TestSize.Level1)
983 {
984 AbilityRuntime_StartOptions* startOptions = nullptr;
985 int32_t minMinWindowWidth = 100;
986 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMinWindowWidth(startOptions, minMinWindowWidth),
987 ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
988 }
989
990 /**
991 * @tc.name: OH_AbilityRuntime_SetStartOptionsMinWindowWidth_002
992 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMinWindowWidth
993 * @tc.type: FUNC
994 */
995 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMinWindowWidth_002, TestSize.Level1)
996 {
997 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
998 int32_t minMinWindowWidth = 100;
999 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMinWindowWidth(startOptions, minMinWindowWidth),
1000 startOptions->SetStartOptionsMinWindowWidth(minMinWindowWidth));
1001 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1002 }
1003
1004 /**
1005 * @tc.name: OH_AbilityRuntime_SetStartOptionsMinWindowWidth_003
1006 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMinWindowWidth
1007 * @tc.type: FUNC
1008 */
1009 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMinWindowWidth_003, TestSize.Level1)
1010 {
1011 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1012 int32_t minMinWindowWidth = -100;
1013 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMinWindowWidth(startOptions, minMinWindowWidth),
1014 startOptions->SetStartOptionsMinWindowWidth(minMinWindowWidth));
1015 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1016 }
1017
1018 /**
1019 * @tc.name: OH_AbilityRuntime_SetStartOptionsMinWindowWidth_004
1020 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMinWindowWidth
1021 * @tc.type: FUNC
1022 */
1023 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMinWindowWidth_004, TestSize.Level1)
1024 {
1025 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1026 int32_t minMinWindowWidth = 0;
1027 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMinWindowWidth(startOptions, minMinWindowWidth),
1028 startOptions->SetStartOptionsMinWindowWidth(minMinWindowWidth));
1029 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1030 }
1031
1032 /**
1033 * @tc.name: OH_AbilityRuntime_GetStartOptionsMinWindowWidth_001
1034 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMinWindowWidth
1035 * @tc.type: FUNC
1036 */
1037 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMinWindowWidth_001, TestSize.Level1)
1038 {
1039 // Arrange
1040 AbilityRuntime_StartOptions *startOptions = nullptr;
1041 int32_t minMinWindowWidth;
1042
1043 // Act
1044 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsMinWindowWidth(startOptions, minMinWindowWidth);
1045
1046 // Assert
1047 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1048 }
1049
1050 /**
1051 * @tc.name: OH_AbilityRuntime_GetStartOptionsMinWindowWidth_002
1052 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMinWindowWidth
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMinWindowWidth_002, TestSize.Level1)
1056 {
1057 // Arrange
1058 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1059 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsMinWindowWidth(startOptions, 100);
1060 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
1061 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1062
1063 int32_t minMinWindowWidth;
1064
1065 // Act
1066 result = OH_AbilityRuntime_GetStartOptionsMinWindowWidth(startOptions, minMinWindowWidth);
1067
1068 // Assert
1069 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1070 EXPECT_EQ(100, minMinWindowWidth);
1071 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1072 }
1073
1074 /**
1075 * @tc.name: OH_AbilityRuntime_GetStartOptionsMinWindowWidth_003
1076 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMinWindowWidth
1077 * @tc.type: FUNC
1078 */
1079 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMinWindowWidth_003, TestSize.Level1)
1080 {
1081 // Arrange
1082 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1083 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsMinWindowWidth(startOptions, -100);
1084 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
1085 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1086
1087 int32_t minMinWindowWidth;
1088
1089 // Act
1090 result = OH_AbilityRuntime_GetStartOptionsMinWindowWidth(startOptions, minMinWindowWidth);
1091
1092 // Assert
1093 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1094 EXPECT_EQ(-100, minMinWindowWidth);
1095 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1096 }
1097
1098 /**
1099 * @tc.name: OH_AbilityRuntime_SetStartOptionsMaxWindowWidth_001
1100 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMaxWindowWidth
1101 * @tc.type: FUNC
1102 */
1103 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMaxWindowWidth_001, TestSize.Level1)
1104 {
1105 AbilityRuntime_StartOptions* startOptions = nullptr;
1106 int32_t maxWindowWidth = 100;
1107 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMaxWindowWidth(startOptions, maxWindowWidth),
1108 ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
1109 }
1110
1111 /**
1112 * @tc.name: OH_AbilityRuntime_SetStartOptionsMaxWindowWidth_002
1113 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMaxWindowWidth
1114 * @tc.type: FUNC
1115 */
1116 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMaxWindowWidth_002, TestSize.Level1)
1117 {
1118 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1119 int32_t maxWindowWidth = 100;
1120 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMaxWindowWidth(startOptions, maxWindowWidth),
1121 startOptions->SetStartOptionsMaxWindowWidth(maxWindowWidth));
1122 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1123 }
1124
1125 /**
1126 * @tc.name: OH_AbilityRuntime_SetStartOptionsMaxWindowWidth_003
1127 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMaxWindowWidth
1128 * @tc.type: FUNC
1129 */
1130 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMaxWindowWidth_003, TestSize.Level1)
1131 {
1132 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1133 int32_t maxWindowWidth = -100;
1134 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMaxWindowWidth(startOptions, maxWindowWidth),
1135 startOptions->SetStartOptionsMaxWindowWidth(maxWindowWidth));
1136 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1137 }
1138
1139 /**
1140 * @tc.name: OH_AbilityRuntime_SetStartOptionsMaxWindowWidth_004
1141 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMaxWindowWidth
1142 * @tc.type: FUNC
1143 */
1144 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMaxWindowWidth_004, TestSize.Level1)
1145 {
1146 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1147 int32_t maxWindowWidth = 0;
1148 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMaxWindowWidth(startOptions, maxWindowWidth),
1149 startOptions->SetStartOptionsMaxWindowWidth(maxWindowWidth));
1150 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1151 }
1152
1153 /**
1154 * @tc.name: OH_AbilityRuntime_GetStartOptionsMaxWindowWidth_001
1155 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMaxWindowWidth
1156 * @tc.type: FUNC
1157 */
1158 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMaxWindowWidth_001, TestSize.Level1)
1159 {
1160 // Arrange
1161 AbilityRuntime_StartOptions *startOptions = nullptr;
1162 int32_t maxWindowWidth;
1163
1164 // Act
1165 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsMaxWindowWidth(startOptions, maxWindowWidth);
1166
1167 // Assert
1168 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1169 }
1170
1171 /**
1172 * @tc.name: OH_AbilityRuntime_GetStartOptionsMaxWindowWidth_002
1173 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMaxWindowWidth
1174 * @tc.type: FUNC
1175 */
1176 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMaxWindowWidth_002, TestSize.Level1)
1177 {
1178 // Arrange
1179 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1180 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsMaxWindowWidth(startOptions, 100);
1181 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
1182 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1183
1184 int32_t maxWindowWidth;
1185
1186 // Act
1187 result = OH_AbilityRuntime_GetStartOptionsMaxWindowWidth(startOptions, maxWindowWidth);
1188
1189 // Assert
1190 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1191 EXPECT_EQ(100, maxWindowWidth);
1192 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1193 }
1194
1195 /**
1196 * @tc.name: OH_AbilityRuntime_GetStartOptionsMaxWindowWidth_003
1197 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMaxWindowWidth
1198 * @tc.type: FUNC
1199 */
1200 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMaxWindowWidth_003, TestSize.Level1)
1201 {
1202 // Arrange
1203 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1204 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsMaxWindowWidth(startOptions, -100);
1205 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
1206 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1207
1208 int32_t maxWindowWidth;
1209
1210 // Act
1211 result = OH_AbilityRuntime_GetStartOptionsMaxWindowWidth(startOptions, maxWindowWidth);
1212
1213 // Assert
1214 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1215 EXPECT_EQ(-100, maxWindowWidth);
1216 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1217 }
1218
1219 /**
1220 * @tc.name: OH_AbilityRuntime_SetStartOptionsMaxWindowHeight_001
1221 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMaxWindowHeight
1222 * @tc.type: FUNC
1223 */
1224 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMaxWindowHeight_001, TestSize.Level1)
1225 {
1226 AbilityRuntime_StartOptions* startOptions = nullptr;
1227 int32_t maxWindowHeight = 100;
1228 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMaxWindowHeight(startOptions, maxWindowHeight),
1229 ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
1230 }
1231
1232 /**
1233 * @tc.name: OH_AbilityRuntime_SetStartOptionsMaxWindowHeight_002
1234 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMaxWindowHeight
1235 * @tc.type: FUNC
1236 */
1237 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMaxWindowHeight_002, TestSize.Level1)
1238 {
1239 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1240 int32_t maxWindowHeight = 100;
1241 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMaxWindowHeight(startOptions, maxWindowHeight),
1242 startOptions->SetStartOptionsMaxWindowHeight(maxWindowHeight));
1243 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1244 }
1245
1246 /**
1247 * @tc.name: OH_AbilityRuntime_SetStartOptionsMaxWindowHeight_003
1248 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMaxWindowHeight
1249 * @tc.type: FUNC
1250 */
1251 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMaxWindowHeight_003, TestSize.Level1)
1252 {
1253 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1254 int32_t maxWindowHeight = -100;
1255 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMaxWindowHeight(startOptions, maxWindowHeight),
1256 startOptions->SetStartOptionsMaxWindowHeight(maxWindowHeight));
1257 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1258 }
1259
1260 /**
1261 * @tc.name: OH_AbilityRuntime_SetStartOptionsMaxWindowHeight_004
1262 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMaxWindowHeight
1263 * @tc.type: FUNC
1264 */
1265 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMaxWindowHeight_004, TestSize.Level1)
1266 {
1267 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1268 int32_t maxWindowHeight = 0;
1269 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMaxWindowHeight(startOptions, maxWindowHeight),
1270 startOptions->SetStartOptionsMaxWindowHeight(maxWindowHeight));
1271 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1272 }
1273
1274 /**
1275 * @tc.name: OH_AbilityRuntime_GetStartOptionsMaxWindowHeight_001
1276 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMaxWindowHeight
1277 * @tc.type: FUNC
1278 */
1279 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMaxWindowHeight_001, TestSize.Level1)
1280 {
1281 // Arrange
1282 AbilityRuntime_StartOptions *startOptions = nullptr;
1283 int32_t maxWindowHeight;
1284
1285 // Act
1286 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsMaxWindowHeight(startOptions, maxWindowHeight);
1287
1288 // Assert
1289 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1290 }
1291
1292 /**
1293 * @tc.name: OH_AbilityRuntime_GetStartOptionsMaxWindowHeight_002
1294 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMaxWindowHeight
1295 * @tc.type: FUNC
1296 */
1297 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMaxWindowHeight_002, TestSize.Level1)
1298 {
1299 // Arrange
1300 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1301 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsMaxWindowHeight(startOptions, 100);
1302 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
1303 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1304
1305 int32_t maxWindowHeight;
1306
1307 // Act
1308 result = OH_AbilityRuntime_GetStartOptionsMaxWindowHeight(startOptions, maxWindowHeight);
1309
1310 // Assert
1311 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1312 EXPECT_EQ(100, maxWindowHeight);
1313 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1314 }
1315
1316 /**
1317 * @tc.name: OH_AbilityRuntime_GetStartOptionsMaxWindowHeight_003
1318 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMaxWindowHeight
1319 * @tc.type: FUNC
1320 */
1321 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMaxWindowHeight_003, TestSize.Level1)
1322 {
1323 // Arrange
1324 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1325 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsMaxWindowHeight(startOptions, -100);
1326 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
1327 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1328
1329 int32_t maxWindowHeight;
1330
1331 // Act
1332 result = OH_AbilityRuntime_GetStartOptionsMaxWindowHeight(startOptions, maxWindowHeight);
1333
1334 // Assert
1335 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1336 EXPECT_EQ(-100, maxWindowHeight);
1337 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1338 }
1339
1340 /**
1341 * @tc.name: OH_AbilityRuntime_SetStartOptionsMinWindowHeight_001
1342 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMinWindowHeight
1343 * @tc.type: FUNC
1344 */
1345 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMinWindowHeight_001, TestSize.Level1)
1346 {
1347 AbilityRuntime_StartOptions* startOptions = nullptr;
1348 int32_t minWindowHeight = 100;
1349 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMinWindowHeight(startOptions, minWindowHeight),
1350 ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
1351 }
1352
1353 /**
1354 * @tc.name: OH_AbilityRuntime_SetStartOptionsMinWindowHeight_002
1355 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMinWindowHeight
1356 * @tc.type: FUNC
1357 */
1358 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMinWindowHeight_002, TestSize.Level1)
1359 {
1360 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1361 int32_t minWindowHeight = 100;
1362 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMinWindowHeight(startOptions, minWindowHeight),
1363 startOptions->SetStartOptionsMinWindowHeight(minWindowHeight));
1364 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1365 }
1366
1367 /**
1368 * @tc.name: OH_AbilityRuntime_SetStartOptionsMinWindowHeight_003
1369 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMinWindowHeight
1370 * @tc.type: FUNC
1371 */
1372 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMinWindowHeight_003, TestSize.Level1)
1373 {
1374 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1375 int32_t minWindowHeight = -100;
1376 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMinWindowHeight(startOptions, minWindowHeight),
1377 startOptions->SetStartOptionsMinWindowHeight(minWindowHeight));
1378 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1379 }
1380
1381 /**
1382 * @tc.name: OH_AbilityRuntime_SetStartOptionsMinWindowHeight_004
1383 * @tc.desc: OH_AbilityRuntime_SetStartOptionsMinWindowHeight
1384 * @tc.type: FUNC
1385 */
1386 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsMinWindowHeight_004, TestSize.Level1)
1387 {
1388 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1389 int32_t minWindowHeight = 0;
1390 EXPECT_EQ(OH_AbilityRuntime_SetStartOptionsMinWindowHeight(startOptions, minWindowHeight),
1391 startOptions->SetStartOptionsMinWindowHeight(minWindowHeight));
1392 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1393 }
1394
1395 /**
1396 * @tc.name: OH_AbilityRuntime_GetStartOptionsMinWindowHeight_001
1397 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMinWindowHeight
1398 * @tc.type: FUNC
1399 */
1400 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMinWindowHeight_001, TestSize.Level1)
1401 {
1402 // Arrange
1403 AbilityRuntime_StartOptions *startOptions = nullptr;
1404 int32_t minWindowHeight;
1405
1406 // Act
1407 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsMinWindowHeight(startOptions, minWindowHeight);
1408
1409 // Assert
1410 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1411 }
1412
1413 /**
1414 * @tc.name: OH_AbilityRuntime_GetStartOptionsMinWindowHeight_002
1415 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMinWindowHeight
1416 * @tc.type: FUNC
1417 */
1418 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMinWindowHeight_002, TestSize.Level1)
1419 {
1420 // Arrange
1421 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1422 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsMinWindowHeight(startOptions, 100);
1423 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
1424 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1425
1426 int32_t minWindowHeight;
1427
1428 // Act
1429 result = OH_AbilityRuntime_GetStartOptionsMinWindowHeight(startOptions, minWindowHeight);
1430
1431 // Assert
1432 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1433 EXPECT_EQ(100, minWindowHeight);
1434 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1435 }
1436
1437 /**
1438 * @tc.name: OH_AbilityRuntime_GetStartOptionsMinWindowHeight_003
1439 * @tc.desc: OH_AbilityRuntime_GetStartOptionsMinWindowHeight
1440 * @tc.type: FUNC
1441 */
1442 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsMinWindowHeight_003, TestSize.Level1)
1443 {
1444 // Arrange
1445 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1446 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsMinWindowHeight(startOptions, -100);
1447 // Assuming OH_AbilityRuntime_SetStartOptionsWindowMode returns success
1448 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1449
1450 int32_t minWindowHeight;
1451
1452 // Act
1453 result = OH_AbilityRuntime_GetStartOptionsMinWindowHeight(startOptions, minWindowHeight);
1454
1455 // Assert
1456 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1457 EXPECT_EQ(-100, minWindowHeight);
1458 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1459 }
1460
1461 /**
1462 * @tc.name: OH_AbilityRuntime_SetStartOptionsStartWindowIcon_001
1463 * @tc.desc: OH_AbilityRuntime_SetStartOptionsStartWindowIcon
1464 * @tc.type: FUNC
1465 */
1466 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsStartWindowIcon_001, TestSize.Level1)
1467 {
1468 // Arrange
1469 AbilityRuntime_StartOptions *startOptions = nullptr;
1470 OH_PixelmapNative *startWindowIcon = nullptr;
1471 #ifdef START_WINDOW_OPTIONS_WITH_PIXELMAP
1472 startWindowIcon = new OH_PixelmapNative(nullptr);
1473 #endif
1474
1475 // Act
1476 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsStartWindowIcon(startOptions, startWindowIcon);
1477
1478 // Assert
1479 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1480 #ifdef START_WINDOW_OPTIONS_WITH_PIXELMAP
1481 delete startWindowIcon;
1482 #endif
1483 }
1484
1485 /**
1486 * @tc.name: OH_AbilityRuntime_SetStartOptionsStartWindowIcon_002
1487 * @tc.desc: OH_AbilityRuntime_SetStartOptionsStartWindowIcon
1488 * @tc.type: FUNC
1489 */
1490 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsStartWindowIcon_002, TestSize.Level1)
1491 {
1492 // Arrange
1493 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1494 EXPECT_NE(startOptions, nullptr);
1495 OH_PixelmapNative *startWindowIcon = nullptr;
1496 #ifdef START_WINDOW_OPTIONS_WITH_PIXELMAP
1497 startWindowIcon = new OH_PixelmapNative(nullptr);
1498 #endif
1499 // Act
1500 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsStartWindowIcon(startOptions, startWindowIcon);
1501
1502 // Assert
1503 EXPECT_EQ(startOptions->SetStartOptionsStartWindowIcon(startWindowIcon), result);
1504
1505 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1506 #ifdef START_WINDOW_OPTIONS_WITH_PIXELMAP
1507 delete startWindowIcon;
1508 #endif
1509 }
1510
1511 /**
1512 * @tc.name: OH_AbilityRuntime_GetStartOptionsStartWindowIcon_001
1513 * @tc.desc: OH_AbilityRuntime_GetStartOptionsStartWindowIcon
1514 * @tc.type: FUNC
1515 */
1516 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsStartWindowIcon_001, TestSize.Level1)
1517 {
1518 // Arrange
1519 AbilityRuntime_StartOptions *startOptions = nullptr;
1520 OH_PixelmapNative *startWindowIcon = nullptr;
1521
1522 // Act
1523 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsStartWindowIcon(startOptions, &startWindowIcon);
1524
1525 // Assert
1526 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1527 }
1528
1529 /**
1530 * @tc.name: OH_AbilityRuntime_GetStartOptionsStartWindowIcon_002
1531 * @tc.desc: OH_AbilityRuntime_GetStartOptionsStartWindowIcon
1532 * @tc.type: FUNC
1533 */
1534 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsStartWindowIcon_002, TestSize.Level1)
1535 {
1536 // Arrange
1537 TAG_LOGI(AAFwkTag::APPKIT, "OH_AbilityRuntime_GetStartOptionsStartWindowIcon_002 begin");
1538 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1539 EXPECT_NE(startOptions, nullptr);
1540
1541 AbilityRuntime_ErrorCode result = ABILITY_RUNTIME_ERROR_CODE_NO_ERROR;
1542 #ifdef START_WINDOW_OPTIONS_WITH_PIXELMAP
1543 OH_PixelmapNative *startWindowIcon = new OH_PixelmapNative(nullptr);
1544 result = OH_AbilityRuntime_SetStartOptionsStartWindowIcon(startOptions, startWindowIcon);
1545 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1546 #endif
1547
1548 // Act
1549 OH_PixelmapNative *newStartWindowIcon = nullptr;
1550 result = OH_AbilityRuntime_GetStartOptionsStartWindowIcon(startOptions, &newStartWindowIcon);
1551
1552 // Assert
1553 #ifdef START_WINDOW_OPTIONS_WITH_PIXELMAP
1554 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1555 EXPECT_EQ(newStartWindowIcon, nullptr);
1556 #else
1557 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1558 #endif
1559
1560 #ifdef START_WINDOW_OPTIONS_WITH_PIXELMAP
1561 delete startWindowIcon;
1562 #endif
1563 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1564 TAG_LOGI(AAFwkTag::APPKIT, "OH_AbilityRuntime_GetStartOptionsStartWindowIcon_002 end");
1565 }
1566
1567 /**
1568 * @tc.name: OH_AbilityRuntime_GetStartOptionsStartWindowIcon_003
1569 * @tc.desc: OH_AbilityRuntime_GetStartOptionsStartWindowIcon
1570 * @tc.type: FUNC
1571 */
1572 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsStartWindowIcon_003, TestSize.Level1)
1573 {
1574 // Arrange
1575 TAG_LOGI(AAFwkTag::APPKIT, "OH_AbilityRuntime_GetStartOptionsStartWindowIcon_003 begin");
1576 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1577 EXPECT_NE(startOptions, nullptr);
1578
1579 OH_PixelmapNative *startWindowIcon = nullptr;
1580
1581 // Act
1582 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_GetStartOptionsStartWindowIcon(startOptions, &startWindowIcon);
1583
1584 // Assert
1585 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1586
1587 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1588 TAG_LOGI(AAFwkTag::APPKIT, "OH_AbilityRuntime_GetStartOptionsStartWindowIcon_003 end");
1589 }
1590
1591 /**
1592 * @tc.name: OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor_001
1593 * @tc.desc: OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor
1594 * @tc.type: FUNC
1595 */
1596 HWTEST_F(AbilityRuntimeStartOptionsTest,
1597 OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor_001, TestSize.Level1)
1598 {
1599 // Arrange
1600 AbilityRuntime_StartOptions *startOptions = nullptr;
1601 const char *startWindowBackgroundColor = "FFFFFF";
1602
1603 // Act
1604 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor(
1605 startOptions, startWindowBackgroundColor);
1606
1607 // Assert
1608 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1609 }
1610
1611 /**
1612 * @tc.name: OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor_002
1613 * @tc.desc: OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor
1614 * @tc.type: FUNC
1615 */
1616 HWTEST_F(AbilityRuntimeStartOptionsTest,
1617 OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor_002, TestSize.Level1)
1618 {
1619 // Arrange
1620 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1621 EXPECT_NE(startOptions, nullptr);
1622 const char *startWindowBackgroundColor = "FFFFFF";
1623
1624 // Act
1625 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor(
1626 startOptions, startWindowBackgroundColor);
1627
1628 // Assert
1629 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1630 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1631 }
1632
1633 /**
1634 * @tc.name: OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor_003
1635 * @tc.desc: OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor
1636 * @tc.type: FUNC
1637 */
1638 HWTEST_F(AbilityRuntimeStartOptionsTest,
1639 OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor_003, TestSize.Level1)
1640 {
1641 // Arrange
1642 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1643 EXPECT_NE(startOptions, nullptr);
1644 const char *startWindowBackgroundColor = nullptr;
1645
1646 // Act
1647 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor(
1648 startOptions, startWindowBackgroundColor);
1649
1650 // Assert
1651 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1652 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1653 }
1654
1655 /**
1656 * @tc.name: OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor_001
1657 * @tc.desc: OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor
1658 * @tc.type: FUNC
1659 */
1660 HWTEST_F(AbilityRuntimeStartOptionsTest,
1661 OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor_001, TestSize.Level1)
1662 {
1663 AbilityRuntime_StartOptions *startOptions = nullptr;
1664 char *startWindowBackgroundColor;
1665 size_t size;
1666 EXPECT_EQ(OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor(
1667 startOptions, &startWindowBackgroundColor, size), ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
1668 }
1669
1670 /**
1671 * @tc.name: OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor_002
1672 * @tc.desc: OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor
1673 * @tc.type: FUNC
1674 */
1675 HWTEST_F(AbilityRuntimeStartOptionsTest,
1676 OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor_002, TestSize.Level1)
1677 {
1678 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1679 EXPECT_NE(startOptions, nullptr);
1680
1681 char originalStartWindowBackgroundColor[] = "FFFFFF";
1682 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor(
1683 startOptions, originalStartWindowBackgroundColor);
1684 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1685
1686 char *startWindowBackgroundColor = nullptr;
1687 size_t size = 0;
1688 EXPECT_EQ(OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor(startOptions,
1689 &startWindowBackgroundColor, size), ABILITY_RUNTIME_ERROR_CODE_NO_ERROR);
1690 EXPECT_EQ(strcmp(startWindowBackgroundColor, originalStartWindowBackgroundColor), 0);
1691 EXPECT_EQ(size, strlen(originalStartWindowBackgroundColor));
1692 free(startWindowBackgroundColor);
1693 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1694 }
1695
1696 /**
1697 * @tc.name: OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor_003
1698 * @tc.desc: OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor
1699 * @tc.type: FUNC
1700 */
1701 HWTEST_F(AbilityRuntimeStartOptionsTest,
1702 OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor_003, TestSize.Level1)
1703 {
1704 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1705 EXPECT_NE(startOptions, nullptr);
1706
1707 char originalStartWindowBackgroundColor[] = "";
1708 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsStartWindowBackgroundColor(
1709 startOptions, originalStartWindowBackgroundColor);
1710 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1711
1712 char *startWindowBackgroundColor = nullptr;
1713 size_t size = 0;
1714 EXPECT_EQ(OH_AbilityRuntime_GetStartOptionsStartWindowBackgroundColor(
1715 startOptions, &startWindowBackgroundColor, size), ABILITY_RUNTIME_ERROR_CODE_NO_ERROR);
1716 EXPECT_EQ(size, 0);
1717 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1718 }
1719
1720 /**
1721 * @tc.name: OH_AbilityRuntime_SetStartOptionsSupportedWindowModes_001
1722 * @tc.desc: OH_AbilityRuntime_SetStartOptionsSupportedWindowModes
1723 * @tc.type: FUNC
1724 */
1725 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsSupportedWindowModes_001, TestSize.Level1)
1726 {
1727 // Arrange
1728 AbilityRuntime_StartOptions *startOptions = nullptr;
1729 AbilityRuntime_SupportedWindowMode *supportedWindowModes = nullptr;
1730 size_t size = 0;
1731
1732 // Act
1733 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsSupportedWindowModes(
1734 startOptions, supportedWindowModes, size);
1735
1736 // Assert
1737 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1738 }
1739
1740 /**
1741 * @tc.name: OH_AbilityRuntime_SetStartOptionsSupportedWindowModes_002
1742 * @tc.desc: OH_AbilityRuntime_SetStartOptionsSupportedWindowModes
1743 * @tc.type: FUNC
1744 */
1745 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsSupportedWindowModes_002, TestSize.Level1)
1746 {
1747 // Arrange
1748 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1749 EXPECT_NE(startOptions, nullptr);
1750
1751 AbilityRuntime_SupportedWindowMode supportedWindowModes[1] = { ABILITY_RUNTIME_SUPPORTED_WINDOW_MODE_FULL_SCREEN };
1752 size_t size = 1;
1753
1754 // Act
1755 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsSupportedWindowModes(
1756 startOptions, supportedWindowModes, size);
1757
1758 // Assert
1759 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1760 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1761 }
1762
1763 /**
1764 * @tc.name: OH_AbilityRuntime_SetStartOptionsSupportedWindowModes_003
1765 * @tc.desc: OH_AbilityRuntime_SetStartOptionsSupportedWindowModes
1766 * @tc.type: FUNC
1767 */
1768 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsSupportedWindowModes_003, TestSize.Level1)
1769 {
1770 // Arrange
1771 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1772 EXPECT_NE(startOptions, nullptr);
1773
1774 AbilityRuntime_SupportedWindowMode *supportedWindowModes = nullptr;
1775 size_t size = 0; // Invalid size
1776
1777 // Act
1778 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsSupportedWindowModes(
1779 startOptions, supportedWindowModes, size);
1780
1781 // Assert
1782 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1783 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1784 }
1785
1786 /**
1787 * @tc.name: OH_AbilityRuntime_SetStartOptionsSupportedWindowModes_004
1788 * @tc.desc: OH_AbilityRuntime_SetStartOptionsSupportedWindowModes
1789 * @tc.type: FUNC
1790 */
1791 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_SetStartOptionsSupportedWindowModes_004, TestSize.Level1)
1792 {
1793 // Arrange
1794 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1795 EXPECT_NE(startOptions, nullptr);
1796
1797 AbilityRuntime_SupportedWindowMode supportedWindowModes[1] = { ABILITY_RUNTIME_SUPPORTED_WINDOW_MODE_FULL_SCREEN };
1798 size_t size = MAX_SUPPOPRT_WINDOW_MODES_SIZE + 1; // Invalid size
1799
1800 // Act
1801 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsSupportedWindowModes(
1802 startOptions, supportedWindowModes, size);
1803
1804 // Assert
1805 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID, result);
1806 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1807 }
1808
1809 /**
1810 * @tc.name: OH_AbilityRuntime_GetStartOptionsSupportedWindowModes_001
1811 * @tc.desc: OH_AbilityRuntime_GetStartOptionsSupportedWindowModes
1812 * @tc.type: FUNC
1813 */
1814 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsSupportedWindowModes_001, TestSize.Level1)
1815 {
1816 AbilityRuntime_SupportedWindowMode *supportedWindowModes = nullptr;
1817 size_t size = 0;
1818 EXPECT_EQ(OH_AbilityRuntime_GetStartOptionsSupportedWindowModes(nullptr, &supportedWindowModes, size),
1819 ABILITY_RUNTIME_ERROR_CODE_PARAM_INVALID);
1820 }
1821
1822 /**
1823 * @tc.name: OH_AbilityRuntime_GetStartOptionsSupportedWindowModes_002
1824 * @tc.desc: OH_AbilityRuntime_GetStartOptionsSupportedWindowModes
1825 * @tc.type: FUNC
1826 */
1827 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsSupportedWindowModes_002, TestSize.Level1)
1828 {
1829 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1830 EXPECT_NE(startOptions, nullptr);
1831
1832 AbilityRuntime_SupportedWindowMode supportedWindowModes[1] = { ABILITY_RUNTIME_SUPPORTED_WINDOW_MODE_FULL_SCREEN };
1833 size_t size = 1;
1834
1835 AbilityRuntime_ErrorCode result = OH_AbilityRuntime_SetStartOptionsSupportedWindowModes(
1836 startOptions, supportedWindowModes, size);
1837 EXPECT_EQ(ABILITY_RUNTIME_ERROR_CODE_NO_ERROR, result);
1838
1839 // Act
1840 AbilityRuntime_SupportedWindowMode *newSupportWindowModes = nullptr;
1841 size_t newSize = 0;
1842 EXPECT_EQ(OH_AbilityRuntime_GetStartOptionsSupportedWindowModes(startOptions, &newSupportWindowModes, newSize),
1843 ABILITY_RUNTIME_ERROR_CODE_NO_ERROR);
1844 EXPECT_NE(newSupportWindowModes, nullptr);
1845 EXPECT_EQ(newSize, 1);
1846 free(newSupportWindowModes);
1847 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1848 }
1849
1850 /**
1851 * @tc.name: OH_AbilityRuntime_GetStartOptionsSupportedWindowModes_003
1852 * @tc.desc: OH_AbilityRuntime_GetStartOptionsSupportedWindowModes
1853 * @tc.type: FUNC
1854 */
1855 HWTEST_F(AbilityRuntimeStartOptionsTest, OH_AbilityRuntime_GetStartOptionsSupportedWindowModes_003, TestSize.Level1)
1856 {
1857 AbilityRuntime_StartOptions *startOptions = OH_AbilityRuntime_CreateStartOptions();
1858 EXPECT_NE(startOptions, nullptr);
1859
1860 // Act
1861 AbilityRuntime_SupportedWindowMode *newSupportWindowModes = nullptr;
1862 size_t newSize = 0;
1863 EXPECT_EQ(OH_AbilityRuntime_GetStartOptionsSupportedWindowModes(startOptions, &newSupportWindowModes, newSize),
1864 ABILITY_RUNTIME_ERROR_CODE_NO_ERROR);
1865 EXPECT_EQ(newSupportWindowModes, nullptr);
1866 EXPECT_EQ(newSize, 0);
1867 OH_AbilityRuntime_DestroyStartOptions(&startOptions);
1868 }
1869 } // namespace AppExecFwk
1870 } // namespace OHOS
1871