1 /* 2 * Copyright (c) 2021-2023 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 private: 44 static constexpr uint32_t SET_REFRESHRATE_SLEEP_S = 1; // wait for refreshrate change 45 }; 46 47 /* 48 * Function: GetScreenHDRCapability 49 * Type: Function 50 * Rank: Important(2) 51 * EnvConditions: N/A 52 * CaseDescription: 1. call GetScreenHDRCapability 53 * 2. check ret 54 * @tc.require: IssueI5KGK4 55 */ 56 HWTEST_F(RSInterfacesTest, GetScreenHDRCapability001, Function | SmallTest | Level2) 57 { 58 auto screenId = rsInterfaces->GetDefaultScreenId(); 59 EXPECT_NE(screenId, INVALID_SCREEN_ID); 60 61 RSScreenHDRCapability hdrCapability; 62 int ret = rsInterfaces->GetScreenHDRCapability(screenId, hdrCapability); 63 EXPECT_EQ(ret, StatusCode::SUCCESS); 64 EXPECT_EQ(hdrCapability.GetMaxLum(), 1000); // maxLum now is mock data 65 } 66 67 /* 68 * Function: GetScreenHDRCapability 69 * Type: Function 70 * Rank: Important(2) 71 * EnvConditions: N/A 72 * CaseDescription: 1. call GetScreenHDRCapability with INVALID_SCREEN_ID 73 * 2. check ret 74 * @tc.require: IssueI5KGK4 75 */ 76 HWTEST_F(RSInterfacesTest, GetScreenHDRCapability002, Function | SmallTest | Level2) 77 { 78 RSScreenHDRCapability hdrCapability; 79 int ret = rsInterfaces->GetScreenHDRCapability(INVALID_SCREEN_ID, hdrCapability); 80 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 81 } 82 83 /* 84 * Function: GetScreenType 85 * Type: Function 86 * Rank: Important(2) 87 * EnvConditions: N/A 88 * CaseDescription: 1. call GetScreenType 89 * 2. check ret 90 */ 91 HWTEST_F(RSInterfacesTest, GetScreenType001, Function | SmallTest | Level2) 92 { 93 auto screenId = rsInterfaces->GetDefaultScreenId(); 94 EXPECT_NE(screenId, INVALID_SCREEN_ID); 95 96 RSScreenType type; 97 int ret = rsInterfaces->GetScreenType(screenId, type); 98 EXPECT_EQ(ret, StatusCode::SUCCESS); 99 } 100 101 /* 102 * Function: GetScreenType 103 * Type: Function 104 * Rank: Important(2) 105 * EnvConditions: N/A 106 * CaseDescription: 1. call GetScreenType with INVALID_SCREEN_ID 107 * 2. check ret 108 */ 109 HWTEST_F(RSInterfacesTest, GetScreenType002, Function | SmallTest | Level2) 110 { 111 RSScreenType type; 112 int ret = rsInterfaces->GetScreenType(INVALID_SCREEN_ID, type); 113 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 114 } 115 116 /* 117 * Function: SetVirtualScreenResolution/GetVirtualScreenResolution 118 * Type: Function 119 * Rank: Important(2) 120 * EnvConditions: N/A 121 * CaseDescription: 1. Call CreateVirtualScreen, use normal parameters. 122 * 2. Use SetVirtualScreenResolution to change the width and height of virtualScreen 123 * 3. Use GetVirtualScreenResolution to get current width and height of virtualScreen 124 * 4. Check current width and height of virtualScreen 125 */ 126 HWTEST_F(RSInterfacesTest, SetVirtualScreenResolution001, Function | SmallTest | Level2) 127 { 128 auto csurface = IConsumerSurface::Create(); 129 EXPECT_NE(csurface, nullptr); 130 auto producer = csurface->GetProducer(); 131 auto psurface = Surface::CreateSurfaceAsProducer(producer); 132 uint32_t defaultWidth = 720; 133 uint32_t defaultHeight = 1280; 134 uint32_t newWidth = 1920; 135 uint32_t newHeight = 1080; 136 EXPECT_NE(psurface, nullptr); 137 138 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 139 "virtual5", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 140 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 141 142 auto curVirtualScreenResolution = rsInterfaces->GetVirtualScreenResolution(virtualScreenId); 143 EXPECT_EQ(curVirtualScreenResolution.GetVirtualScreenWidth(), defaultWidth); 144 EXPECT_EQ(curVirtualScreenResolution.GetVirtualScreenHeight(), defaultHeight); 145 146 rsInterfaces->SetVirtualScreenResolution(virtualScreenId, newWidth, newHeight); 147 148 curVirtualScreenResolution = rsInterfaces->GetVirtualScreenResolution(virtualScreenId); 149 EXPECT_EQ(curVirtualScreenResolution.GetVirtualScreenWidth(), newWidth); 150 EXPECT_EQ(curVirtualScreenResolution.GetVirtualScreenHeight(), newHeight); 151 152 rsInterfaces->RemoveVirtualScreen(virtualScreenId); 153 } 154 155 /* 156 * Function: GetAllScreenIds 157 * Type: Function 158 * Rank: Important(2) 159 * EnvConditions: N/A 160 * CaseDescription: 1. call GetAllScreenIds 161 * 2. check vector size 162 */ 163 HWTEST_F(RSInterfacesTest, GetAllScreenIds, Function | SmallTest | Level2) 164 { 165 std::vector<ScreenId> ids = rsInterfaces->GetAllScreenIds(); 166 int32_t size = ids.size(); 167 EXPECT_GT(ids.size(), 0); 168 auto csurface = IConsumerSurface::Create(); 169 EXPECT_NE(csurface, nullptr); 170 auto producer = csurface->GetProducer(); 171 auto psurface = Surface::CreateSurfaceAsProducer(producer); 172 uint32_t defaultWidth = 720; 173 uint32_t defaultHeight = 1280; 174 EXPECT_NE(psurface, nullptr); 175 176 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 177 "virtual6", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 178 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 179 ids = rsInterfaces->GetAllScreenIds(); 180 EXPECT_EQ(size + 1, ids.size()); 181 } 182 183 /* 184 * Function: GetDefaultScreenId 185 * Type: Function 186 * Rank: Important(2) 187 * EnvConditions: N/A 188 * CaseDescription: 1. call GetDefaultScreenId 189 * 2. check ret 190 */ 191 HWTEST_F(RSInterfacesTest, GetDefaultScreenId, Function | SmallTest | Level2) 192 { 193 ScreenId defaultScreenId = rsInterfaces->GetDefaultScreenId(); 194 EXPECT_NE(defaultScreenId, INVALID_SCREEN_ID); 195 } 196 197 /* 198 * Function: CreateVirtualScreen 199 * Type: Function 200 * Rank: Important(2) 201 * EnvConditions: N/A 202 * CaseDescription: 1. call CreateVirtualScreen, use normal parameters. 203 * 2. check ret 204 */ 205 HWTEST_F(RSInterfacesTest, CreateVirtualScreen001, Function | SmallTest | Level2) 206 { 207 auto csurface = IConsumerSurface::Create(); 208 EXPECT_NE(csurface, nullptr); 209 auto producer = csurface->GetProducer(); 210 auto psurface = Surface::CreateSurfaceAsProducer(producer); 211 EXPECT_NE(csurface, nullptr); 212 213 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 214 "virtual0", 320, 180, psurface, INVALID_SCREEN_ID, -1); 215 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 216 217 rsInterfaces->RemoveVirtualScreen(virtualScreenId); 218 } 219 220 /* 221 * Function: CreateVirtualScreen 222 * Type: Function 223 * Rank: Important(2) 224 * EnvConditions: N/A 225 * CaseDescription: 1. call CreateVirtualScreen, use nullptr surface 226 * 2. check ret 227 */ 228 HWTEST_F(RSInterfacesTest, CreateVirtualScreen002, Function | SmallTest | Level2) 229 { 230 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 231 "virtual0", 320, 180, nullptr, INVALID_SCREEN_ID, -1); 232 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 233 rsInterfaces->RemoveVirtualScreen(virtualScreenId); 234 } 235 236 /* 237 * Function: CreateVirtualScreen 238 * Type: Function 239 * Rank: Important(2) 240 * EnvConditions: N/A 241 * CaseDescription: 1. call CreateVirtualScreen twice with the same surface 242 * 2. check ret 243 */ 244 HWTEST_F(RSInterfacesTest, CreateVirtualScreen003, Function | SmallTest | Level2) 245 { 246 auto csurface = IConsumerSurface::Create(); 247 EXPECT_NE(csurface, nullptr); 248 auto producer = csurface->GetProducer(); 249 auto psurface = Surface::CreateSurfaceAsProducer(producer); 250 EXPECT_NE(csurface, nullptr); 251 252 ScreenId virtualScreenId1 = rsInterfaces->CreateVirtualScreen( 253 "virtual1", 320, 180, psurface, INVALID_SCREEN_ID, -1); 254 EXPECT_NE(virtualScreenId1, INVALID_SCREEN_ID); 255 256 ScreenId virtualScreenId2 = rsInterfaces->CreateVirtualScreen( 257 "virtual2", 320, 180, psurface, INVALID_SCREEN_ID, -1); 258 EXPECT_EQ(virtualScreenId2, INVALID_SCREEN_ID); 259 260 rsInterfaces->RemoveVirtualScreen(virtualScreenId1); 261 } 262 263 /* 264 * Function: CreateVirtualScreen 265 * Type: Function 266 * Rank: Important(2) 267 * EnvConditions: N/A 268 * CaseDescription: 1. call CreateVirtualScreen with other get/set funcs 269 * 2. check ret 270 */ 271 HWTEST_F(RSInterfacesTest, CreateVirtualScreen004, Function | SmallTest | Level2) 272 { 273 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 274 "virtual0", 320, 180, nullptr, INVALID_SCREEN_ID, -1); 275 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 276 277 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(virtualScreenId); 278 EXPECT_EQ(supportedScreenModes.size(), 0); 279 280 rsInterfaces->SetScreenActiveMode(virtualScreenId, 0); 281 auto modeInfo = rsInterfaces->GetScreenActiveMode(virtualScreenId); 282 EXPECT_EQ(modeInfo.GetScreenModeId(), -1); 283 284 rsInterfaces->SetScreenPowerStatus(virtualScreenId, ScreenPowerStatus::POWER_STATUS_ON); 285 usleep(50000); // wait 50000us to ensure SetScreenPowerStatus done. 286 auto powerStatus = rsInterfaces->GetScreenPowerStatus(virtualScreenId); 287 EXPECT_EQ(powerStatus, ScreenPowerStatus::INVALID_POWER_STATUS); 288 289 auto screenCapability = rsInterfaces->GetScreenCapability(virtualScreenId); 290 EXPECT_EQ(screenCapability.GetPhyWidth(), 0); 291 EXPECT_EQ(screenCapability.GetName(), "virtual0"); 292 293 auto backLight = rsInterfaces->GetScreenBacklight(virtualScreenId); 294 EXPECT_EQ(backLight, -1); 295 rsInterfaces->RemoveVirtualScreen(virtualScreenId); 296 } 297 298 /* 299 * Function: GetScreenSupportedModes 300 * Type: Function 301 * Rank: Important(2) 302 * EnvConditions: N/A 303 * CaseDescription: 1. call GetScreenSupportedModes 304 * 2. check ret 305 */ 306 HWTEST_F(RSInterfacesTest, GetScreenSupportedModes001, Function | SmallTest | Level2) 307 { 308 auto screenId = rsInterfaces->GetDefaultScreenId(); 309 EXPECT_NE(screenId, INVALID_SCREEN_ID); 310 311 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(screenId); 312 EXPECT_GT(supportedScreenModes.size(), 0); 313 } 314 315 /* 316 * Function: GetScreenSupportedModes 317 * Type: Function 318 * Rank: Important(2) 319 * EnvConditions: N/A 320 * CaseDescription: 1. call GetScreenSupportedModes with INVALID_SCREEN_ID 321 * 2. check ret 322 */ 323 HWTEST_F(RSInterfacesTest, GetScreenSupportedModes002, Function | SmallTest | Level2) 324 { 325 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(INVALID_SCREEN_ID); 326 EXPECT_EQ(supportedScreenModes.size(), 0); 327 } 328 329 /* 330 * Function: SetScreenActiveMode 331 * Type: Function 332 * Rank: Important(2) 333 * EnvConditions: N/A 334 * CaseDescription: 1. call SetScreenActiveMode 335 * 2. check 336 */ 337 HWTEST_F(RSInterfacesTest, SetScreenActiveMode001, Function | SmallTest | Level2) 338 { 339 auto screenId = rsInterfaces->GetDefaultScreenId(); 340 EXPECT_NE(screenId, INVALID_SCREEN_ID); 341 342 rsInterfaces->SetScreenActiveMode(screenId, 0); 343 auto modeInfo = rsInterfaces->GetScreenActiveMode(screenId); 344 EXPECT_EQ(modeInfo.GetScreenModeId(), 0); 345 } 346 347 /* 348 * Function: SetScreenActiveMode 349 * Type: Function 350 * Rank: Important(2) 351 * EnvConditions: N/A 352 * CaseDescription: 1. call SetScreenActiveMode 353 * 2. check 354 */ 355 HWTEST_F(RSInterfacesTest, SetScreenActiveMode002, Function | SmallTest | Level2) 356 { 357 auto screenId = rsInterfaces->GetDefaultScreenId(); 358 EXPECT_NE(screenId, INVALID_SCREEN_ID); 359 360 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(screenId); 361 EXPECT_GT(supportedScreenModes.size(), 0); 362 363 rsInterfaces->SetScreenActiveMode(screenId, 0); 364 auto modeInfo = rsInterfaces->GetScreenActiveMode(screenId); 365 EXPECT_EQ(modeInfo.GetScreenModeId(), 0); 366 } 367 368 /* 369 * Function: GetScreenActiveMode 370 * Type: Function 371 * Rank: Important(2) 372 * EnvConditions: N/A 373 * CaseDescription: 1. call SetScreenActiveMode 374 * 2. check 375 */ 376 HWTEST_F(RSInterfacesTest, GetScreenActiveMode001, Function | SmallTest | Level2) 377 { 378 auto screenId = rsInterfaces->GetDefaultScreenId(); 379 EXPECT_NE(screenId, INVALID_SCREEN_ID); 380 381 rsInterfaces->SetScreenActiveMode(screenId, 0); 382 auto modeInfo = rsInterfaces->GetScreenActiveMode(screenId); 383 EXPECT_EQ(modeInfo.GetScreenModeId(), 0); 384 EXPECT_NE(modeInfo.GetScreenRefreshRate(), 0); 385 EXPECT_NE(modeInfo.GetScreenHeight(), -1); 386 EXPECT_NE(modeInfo.GetScreenWidth(), -1); 387 } 388 389 /* 390 * Function: GetScreenActiveMode 391 * Type: Function 392 * Rank: Important(2) 393 * EnvConditions: N/A 394 * CaseDescription: 1. call SetScreenActiveMode with INVALID_SCREEN_ID 395 * 2. check 396 */ 397 HWTEST_F(RSInterfacesTest, GetScreenActiveMode002, Function | SmallTest | Level2) 398 { 399 auto modeInfo = rsInterfaces->GetScreenActiveMode(INVALID_SCREEN_ID); 400 EXPECT_EQ(modeInfo.GetScreenHeight(), -1); 401 EXPECT_EQ(modeInfo.GetScreenWidth(), -1); 402 } 403 404 /* 405 * Function: SetScreenPowerStatus 406 * Type: Function 407 * Rank: Important(2) 408 * EnvConditions: N/A 409 * CaseDescription: 1. call SetScreenPowerStatus with INVALID_SCREEN_ID 410 * 2. check 411 */ 412 HWTEST_F(RSInterfacesTest, SetScreenPowerStatus001, Function | SmallTest | Level2) 413 { 414 auto screenId = rsInterfaces->GetDefaultScreenId(); 415 EXPECT_NE(screenId, INVALID_SCREEN_ID); 416 417 rsInterfaces->SetScreenPowerStatus(INVALID_SCREEN_ID, ScreenPowerStatus::POWER_STATUS_STANDBY); 418 } 419 420 /* 421 * Function: SetScreenPowerStatus 422 * Type: Function 423 * Rank: Important(2) 424 * EnvConditions: N/A 425 * CaseDescription: 1. call SetScreenPowerStatus with value of POWER_STATUS_ON 426 * 2. check 427 */ 428 HWTEST_F(RSInterfacesTest, SetScreenPowerStatus002, Function | SmallTest | Level2) 429 { 430 auto screenId = rsInterfaces->GetDefaultScreenId(); 431 EXPECT_NE(screenId, INVALID_SCREEN_ID); 432 433 rsInterfaces->SetScreenPowerStatus(screenId, ScreenPowerStatus::POWER_STATUS_ON); 434 usleep(50000); // wait 50000us to ensure SetScreenPowerStatus done. 435 auto powerStatus = rsInterfaces->GetScreenPowerStatus(screenId); 436 EXPECT_EQ(powerStatus, ScreenPowerStatus::POWER_STATUS_ON); 437 } 438 439 /* 440 * Function: GetScreenPowerStatus 441 * Type: Function 442 * Rank: Important(2) 443 * EnvConditions: N/A 444 * CaseDescription: 1. call GetScreenPowerStatus when set POWER_STATUS_ON 445 * 2. check 446 */ 447 HWTEST_F(RSInterfacesTest, GetScreenPowerStatus001, Function | SmallTest | Level2) 448 { 449 auto screenId = rsInterfaces->GetDefaultScreenId(); 450 EXPECT_NE(screenId, INVALID_SCREEN_ID); 451 452 rsInterfaces->SetScreenPowerStatus(screenId, ScreenPowerStatus::POWER_STATUS_ON); 453 usleep(50000); // wait 50000us to ensure SetScreenPowerStatus done. 454 auto powerStatus = rsInterfaces->GetScreenPowerStatus(screenId); 455 EXPECT_EQ(powerStatus, ScreenPowerStatus::POWER_STATUS_ON); 456 } 457 458 /* 459 * Function: GetScreenPowerStatus 460 * Type: Function 461 * Rank: Important(2) 462 * EnvConditions: N/A 463 * CaseDescription: 1. call GetScreenPowerStatus when INVALID screenID 464 * 2. check 465 */ 466 HWTEST_F(RSInterfacesTest, GetScreenPowerStatus002, Function | SmallTest | Level2) 467 { 468 auto powerStatus = rsInterfaces->GetScreenPowerStatus(INVALID_SCREEN_ID); 469 EXPECT_EQ(powerStatus, ScreenPowerStatus::INVALID_POWER_STATUS); 470 } 471 472 /* 473 * Function: GetScreenCapability 474 * Type: Function 475 * Rank: Important(2) 476 * EnvConditions: N/A 477 * CaseDescription: 1. call GetScreenCapability 478 * 2. check 479 */ 480 HWTEST_F(RSInterfacesTest, GetScreenCapability001, Function | SmallTest | Level2) 481 { 482 auto screenId = rsInterfaces->GetDefaultScreenId(); 483 EXPECT_NE(screenId, INVALID_SCREEN_ID); 484 485 auto screenCapability = rsInterfaces->GetScreenCapability(screenId); 486 EXPECT_NE(screenCapability.GetType(), DISP_INVALID); 487 } 488 489 /* 490 * Function: GetScreenCapability 491 * Type: Function 492 * Rank: Important(2) 493 * EnvConditions: N/A 494 * CaseDescription: 1. call GetScreenCapability with INVALID_SCREEN_ID 495 * 2. check 496 */ 497 HWTEST_F(RSInterfacesTest, GetScreenCapability002, Function | SmallTest | Level2) 498 { 499 auto screenCapability = rsInterfaces->GetScreenCapability(INVALID_SCREEN_ID); 500 EXPECT_EQ(screenCapability.GetPhyWidth(), 0); 501 EXPECT_EQ(screenCapability.GetPhyHeight(), 0); 502 } 503 504 /* 505 * Function: GetScreenData 506 * Type: Function 507 * Rank: Important(2) 508 * EnvConditions: N/A 509 * CaseDescription: 1. call GetScreenData 510 * 2. check 511 */ 512 HWTEST_F(RSInterfacesTest, GetScreenData001, Function | SmallTest | Level2) 513 { 514 auto screenId = rsInterfaces->GetDefaultScreenId(); 515 EXPECT_NE(screenId, INVALID_SCREEN_ID); 516 517 auto screenData = rsInterfaces->GetScreenData(screenId); 518 EXPECT_GT(screenData.GetSupportModeInfo().size(), 0); 519 520 auto screenCapability = screenData.GetCapability(); 521 EXPECT_NE(screenCapability.GetType(), DISP_INVALID); 522 523 auto modeInfo = screenData.GetActivityModeInfo(); 524 EXPECT_NE(modeInfo.GetScreenModeId(), -1); 525 EXPECT_NE(modeInfo.GetScreenRefreshRate(), 0); 526 EXPECT_NE(modeInfo.GetScreenHeight(), -1); 527 EXPECT_NE(modeInfo.GetScreenWidth(), -1); 528 } 529 530 /* 531 * Function: GetScreenData 532 * Type: Function 533 * Rank: Important(2) 534 * EnvConditions: N/A 535 * CaseDescription: 1. call GetScreenData with INVALID_SCREEN_ID 536 * 2. check 537 */ 538 HWTEST_F(RSInterfacesTest, GetScreenData002, Function | SmallTest | Level2) 539 { 540 auto screenData = rsInterfaces->GetScreenData(INVALID_SCREEN_ID); 541 EXPECT_EQ(screenData.GetSupportModeInfo().size(), 0); 542 543 auto screenCapability = screenData.GetCapability(); 544 EXPECT_EQ(screenCapability.GetPhyWidth(), 0); 545 EXPECT_EQ(screenCapability.GetPhyHeight(), 0); 546 547 auto modeInfo = screenData.GetActivityModeInfo(); 548 EXPECT_EQ(modeInfo.GetScreenHeight(), -1); 549 EXPECT_EQ(modeInfo.GetScreenWidth(), -1); 550 } 551 552 /* 553 * Function: SetScreenBacklight 554 * Type: Function 555 * Rank: Important(2) 556 * EnvConditions: N/A 557 * CaseDescription: 1. call SetScreenBacklight with value:50 558 * 2. check 559 */ 560 HWTEST_F(RSInterfacesTest, SetScreenBacklight001, Function | SmallTest | Level2) 561 { 562 auto screenId = rsInterfaces->GetDefaultScreenId(); 563 EXPECT_NE(screenId, INVALID_SCREEN_ID); 564 565 rsInterfaces->SetScreenBacklight(screenId, 50); 566 auto backLight = rsInterfaces->GetScreenBacklight(screenId); 567 EXPECT_EQ(backLight, 50); 568 } 569 570 /* 571 * Function: SetScreenBacklight 572 * Type: Function 573 * Rank: Important(2) 574 * EnvConditions: N/A 575 * CaseDescription: 1. call SetScreenBacklight with value:100 576 * 2. check 577 */ 578 HWTEST_F(RSInterfacesTest, SetScreenBacklight002, Function | SmallTest | Level2) 579 { 580 auto screenId = rsInterfaces->GetDefaultScreenId(); 581 EXPECT_NE(screenId, INVALID_SCREEN_ID); 582 583 rsInterfaces->SetScreenBacklight(screenId, 100); 584 auto backLight = rsInterfaces->GetScreenBacklight(screenId); 585 EXPECT_EQ(backLight, 100); 586 } 587 588 /* 589 * Function: GetScreenBacklight 590 * Type: Function 591 * Rank: Important(2) 592 * EnvConditions: N/A 593 * CaseDescription: 1. call GetScreenBacklight with value: 50 594 * 2. check 595 */ 596 HWTEST_F(RSInterfacesTest, GetScreenBacklight001, Function | SmallTest | Level2) 597 { 598 auto screenId = rsInterfaces->GetDefaultScreenId(); 599 EXPECT_NE(screenId, INVALID_SCREEN_ID); 600 601 rsInterfaces->SetScreenBacklight(screenId, 50); 602 auto backLight = rsInterfaces->GetScreenBacklight(screenId); 603 EXPECT_EQ(backLight, 50); 604 } 605 606 /* 607 * Function: GetScreenBacklight 608 * Type: Function 609 * Rank: Important(2) 610 * EnvConditions: N/A 611 * CaseDescription: 1. call GetScreenBacklight INVALID_SCREEN_ID 612 * 2. check 613 */ 614 HWTEST_F(RSInterfacesTest, GetScreenBacklight002, Function | SmallTest | Level2) 615 { 616 auto backLight = rsInterfaces->GetScreenBacklight(INVALID_SCREEN_ID); 617 EXPECT_EQ(backLight, -1); 618 } 619 620 /* 621 * Function: SetScreenChangeCallback 622 * Type: Function 623 * Rank: Important(2) 624 * EnvConditions: N/A 625 * CaseDescription: 1. call SetScreenChangeCallback 626 * 2. wait 2s and check the ret 627 */ 628 HWTEST_F(RSInterfacesTest, SetScreenChangeCallback, Function | SmallTest | Level2) 629 { 630 ScreenId screenId = INVALID_SCREEN_ID; 631 ScreenEvent screenEvent = ScreenEvent::UNKNOWN; 632 bool callbacked = false; __anon79089d2e0102(ScreenId id, ScreenEvent event) 633 auto callback = [&screenId, &screenEvent, &callbacked](ScreenId id, ScreenEvent event) { 634 screenId = id; 635 screenEvent = event; 636 callbacked = true; 637 }; 638 int32_t status = rsInterfaces->SetScreenChangeCallback(callback); 639 EXPECT_EQ(status, StatusCode::SUCCESS); 640 sleep(2); // wait 2s to check if the callback returned. 641 if (status == StatusCode::SUCCESS) { 642 EXPECT_NE(screenId, INVALID_SCREEN_ID); 643 EXPECT_NE(screenEvent, ScreenEvent::UNKNOWN); 644 } else { 645 EXPECT_EQ(screenId, INVALID_SCREEN_ID); 646 EXPECT_EQ(screenEvent, ScreenEvent::UNKNOWN); 647 } 648 } 649 650 /* 651 * Function: GetScreenSupportedColorGamuts 652 * Type: Function 653 * Rank: Important(2) 654 * EnvConditions: N/A 655 * CaseDescription: 1. call GetScreenSupportedColorGamuts with INVALID_SCREEN_ID 656 * 2. check ret 657 */ 658 HWTEST_F(RSInterfacesTest, GetScreenSupportedColorGamuts002, Function | SmallTest | Level2) 659 { 660 std::vector<ScreenColorGamut> modes; 661 int ret = rsInterfaces->GetScreenSupportedColorGamuts(INVALID_SCREEN_ID, modes); 662 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 663 } 664 665 /* 666 * Function: GetScreenSupportedMetaDataKeys 667 * Type: Function 668 * Rank: Important(2) 669 * EnvConditions: N/A 670 * CaseDescription: 1. call GetScreenSupportedMetaDataKeys 671 * 2. check ret 672 * @tc.require: IssueI5KGK4 673 */ 674 HWTEST_F(RSInterfacesTest, GetScreenSupportedMetaDataKeys001, Function | SmallTest | Level2) 675 { 676 auto screenId = rsInterfaces->GetDefaultScreenId(); 677 EXPECT_NE(screenId, INVALID_SCREEN_ID); 678 std::vector<ScreenHDRMetadataKey> keys; 679 int ret = rsInterfaces->GetScreenSupportedMetaDataKeys(screenId, keys); 680 EXPECT_EQ(ret, StatusCode::SUCCESS); 681 EXPECT_EQ(keys[0], ScreenHDRMetadataKey::MATAKEY_RED_PRIMARY_X); // ScreenHDRMetadataKey now is mock data. 682 } 683 684 /* 685 * Function: GetScreenSupportedMetaDataKeys 686 * Type: Function 687 * Rank: Important(2) 688 * EnvConditions: N/A 689 * CaseDescription: 1. call GetScreenSupportedMetaDataKeys with INVALID_SCREEN_ID 690 * 2. check ret 691 * @tc.require: IssueI5KGK4 692 */ 693 HWTEST_F(RSInterfacesTest, GetScreenSupportedMetaDataKeys002, Function | SmallTest | Level2) 694 { 695 std::vector<ScreenHDRMetadataKey> keys; 696 int ret = rsInterfaces->GetScreenSupportedMetaDataKeys(INVALID_SCREEN_ID, keys); 697 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 698 } 699 700 /* 701 * Function: GetScreenColorGamut 702 * Type: Function 703 * Rank: Important(2) 704 * EnvConditions: N/A 705 * CaseDescription: 1. call GetScreenColorGamut with INVALID_SCREEN_ID 706 * 2. check ret 707 */ 708 HWTEST_F(RSInterfacesTest, GetScreenColorGamut002, Function | SmallTest | Level2) 709 { 710 ScreenColorGamut mode = ScreenColorGamut::COLOR_GAMUT_INVALID; 711 int ret = rsInterfaces->GetScreenColorGamut(INVALID_SCREEN_ID, mode); 712 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 713 } 714 715 /* 716 * Function: SetScreenColorGamut 717 * Type: Function 718 * Rank: Important(2) 719 * EnvConditions: N/A 720 * CaseDescription: 1. call SetScreenColorGamut with INVALID_SCREEN_ID 721 * 2. check ret 722 */ 723 HWTEST_F(RSInterfacesTest, SetScreenColorGamut002, Function | SmallTest | Level2) 724 { 725 int ret = rsInterfaces->SetScreenColorGamut(INVALID_SCREEN_ID, 0); 726 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 727 } 728 729 /* 730 * Function: SetScreenGamutMap 731 * Type: Function 732 * Rank: Important(2) 733 * EnvConditions: N/A 734 * CaseDescription: 1. call SetScreenGamutMap with INVALID_SCREEN_ID 735 * 2. check ret 736 */ 737 HWTEST_F(RSInterfacesTest, SetScreenGamutMap002, Function | SmallTest | Level2) 738 { 739 ScreenGamutMap gamutMap = ScreenGamutMap::GAMUT_MAP_CONSTANT; 740 int ret = rsInterfaces->SetScreenGamutMap(INVALID_SCREEN_ID, gamutMap); 741 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 742 } 743 744 /* 745 * Function: GetScreenGamutMap 746 * Type: Function 747 * Rank: Important(2) 748 * EnvConditions: N/A 749 * CaseDescription: 1. call GetScreenGamutMap with INVALID_SCREEN_ID 750 * 2. check ret 751 */ 752 HWTEST_F(RSInterfacesTest, GetScreenGamutMap002, Function | SmallTest | Level2) 753 { 754 ScreenGamutMap gamutMap = ScreenGamutMap::GAMUT_MAP_CONSTANT; 755 int ret = rsInterfaces->GetScreenGamutMap(INVALID_SCREEN_ID, gamutMap); 756 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 757 } 758 759 /* 760 * Function: SetScreenSkipFrameInterval 761 * Type: Function 762 * Rank: Important(2) 763 * EnvConditions: N/A 764 * CaseDescription: 1. call SetScreenSkipFrameInterval with invalid parameters and check ret 765 */ 766 HWTEST_F(RSInterfacesTest, SetScreenSkipFrameInterval001, Function | SmallTest | Level2) 767 { 768 ScreenId screenId = INVALID_SCREEN_ID; 769 uint32_t skipFrameInterval = 1; 770 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 771 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 772 } 773 774 /* 775 * Function: SetScreenSkipFrameInterval 776 * Type: Function 777 * Rank: Important(2) 778 * EnvConditions: N/A 779 * CaseDescription: 1. call SetScreenSkipFrameInterval with invalid parameters and check ret 780 */ 781 HWTEST_F(RSInterfacesTest, SetScreenSkipFrameInterval002, Function | SmallTest | Level2) 782 { 783 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 784 EXPECT_NE(screenId, INVALID_SCREEN_ID); 785 uint32_t skipFrameInterval = 0; 786 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 787 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 788 } 789 790 /* 791 * Function: SetScreenSkipFrameInterval 792 * Type: Function 793 * Rank: Important(2) 794 * EnvConditions: N/A 795 * CaseDescription: 1. call SetScreenSkipFrameInterval with invalid parameters and check ret 796 */ 797 HWTEST_F(RSInterfacesTest, SetScreenSkipFrameInterval003, Function | SmallTest | Level2) 798 { 799 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 800 EXPECT_NE(screenId, INVALID_SCREEN_ID); 801 uint32_t skipFrameInterval = 100; // for test 802 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 803 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 804 } 805 806 /* 807 * Function: SetScreenSkipFrameInterval 808 * Type: Function 809 * Rank: Important(1) 810 * EnvConditions: N/A 811 * CaseDescription: 1. call SetScreenSkipFrameInterval with valid parameters and check ret 812 */ 813 HWTEST_F(RSInterfacesTest, SetScreenSkipFrameInterval004, Function | SmallTest | Level1) 814 { 815 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 816 EXPECT_NE(screenId, INVALID_SCREEN_ID); 817 float skipFrameInterval = 2.1; // for test 818 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 819 EXPECT_EQ(ret, StatusCode::SUCCESS); 820 } 821 822 /* 823 * Function: SetScreenSkipFrameInterval 824 * Type: Function 825 * Rank: Important(1) 826 * EnvConditions: N/A 827 * CaseDescription: 1. call SetScreenSkipFrameInterval with valid parameters and check ret 828 */ 829 HWTEST_F(RSInterfacesTest, SetScreenSkipFrameInterval005, Function | SmallTest | Level1) 830 { 831 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 832 EXPECT_NE(screenId, INVALID_SCREEN_ID); 833 uint32_t skipFrameInterval = 1; 834 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 835 ASSERT_EQ(ret, StatusCode::SUCCESS); 836 } 837 838 /* 839 * @tc.name: ScreenGamutMap_001 840 * @tc.desc: Test SetScreenGamutMap And GetScreenGamutMap 841 * @tc.type: FUNC 842 * @tc.require: issueI60RFZ 843 */ 844 HWTEST_F(RSInterfacesTest, ScreenGamutMap_001, Function | SmallTest | Level2) 845 { 846 ScreenId defaultScreenId = rsInterfaces->GetDefaultScreenId(); 847 ScreenGamutMap mode = ScreenGamutMap::GAMUT_MAP_CONSTANT; 848 uint32_t statusMode = rsInterfaces->SetScreenGamutMap(defaultScreenId, mode); 849 ASSERT_EQ(statusMode, StatusCode::HDI_ERROR); 850 statusMode = rsInterfaces->GetScreenGamutMap(defaultScreenId, mode); 851 ASSERT_EQ(statusMode, StatusCode::HDI_ERROR); 852 } 853 854 /* 855 * @tc.name: RegisterOcclusionChangeCallback Test 856 * @tc.desc: RegisterOcclusionChangeCallback Test 857 * @tc.type: FUNC 858 * @tc.require: 859 */ 860 HWTEST_F(RSInterfacesTest, RegisterOcclusionChangeCallback_Test, Function | SmallTest | Level2) 861 { 862 ASSERT_NE(rsInterfaces, nullptr); __anon79089d2e0202(std::shared_ptr<RSOcclusionData> data)863 OcclusionChangeCallback cb = [](std::shared_ptr<RSOcclusionData> data){}; 864 int32_t ret = rsInterfaces->RegisterOcclusionChangeCallback(cb); 865 ASSERT_EQ(ret, 0); 866 } 867 868 /* 869 * @tc.name: SetVirtualScreenSurface Test a notfound id 870 * @tc.desc: SetVirtualScreenSurface Test a notfound id 871 * @tc.type: FUNC 872 * @tc.require: 873 */ 874 HWTEST_F(RSInterfacesTest, SetVirtualScreenSurface_Test, Function | SmallTest | Level2) 875 { 876 ASSERT_NE(rsInterfaces, nullptr); 877 auto csurface = IConsumerSurface::Create(); 878 ASSERT_NE(csurface, nullptr); 879 auto producer = csurface->GetProducer(); 880 auto psurface = Surface::CreateSurfaceAsProducer(producer); 881 ASSERT_NE(psurface, nullptr); 882 883 int32_t ret = rsInterfaces->SetVirtualScreenSurface(123, psurface); 884 ASSERT_EQ(ret, 0); 885 } 886 887 /* 888 * @tc.name: GetScreenCurrentRefreshRate001 889 * @tc.desc: Verify the function of getting the current refreshrate via rs interfaces 890 * @tc.type: FUNC 891 * @tc.require: I7EM2R 892 */ 893 HWTEST_F(RSInterfacesTest, GetScreenCurrentRefreshRate001, Function | SmallTest | Level2) 894 { 895 auto screenId = rsInterfaces->GetDefaultScreenId(); 896 EXPECT_NE(screenId, INVALID_SCREEN_ID); 897 898 auto modeInfo = rsInterfaces->GetScreenActiveMode(screenId); 899 rsInterfaces->SetScreenRefreshRate(screenId, 0, modeInfo.GetScreenRefreshRate()); 900 uint32_t currentRate = rsInterfaces-> GetScreenCurrentRefreshRate(screenId); 901 EXPECT_EQ(modeInfo.GetScreenRefreshRate(), currentRate); 902 } 903 904 /* 905 * @tc.name: SetScreenRefreshRate001 906 * @tc.desc: Verify the function of setting the refreshrate with 90hz 907 * @tc.type: FUNC 908 * @tc.require: I7EM2R 909 */ 910 HWTEST_F(RSInterfacesTest, SetScreenRefreshRate001, Function | SmallTest | Level2) 911 { 912 auto screenId = rsInterfaces->GetDefaultScreenId(); 913 EXPECT_NE(screenId, INVALID_SCREEN_ID); 914 uint32_t rateToSet = 30; 915 916 rsInterfaces->SetScreenRefreshRate(screenId, 0, rateToSet); 917 sleep(SET_REFRESHRATE_SLEEP_S); 918 uint32_t currentRate = rsInterfaces->GetScreenCurrentRefreshRate(screenId); 919 auto supportedRates = rsInterfaces->GetScreenSupportedRefreshRates(screenId); 920 921 bool ifSupported = false; 922 for (auto rateIter : supportedRates) { 923 if (rateIter == rateToSet) { 924 ifSupported = true; 925 } 926 } 927 if (ifSupported) { 928 EXPECT_GE(currentRate, rateToSet); 929 } else { 930 EXPECT_NE(currentRate, rateToSet); 931 } 932 } 933 934 /* 935 * @tc.name: SetScreenRefreshRate002 936 * @tc.desc: Verify the function of setting the refreshrate with a very high value 937 * @tc.type: FUNC 938 * @tc.require: I7EM2R 939 */ 940 HWTEST_F(RSInterfacesTest, SetScreenRefreshRate002, Function | SmallTest | Level2) 941 { 942 auto screenId = rsInterfaces->GetDefaultScreenId(); 943 EXPECT_NE(screenId, INVALID_SCREEN_ID); 944 uint32_t rateToSet = 990; 945 946 rsInterfaces->SetScreenRefreshRate(screenId, 0, rateToSet); 947 sleep(SET_REFRESHRATE_SLEEP_S); 948 uint32_t currentRate = rsInterfaces->GetScreenCurrentRefreshRate(screenId); 949 EXPECT_NE(currentRate, rateToSet); 950 } 951 952 /* 953 * @tc.name: SetScreenRefreshRate003 954 * @tc.desc: Verify the function of setting the refreshrate with a normal value of 60hz 955 * @tc.type: FUNC 956 * @tc.require: I7EM2R 957 */ 958 HWTEST_F(RSInterfacesTest, SetScreenRefreshRate003, Function | SmallTest | Level2) 959 { 960 auto screenId = rsInterfaces->GetDefaultScreenId(); 961 EXPECT_NE(screenId, INVALID_SCREEN_ID); 962 uint32_t rateToSet = 60; 963 964 rsInterfaces->SetScreenRefreshRate(screenId, 0, rateToSet); 965 sleep(SET_REFRESHRATE_SLEEP_S); 966 uint32_t currentRate = rsInterfaces->GetScreenCurrentRefreshRate(screenId); 967 auto supportedRates = rsInterfaces->GetScreenSupportedRefreshRates(screenId); 968 969 bool ifSupported = false; 970 for (auto rateIter : supportedRates) { 971 if (rateIter == rateToSet) { 972 ifSupported = true; 973 } 974 } 975 if (ifSupported) { 976 EXPECT_GE(currentRate, rateToSet); 977 } else { 978 EXPECT_NE(currentRate, rateToSet); 979 } 980 } 981 982 /* 983 * @tc.name: SetRefreshRateMode001 984 * @tc.desc: Verify the function of setting the refreshrate mode 985 * @tc.type: FUNC 986 * @tc.require: I7EM2R 987 */ 988 HWTEST_F(RSInterfacesTest, SetRefreshRateMode001, Function | SmallTest | Level2) 989 { 990 auto screenId = rsInterfaces->GetDefaultScreenId(); 991 EXPECT_NE(screenId, INVALID_SCREEN_ID); 992 int32_t rateModeToSet = 2; 993 uint32_t formerRate = 60; 994 uint32_t newRate = 90; 995 996 rsInterfaces->SetScreenRefreshRate(screenId, 0, formerRate); 997 sleep(SET_REFRESHRATE_SLEEP_S); 998 rsInterfaces->SetRefreshRateMode(rateModeToSet); 999 sleep(SET_REFRESHRATE_SLEEP_S); 1000 uint32_t currentRate = rsInterfaces->GetScreenCurrentRefreshRate(screenId); 1001 auto supportedRates = rsInterfaces->GetScreenSupportedRefreshRates(screenId); 1002 1003 bool ifSupported = false; 1004 for (auto rateIter : supportedRates) { 1005 if (rateIter == newRate) { 1006 ifSupported = true; 1007 } 1008 } 1009 1010 if (ifSupported) { 1011 EXPECT_GE(currentRate, formerRate); 1012 } else { 1013 EXPECT_NE(currentRate, formerRate); 1014 } 1015 } 1016 } // namespace Rosen 1017 } // namespace OHOS 1018