1 /* 2 * Copyright (c) 2021 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 <hilog/log.h> 18 #include <memory> 19 #include <unistd.h> 20 21 #include "transaction/rs_interfaces.h" 22 23 using namespace testing::ext; 24 25 namespace OHOS { 26 namespace Rosen { 27 class RSInterfacesTest : public testing::Test { 28 public: 29 static constexpr HiviewDFX::HiLogLabel LOG_LABEL = { LOG_CORE, 0, "RSInterfacesTest" }; 30 SetUpTestCase()31 static void SetUpTestCase() 32 { 33 rsInterfaces = &(RSInterfaces::GetInstance()); 34 } 35 TearDownTestCase()36 static void TearDownTestCase() 37 { 38 rsInterfaces = nullptr; 39 } 40 41 static inline RSInterfaces* rsInterfaces = nullptr; 42 }; 43 44 /* 45 * Function: GetDefaultScreenId 46 * Type: Function 47 * Rank: Important(2) 48 * EnvConditions: N/A 49 * CaseDescription: 1. call GetDefaultScreenId 50 * 2. check ret 51 */ 52 HWTEST_F(RSInterfacesTest, GetDefaultScreenId, Function | SmallTest | Level2) 53 { 54 ScreenId defaultScreenId = rsInterfaces->GetDefaultScreenId(); 55 EXPECT_NE(defaultScreenId, INVALID_SCREEN_ID); 56 } 57 58 /* 59 * Function: CreateVirtualScreen 60 * Type: Function 61 * Rank: Important(2) 62 * EnvConditions: N/A 63 * CaseDescription: 1. call CreateVirtualScreen, use normal parameters. 64 * 2. check ret 65 */ 66 HWTEST_F(RSInterfacesTest, CreateVirtualScreen001, Function | SmallTest | Level2) 67 { 68 auto csurface = Surface::CreateSurfaceAsConsumer(); 69 EXPECT_NE(csurface, nullptr); 70 auto producer = csurface->GetProducer(); 71 auto psurface = Surface::CreateSurfaceAsProducer(producer); 72 EXPECT_NE(csurface, nullptr); 73 74 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 75 "virtual0", 320, 180, psurface, INVALID_SCREEN_ID, -1); 76 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 77 78 rsInterfaces->RemoveVirtualScreen(virtualScreenId); 79 } 80 81 /* 82 * Function: CreateVirtualScreen 83 * Type: Function 84 * Rank: Important(2) 85 * EnvConditions: N/A 86 * CaseDescription: 1. call CreateVirtualScreen, use nullptr surface 87 * 2. check ret 88 */ 89 HWTEST_F(RSInterfacesTest, CreateVirtualScreen002, Function | SmallTest | Level2) 90 { 91 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 92 "virtual0", 320, 180, nullptr, INVALID_SCREEN_ID, -1); 93 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 94 rsInterfaces->RemoveVirtualScreen(virtualScreenId); 95 } 96 97 /* 98 * Function: CreateVirtualScreen 99 * Type: Function 100 * Rank: Important(2) 101 * EnvConditions: N/A 102 * CaseDescription: 1. call CreateVirtualScreen twice with the same surface 103 * 2. check ret 104 */ 105 HWTEST_F(RSInterfacesTest, CreateVirtualScreen003, Function | SmallTest | Level2) 106 { 107 auto csurface = Surface::CreateSurfaceAsConsumer(); 108 EXPECT_NE(csurface, nullptr); 109 auto producer = csurface->GetProducer(); 110 auto psurface = Surface::CreateSurfaceAsProducer(producer); 111 EXPECT_NE(csurface, nullptr); 112 113 ScreenId virtualScreenId1 = rsInterfaces->CreateVirtualScreen( 114 "virtual1", 320, 180, psurface, INVALID_SCREEN_ID, -1); 115 EXPECT_NE(virtualScreenId1, INVALID_SCREEN_ID); 116 117 ScreenId virtualScreenId2 = rsInterfaces->CreateVirtualScreen( 118 "virtual2", 320, 180, psurface, INVALID_SCREEN_ID, -1); 119 EXPECT_EQ(virtualScreenId2, INVALID_SCREEN_ID); 120 } 121 122 /* 123 * Function: CreateVirtualScreen 124 * Type: Function 125 * Rank: Important(2) 126 * EnvConditions: N/A 127 * CaseDescription: 1. call CreateVirtualScreen with other get/set funcs 128 * 2. check ret 129 */ 130 HWTEST_F(RSInterfacesTest, CreateVirtualScreen004, Function | SmallTest | Level2) 131 { 132 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 133 "virtual0", 320, 180, nullptr, INVALID_SCREEN_ID, -1); 134 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 135 136 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(virtualScreenId); 137 EXPECT_EQ(supportedScreenModes.size(), 0); 138 139 rsInterfaces->SetScreenActiveMode(virtualScreenId, 0); 140 auto modeInfo = rsInterfaces->GetScreenActiveMode(virtualScreenId); 141 EXPECT_EQ(modeInfo.GetScreenModeId(), -1); 142 143 rsInterfaces->SetScreenPowerStatus(virtualScreenId, ScreenPowerStatus::POWER_STATUS_ON); 144 usleep(50000); // wait 50000us to ensure SetScreenPowerStatus done. 145 auto powerStatus = rsInterfaces->GetScreenPowerStatus(virtualScreenId); 146 EXPECT_EQ(powerStatus, ScreenPowerStatus::INVALID_POWER_STATUS); 147 148 auto screenCapability = rsInterfaces->GetScreenCapability(virtualScreenId); 149 EXPECT_EQ(screenCapability.GetPhyWidth(), 0); 150 EXPECT_EQ(screenCapability.GetName(), "virtual0"); 151 152 auto backLight = rsInterfaces->GetScreenBacklight(virtualScreenId); 153 EXPECT_EQ(backLight, -1); 154 rsInterfaces->RemoveVirtualScreen(virtualScreenId); 155 } 156 157 /* 158 * Function: GetScreenSupportedModes 159 * Type: Function 160 * Rank: Important(2) 161 * EnvConditions: N/A 162 * CaseDescription: 1. call GetScreenSupportedModes 163 * 2. check ret 164 */ 165 HWTEST_F(RSInterfacesTest, GetScreenSupportedModes001, Function | SmallTest | Level2) 166 { 167 auto screenId = rsInterfaces->GetDefaultScreenId(); 168 EXPECT_NE(screenId, INVALID_SCREEN_ID); 169 170 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(screenId); 171 EXPECT_GT(supportedScreenModes.size(), 0); 172 } 173 174 /* 175 * Function: GetScreenSupportedModes 176 * Type: Function 177 * Rank: Important(2) 178 * EnvConditions: N/A 179 * CaseDescription: 1. call GetScreenSupportedModes with INVALID_SCREEN_ID 180 * 2. check ret 181 */ 182 HWTEST_F(RSInterfacesTest, GetScreenSupportedModes002, Function | SmallTest | Level2) 183 { 184 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(INVALID_SCREEN_ID); 185 EXPECT_EQ(supportedScreenModes.size(), 0); 186 } 187 188 /* 189 * Function: SetScreenActiveMode 190 * Type: Function 191 * Rank: Important(2) 192 * EnvConditions: N/A 193 * CaseDescription: 1. call SetScreenActiveMode 194 * 2. check 195 */ 196 HWTEST_F(RSInterfacesTest, SetScreenActiveMode001, Function | SmallTest | Level2) 197 { 198 auto screenId = rsInterfaces->GetDefaultScreenId(); 199 EXPECT_NE(screenId, INVALID_SCREEN_ID); 200 201 rsInterfaces->SetScreenActiveMode(screenId, 0); 202 auto modeInfo = rsInterfaces->GetScreenActiveMode(screenId); 203 EXPECT_EQ(modeInfo.GetScreenModeId(), 0); 204 } 205 206 /* 207 * Function: SetScreenActiveMode 208 * Type: Function 209 * Rank: Important(2) 210 * EnvConditions: N/A 211 * CaseDescription: 1. call SetScreenActiveMode 212 * 2. check 213 */ 214 HWTEST_F(RSInterfacesTest, SetScreenActiveMode002, Function | SmallTest | Level2) 215 { 216 auto screenId = rsInterfaces->GetDefaultScreenId(); 217 EXPECT_NE(screenId, INVALID_SCREEN_ID); 218 219 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(screenId); 220 EXPECT_GT(supportedScreenModes.size(), 0); 221 222 rsInterfaces->SetScreenActiveMode(screenId, 0); 223 auto modeInfo = rsInterfaces->GetScreenActiveMode(screenId); 224 EXPECT_EQ(modeInfo.GetScreenModeId(), 0); 225 } 226 227 /* 228 * Function: GetScreenActiveMode 229 * Type: Function 230 * Rank: Important(2) 231 * EnvConditions: N/A 232 * CaseDescription: 1. call SetScreenActiveMode 233 * 2. check 234 */ 235 HWTEST_F(RSInterfacesTest, GetScreenActiveMode001, Function | SmallTest | Level2) 236 { 237 auto screenId = rsInterfaces->GetDefaultScreenId(); 238 EXPECT_NE(screenId, INVALID_SCREEN_ID); 239 240 rsInterfaces->SetScreenActiveMode(screenId, 0); 241 auto modeInfo = rsInterfaces->GetScreenActiveMode(screenId); 242 EXPECT_EQ(modeInfo.GetScreenModeId(), 0); 243 EXPECT_NE(modeInfo.GetScreenRefreshRate(), 0); 244 EXPECT_NE(modeInfo.GetScreenHeight(), -1); 245 EXPECT_NE(modeInfo.GetScreenWidth(), -1); 246 } 247 248 /* 249 * Function: GetScreenActiveMode 250 * Type: Function 251 * Rank: Important(2) 252 * EnvConditions: N/A 253 * CaseDescription: 1. call SetScreenActiveMode with INVALID_SCREEN_ID 254 * 2. check 255 */ 256 HWTEST_F(RSInterfacesTest, GetScreenActiveMode002, Function | SmallTest | Level2) 257 { 258 auto modeInfo = rsInterfaces->GetScreenActiveMode(INVALID_SCREEN_ID); 259 EXPECT_EQ(modeInfo.GetScreenHeight(), -1); 260 EXPECT_EQ(modeInfo.GetScreenWidth(), -1); 261 } 262 263 /* 264 * Function: SetScreenPowerStatus 265 * Type: Function 266 * Rank: Important(2) 267 * EnvConditions: N/A 268 * CaseDescription: 1. call SetScreenPowerStatus with INVALID_SCREEN_ID 269 * 2. check 270 */ 271 HWTEST_F(RSInterfacesTest, SetScreenPowerStatus001, Function | SmallTest | Level2) 272 { 273 auto screenId = rsInterfaces->GetDefaultScreenId(); 274 EXPECT_NE(screenId, INVALID_SCREEN_ID); 275 276 rsInterfaces->SetScreenPowerStatus(INVALID_SCREEN_ID, ScreenPowerStatus::POWER_STATUS_STANDBY); 277 usleep(50000); // wait 50000us to ensure SetScreenPowerStatus done. 278 auto powerStatus = rsInterfaces->GetScreenPowerStatus(screenId); 279 EXPECT_EQ(powerStatus, ScreenPowerStatus::POWER_STATUS_ON); 280 } 281 282 /* 283 * Function: SetScreenPowerStatus 284 * Type: Function 285 * Rank: Important(2) 286 * EnvConditions: N/A 287 * CaseDescription: 1. call SetScreenPowerStatus with value of POWER_STATUS_ON 288 * 2. check 289 */ 290 HWTEST_F(RSInterfacesTest, SetScreenPowerStatus002, Function | SmallTest | Level2) 291 { 292 auto screenId = rsInterfaces->GetDefaultScreenId(); 293 EXPECT_NE(screenId, INVALID_SCREEN_ID); 294 295 rsInterfaces->SetScreenPowerStatus(screenId, ScreenPowerStatus::POWER_STATUS_ON); 296 usleep(50000); // wait 50000us to ensure SetScreenPowerStatus done. 297 auto powerStatus = rsInterfaces->GetScreenPowerStatus(screenId); 298 EXPECT_EQ(powerStatus, ScreenPowerStatus::POWER_STATUS_ON); 299 } 300 301 /* 302 * Function: GetScreenPowerStatus 303 * Type: Function 304 * Rank: Important(2) 305 * EnvConditions: N/A 306 * CaseDescription: 1. call GetScreenPowerStatus when set POWER_STATUS_ON 307 * 2. check 308 */ 309 HWTEST_F(RSInterfacesTest, GetScreenPowerStatus001, Function | SmallTest | Level2) 310 { 311 auto screenId = rsInterfaces->GetDefaultScreenId(); 312 EXPECT_NE(screenId, INVALID_SCREEN_ID); 313 314 rsInterfaces->SetScreenPowerStatus(screenId, ScreenPowerStatus::POWER_STATUS_ON); 315 usleep(50000); // wait 50000us to ensure SetScreenPowerStatus done. 316 auto powerStatus = rsInterfaces->GetScreenPowerStatus(screenId); 317 EXPECT_EQ(powerStatus, ScreenPowerStatus::POWER_STATUS_ON); 318 } 319 320 /* 321 * Function: GetScreenPowerStatus 322 * Type: Function 323 * Rank: Important(2) 324 * EnvConditions: N/A 325 * CaseDescription: 1. call GetScreenPowerStatus when INVALID screenID 326 * 2. check 327 */ 328 HWTEST_F(RSInterfacesTest, GetScreenPowerStatus002, Function | SmallTest | Level2) 329 { 330 auto powerStatus = rsInterfaces->GetScreenPowerStatus(INVALID_SCREEN_ID); 331 EXPECT_EQ(powerStatus, ScreenPowerStatus::INVALID_POWER_STATUS); 332 } 333 334 /* 335 * Function: GetScreenCapability 336 * Type: Function 337 * Rank: Important(2) 338 * EnvConditions: N/A 339 * CaseDescription: 1. call GetScreenCapability 340 * 2. check 341 */ 342 HWTEST_F(RSInterfacesTest, GetScreenCapability001, Function | SmallTest | Level2) 343 { 344 auto screenId = rsInterfaces->GetDefaultScreenId(); 345 EXPECT_NE(screenId, INVALID_SCREEN_ID); 346 347 auto screenCapability = rsInterfaces->GetScreenCapability(screenId); 348 std::string emptyName; 349 EXPECT_GT(screenCapability.GetPhyWidth(), 0); 350 EXPECT_GT(screenCapability.GetPhyHeight(), 0); 351 EXPECT_NE(screenCapability.GetType(), DISP_INVALID); 352 } 353 354 /* 355 * Function: GetScreenCapability 356 * Type: Function 357 * Rank: Important(2) 358 * EnvConditions: N/A 359 * CaseDescription: 1. call GetScreenCapability with INVALID_SCREEN_ID 360 * 2. check 361 */ 362 HWTEST_F(RSInterfacesTest, GetScreenCapability002, Function | SmallTest | Level2) 363 { 364 auto screenCapability = rsInterfaces->GetScreenCapability(INVALID_SCREEN_ID); 365 EXPECT_EQ(screenCapability.GetPhyWidth(), 0); 366 EXPECT_EQ(screenCapability.GetPhyHeight(), 0); 367 } 368 369 /* 370 * Function: GetScreenData 371 * Type: Function 372 * Rank: Important(2) 373 * EnvConditions: N/A 374 * CaseDescription: 1. call GetScreenData 375 * 2. check 376 */ 377 HWTEST_F(RSInterfacesTest, GetScreenData001, Function | SmallTest | Level2) 378 { 379 auto screenId = rsInterfaces->GetDefaultScreenId(); 380 EXPECT_NE(screenId, INVALID_SCREEN_ID); 381 382 auto screenData = rsInterfaces->GetScreenData(screenId); 383 EXPECT_GT(screenData.GetSupportModeInfo().size(), 0); 384 385 auto screenCapability = screenData.GetCapability(); 386 std::string emptyName; 387 EXPECT_GT(screenCapability.GetPhyWidth(), 0); 388 EXPECT_GT(screenCapability.GetPhyHeight(), 0); 389 EXPECT_NE(screenCapability.GetType(), DISP_INVALID); 390 391 auto modeInfo = screenData.GetActivityModeInfo(); 392 EXPECT_EQ(modeInfo.GetScreenModeId(), 0); 393 EXPECT_NE(modeInfo.GetScreenRefreshRate(), 0); 394 EXPECT_NE(modeInfo.GetScreenHeight(), -1); 395 EXPECT_NE(modeInfo.GetScreenWidth(), -1); 396 } 397 398 /* 399 * Function: GetScreenData 400 * Type: Function 401 * Rank: Important(2) 402 * EnvConditions: N/A 403 * CaseDescription: 1. call GetScreenData with INVALID_SCREEN_ID 404 * 2. check 405 */ 406 HWTEST_F(RSInterfacesTest, GetScreenData002, Function | SmallTest | Level2) 407 { 408 auto screenData = rsInterfaces->GetScreenData(INVALID_SCREEN_ID); 409 EXPECT_EQ(screenData.GetSupportModeInfo().size(), 0); 410 411 auto screenCapability = screenData.GetCapability(); 412 EXPECT_EQ(screenCapability.GetPhyWidth(), 0); 413 EXPECT_EQ(screenCapability.GetPhyHeight(), 0); 414 415 auto modeInfo = screenData.GetActivityModeInfo(); 416 EXPECT_EQ(modeInfo.GetScreenHeight(), -1); 417 EXPECT_EQ(modeInfo.GetScreenWidth(), -1); 418 } 419 420 /* 421 * Function: SetScreenBacklight 422 * Type: Function 423 * Rank: Important(2) 424 * EnvConditions: N/A 425 * CaseDescription: 1. call SetScreenBacklight with value:50 426 * 2. check 427 */ 428 HWTEST_F(RSInterfacesTest, SetScreenBacklight001, Function | SmallTest | Level2) 429 { 430 auto screenId = rsInterfaces->GetDefaultScreenId(); 431 EXPECT_NE(screenId, INVALID_SCREEN_ID); 432 433 rsInterfaces->SetScreenBacklight(screenId, 50); 434 auto backLight = rsInterfaces->GetScreenBacklight(screenId); 435 EXPECT_EQ(backLight, 50); 436 } 437 438 /* 439 * Function: SetScreenBacklight 440 * Type: Function 441 * Rank: Important(2) 442 * EnvConditions: N/A 443 * CaseDescription: 1. call SetScreenBacklight with value:100 444 * 2. check 445 */ 446 HWTEST_F(RSInterfacesTest, SetScreenBacklight002, Function | SmallTest | Level2) 447 { 448 auto screenId = rsInterfaces->GetDefaultScreenId(); 449 EXPECT_NE(screenId, INVALID_SCREEN_ID); 450 451 rsInterfaces->SetScreenBacklight(screenId, 100); 452 auto backLight = rsInterfaces->GetScreenBacklight(screenId); 453 EXPECT_EQ(backLight, 100); 454 } 455 456 /* 457 * Function: GetScreenBacklight 458 * Type: Function 459 * Rank: Important(2) 460 * EnvConditions: N/A 461 * CaseDescription: 1. call GetScreenBacklight with value: 50 462 * 2. check 463 */ 464 HWTEST_F(RSInterfacesTest, GetScreenBacklight001, Function | SmallTest | Level2) 465 { 466 auto screenId = rsInterfaces->GetDefaultScreenId(); 467 EXPECT_NE(screenId, INVALID_SCREEN_ID); 468 469 rsInterfaces->SetScreenBacklight(screenId, 50); 470 auto backLight = rsInterfaces->GetScreenBacklight(screenId); 471 EXPECT_EQ(backLight, 50); 472 } 473 474 /* 475 * Function: GetScreenBacklight 476 * Type: Function 477 * Rank: Important(2) 478 * EnvConditions: N/A 479 * CaseDescription: 1. call GetScreenBacklight INVALID_SCREEN_ID 480 * 2. check 481 */ 482 HWTEST_F(RSInterfacesTest, GetScreenBacklight002, Function | SmallTest | Level2) 483 { 484 auto backLight = rsInterfaces->GetScreenBacklight(INVALID_SCREEN_ID); 485 EXPECT_EQ(backLight, -1); 486 } 487 488 /* 489 * Function: SetScreenChangeCallback 490 * Type: Function 491 * Rank: Important(2) 492 * EnvConditions: N/A 493 * CaseDescription: 1. call SetScreenChangeCallback 494 * 2. wait 2s and check the ret 495 */ 496 HWTEST_F(RSInterfacesTest, SetScreenChangeCallback, Function | SmallTest | Level2) 497 { 498 ScreenId screenId = INVALID_SCREEN_ID; 499 ScreenEvent screenEvent = ScreenEvent::UNKNOWN; 500 bool callbacked = false; __anon0e8b09120102(ScreenId id, ScreenEvent event) 501 auto callback = [&screenId, &screenEvent, &callbacked](ScreenId id, ScreenEvent event) { 502 screenId = id; 503 screenEvent = event; 504 callbacked = true; 505 }; 506 int32_t status = rsInterfaces->SetScreenChangeCallback(callback); 507 EXPECT_EQ(status, StatusCode::SUCCESS); 508 sleep(2); // wait 2s to check if the callback returned. 509 if (status == StatusCode::SUCCESS) { 510 EXPECT_NE(screenId, INVALID_SCREEN_ID); 511 EXPECT_NE(screenEvent, ScreenEvent::UNKNOWN); 512 } else { 513 EXPECT_EQ(screenId, INVALID_SCREEN_ID); 514 EXPECT_EQ(screenEvent, ScreenEvent::UNKNOWN); 515 } 516 } 517 518 /* 519 * Function: RequestRotation 520 * Type: Function 521 * Rank: Important(2) 522 * EnvConditions: N/A 523 * CaseDescription: 1. call RequestRotation with default screenId 524 * 2. check ret 525 */ 526 HWTEST_F(RSInterfacesTest, RequestRotation001, Function | SmallTest | Level2) 527 { 528 auto screenId = rsInterfaces->GetDefaultScreenId(); 529 EXPECT_NE(screenId, INVALID_SCREEN_ID); 530 531 bool res = rsInterfaces->RequestRotation(screenId, ScreenRotation::ROTATION_90); 532 ASSERT_EQ(res, true); 533 534 res = rsInterfaces->RequestRotation(screenId, ScreenRotation::ROTATION_180); 535 ASSERT_EQ(res, true); 536 537 res = rsInterfaces->RequestRotation(screenId, ScreenRotation::ROTATION_270); 538 ASSERT_EQ(res, true); 539 540 res = rsInterfaces->RequestRotation(screenId, ScreenRotation::ROTATION_0); 541 ASSERT_EQ(res, true); 542 } 543 544 /* 545 * Function: RequestRotation 546 * Type: Function 547 * Rank: Important(2) 548 * EnvConditions: N/A 549 * CaseDescription: 1. call RequestRotation with invalid screenId 550 * 2. check ret 551 */ 552 HWTEST_F(RSInterfacesTest, RequestRotation002, Function | SmallTest | Level2) 553 { 554 ScreenId screenId = INVALID_SCREEN_ID; 555 556 bool res = rsInterfaces->RequestRotation(screenId, ScreenRotation::ROTATION_90); 557 ASSERT_EQ(res, false); 558 } 559 560 /* 561 * Function: GetRotation 562 * Type: Function 563 * Rank: Important(2) 564 * EnvConditions: N/A 565 * CaseDescription: 1. call GetRotation with default screenId 566 * 2. check ret 567 */ 568 HWTEST_F(RSInterfacesTest, GetRotation001, Function | SmallTest | Level2) 569 { 570 auto screenId = rsInterfaces->GetDefaultScreenId(); 571 EXPECT_NE(screenId, INVALID_SCREEN_ID); 572 573 ScreenRotation rotation = rsInterfaces->GetRotation(screenId); 574 ASSERT_EQ(rotation, ScreenRotation::ROTATION_0); 575 } 576 577 /* 578 * Function: GetRotation 579 * Type: Function 580 * Rank: Important(2) 581 * EnvConditions: N/A 582 * CaseDescription: 1. call GetRotation with default screenId 583 * 2. check ret 584 */ 585 HWTEST_F(RSInterfacesTest, GetRotation002, Function | SmallTest | Level2) 586 { 587 auto screenId = rsInterfaces->GetDefaultScreenId(); 588 EXPECT_NE(screenId, INVALID_SCREEN_ID); 589 590 bool res = rsInterfaces->RequestRotation(screenId, ScreenRotation::ROTATION_90); 591 ASSERT_EQ(res, true); 592 593 ScreenRotation rotation = rsInterfaces->GetRotation(screenId); 594 ASSERT_EQ(rotation, ScreenRotation::ROTATION_90); 595 } 596 597 /* 598 * Function: GetRotation 599 * Type: Function 600 * Rank: Important(2) 601 * EnvConditions: N/A 602 * CaseDescription: 1. call GetRotation with invalid screenId 603 * 2. check ret 604 */ 605 HWTEST_F(RSInterfacesTest, GetRotation003, Function | SmallTest | Level2) 606 { 607 ScreenId screenId = INVALID_SCREEN_ID; 608 609 ScreenRotation rotation = rsInterfaces->GetRotation(screenId); 610 ASSERT_EQ(rotation, ScreenRotation::INVALID_SCREEN_ROTATION); 611 } 612 613 /* 614 * Function: GetScreenSupportedColorGamuts 615 * Type: Function 616 * Rank: Important(2) 617 * EnvConditions: N/A 618 * CaseDescription: 1. call GetScreenSupportedColorGamuts 619 * 2. check ret 620 */ 621 HWTEST_F(RSInterfacesTest, GetScreenSupportedColorGamuts001, Function | SmallTest | Level2) 622 { 623 auto screenId = rsInterfaces->GetDefaultScreenId(); 624 EXPECT_NE(screenId, INVALID_SCREEN_ID); 625 std::vector<ScreenColorGamut> modes; 626 int ret = rsInterfaces->GetScreenSupportedColorGamuts(screenId, modes); 627 EXPECT_EQ(ret, StatusCode::SUCCESS); 628 } 629 630 /* 631 * Function: GetScreenSupportedColorGamuts 632 * Type: Function 633 * Rank: Important(2) 634 * EnvConditions: N/A 635 * CaseDescription: 1. call GetScreenSupportedColorGamuts with INVALID_SCREEN_ID 636 * 2. check ret 637 */ 638 HWTEST_F(RSInterfacesTest, GetScreenSupportedColorGamuts002, Function | SmallTest | Level2) 639 { 640 std::vector<ScreenColorGamut> modes; 641 int ret = rsInterfaces->GetScreenSupportedColorGamuts(INVALID_SCREEN_ID, modes); 642 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 643 } 644 645 /* 646 * Function: GetScreenColorGamut 647 * Type: Function 648 * Rank: Important(2) 649 * EnvConditions: N/A 650 * CaseDescription: 1. call GetScreenColorGamut 651 * 2. check ret 652 */ 653 HWTEST_F(RSInterfacesTest, GetScreenColorGamut001, Function | SmallTest | Level2) 654 { 655 auto screenId = rsInterfaces->GetDefaultScreenId(); 656 EXPECT_NE(screenId, INVALID_SCREEN_ID); 657 ScreenColorGamut mode = ScreenColorGamut::COLOR_GAMUT_INVALID; 658 int ret = rsInterfaces->GetScreenColorGamut(screenId, mode); 659 EXPECT_EQ(ret, StatusCode::SUCCESS); 660 } 661 662 /* 663 * Function: GetScreenColorGamut 664 * Type: Function 665 * Rank: Important(2) 666 * EnvConditions: N/A 667 * CaseDescription: 1. call GetScreenColorGamut with INVALID_SCREEN_ID 668 * 2. check ret 669 */ 670 HWTEST_F(RSInterfacesTest, GetScreenColorGamut002, Function | SmallTest | Level2) 671 { 672 ScreenColorGamut mode = ScreenColorGamut::COLOR_GAMUT_INVALID; 673 int ret = rsInterfaces->GetScreenColorGamut(INVALID_SCREEN_ID, mode); 674 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 675 } 676 677 /* 678 * Function: SetScreenColorGamut 679 * Type: Function 680 * Rank: Important(2) 681 * EnvConditions: N/A 682 * CaseDescription: 1. call SetScreenColorGamut 683 * 2. check ret 684 */ 685 HWTEST_F(RSInterfacesTest, SetScreenColorGamut001, Function | SmallTest | Level2) 686 { 687 auto screenId = rsInterfaces->GetDefaultScreenId(); 688 EXPECT_NE(screenId, INVALID_SCREEN_ID); 689 int ret = rsInterfaces->SetScreenColorGamut(screenId, 0); 690 EXPECT_EQ(ret, StatusCode::SUCCESS); 691 } 692 693 /* 694 * Function: SetScreenColorGamut 695 * Type: Function 696 * Rank: Important(2) 697 * EnvConditions: N/A 698 * CaseDescription: 1. call SetScreenColorGamut with INVALID_SCREEN_ID 699 * 2. check ret 700 */ 701 HWTEST_F(RSInterfacesTest, SetScreenColorGamut002, Function | SmallTest | Level2) 702 { 703 int ret = rsInterfaces->SetScreenColorGamut(INVALID_SCREEN_ID, 0); 704 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 705 } 706 707 /* 708 * Function: SetScreenGamutMap 709 * Type: Function 710 * Rank: Important(2) 711 * EnvConditions: N/A 712 * CaseDescription: 1. call SetScreenGamutMap 713 * 2. check ret 714 */ 715 HWTEST_F(RSInterfacesTest, SetScreenGamutMap001, Function | SmallTest | Level2) 716 { 717 auto screenId = rsInterfaces->GetDefaultScreenId(); 718 EXPECT_NE(screenId, INVALID_SCREEN_ID); 719 ScreenGamutMap gamutMap = ScreenGamutMap::GAMUT_MAP_CONSTANT; 720 int ret = rsInterfaces->SetScreenGamutMap(screenId, gamutMap); 721 EXPECT_EQ(ret, StatusCode::SUCCESS); 722 } 723 724 /* 725 * Function: SetScreenGamutMap 726 * Type: Function 727 * Rank: Important(2) 728 * EnvConditions: N/A 729 * CaseDescription: 1. call SetScreenGamutMap with INVALID_SCREEN_ID 730 * 2. check ret 731 */ 732 HWTEST_F(RSInterfacesTest, SetScreenGamutMap002, Function | SmallTest | Level2) 733 { 734 ScreenGamutMap gamutMap = ScreenGamutMap::GAMUT_MAP_CONSTANT; 735 int ret = rsInterfaces->SetScreenGamutMap(INVALID_SCREEN_ID, gamutMap); 736 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 737 } 738 739 /* 740 * Function: GetScreenGamutMap 741 * Type: Function 742 * Rank: Important(2) 743 * EnvConditions: N/A 744 * CaseDescription: 1. call GetScreenGamutMap 745 * 2. check ret 746 */ 747 HWTEST_F(RSInterfacesTest, GetScreenGamutMap001, Function | SmallTest | Level2) 748 { 749 auto screenId = rsInterfaces->GetDefaultScreenId(); 750 EXPECT_NE(screenId, INVALID_SCREEN_ID); 751 ScreenGamutMap gamutMap = ScreenGamutMap::GAMUT_MAP_CONSTANT; 752 int ret = rsInterfaces->GetScreenGamutMap(screenId, gamutMap); 753 EXPECT_EQ(ret, StatusCode::SUCCESS); 754 } 755 756 /* 757 * Function: GetScreenGamutMap 758 * Type: Function 759 * Rank: Important(2) 760 * EnvConditions: N/A 761 * CaseDescription: 1. call GetScreenGamutMap with INVALID_SCREEN_ID 762 * 2. check ret 763 */ 764 HWTEST_F(RSInterfacesTest, GetScreenGamutMap002, Function | SmallTest | Level2) 765 { 766 ScreenGamutMap gamutMap = ScreenGamutMap::GAMUT_MAP_CONSTANT; 767 int ret = rsInterfaces->GetScreenGamutMap(INVALID_SCREEN_ID, gamutMap); 768 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 769 } 770 } // namespace Rosen 771 } // namespace OHOS 772