1 /* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 #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 rsInterfaces->RemoveVirtualScreen(virtualScreenId1); 122 } 123 124 /* 125 * Function: CreateVirtualScreen 126 * Type: Function 127 * Rank: Important(2) 128 * EnvConditions: N/A 129 * CaseDescription: 1. call CreateVirtualScreen with other get/set funcs 130 * 2. check ret 131 */ 132 HWTEST_F(RSInterfacesTest, CreateVirtualScreen004, Function | SmallTest | Level2) 133 { 134 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 135 "virtual0", 320, 180, nullptr, INVALID_SCREEN_ID, -1); 136 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 137 138 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(virtualScreenId); 139 EXPECT_EQ(supportedScreenModes.size(), 0); 140 141 rsInterfaces->SetScreenActiveMode(virtualScreenId, 0); 142 auto modeInfo = rsInterfaces->GetScreenActiveMode(virtualScreenId); 143 EXPECT_EQ(modeInfo.GetScreenModeId(), -1); 144 145 rsInterfaces->SetScreenPowerStatus(virtualScreenId, ScreenPowerStatus::POWER_STATUS_ON); 146 usleep(50000); // wait 50000us to ensure SetScreenPowerStatus done. 147 auto powerStatus = rsInterfaces->GetScreenPowerStatus(virtualScreenId); 148 EXPECT_EQ(powerStatus, ScreenPowerStatus::INVALID_POWER_STATUS); 149 150 auto screenCapability = rsInterfaces->GetScreenCapability(virtualScreenId); 151 EXPECT_EQ(screenCapability.GetPhyWidth(), 0); 152 EXPECT_EQ(screenCapability.GetName(), "virtual0"); 153 154 auto backLight = rsInterfaces->GetScreenBacklight(virtualScreenId); 155 EXPECT_EQ(backLight, -1); 156 rsInterfaces->RemoveVirtualScreen(virtualScreenId); 157 } 158 159 /* 160 * Function: GetScreenSupportedModes 161 * Type: Function 162 * Rank: Important(2) 163 * EnvConditions: N/A 164 * CaseDescription: 1. call GetScreenSupportedModes 165 * 2. check ret 166 */ 167 HWTEST_F(RSInterfacesTest, GetScreenSupportedModes001, Function | SmallTest | Level2) 168 { 169 auto screenId = rsInterfaces->GetDefaultScreenId(); 170 EXPECT_NE(screenId, INVALID_SCREEN_ID); 171 172 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(screenId); 173 EXPECT_GT(supportedScreenModes.size(), 0); 174 } 175 176 /* 177 * Function: GetScreenSupportedModes 178 * Type: Function 179 * Rank: Important(2) 180 * EnvConditions: N/A 181 * CaseDescription: 1. call GetScreenSupportedModes with INVALID_SCREEN_ID 182 * 2. check ret 183 */ 184 HWTEST_F(RSInterfacesTest, GetScreenSupportedModes002, Function | SmallTest | Level2) 185 { 186 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(INVALID_SCREEN_ID); 187 EXPECT_EQ(supportedScreenModes.size(), 0); 188 } 189 190 /* 191 * Function: SetScreenActiveMode 192 * Type: Function 193 * Rank: Important(2) 194 * EnvConditions: N/A 195 * CaseDescription: 1. call SetScreenActiveMode 196 * 2. check 197 */ 198 HWTEST_F(RSInterfacesTest, SetScreenActiveMode001, Function | SmallTest | Level2) 199 { 200 auto screenId = rsInterfaces->GetDefaultScreenId(); 201 EXPECT_NE(screenId, INVALID_SCREEN_ID); 202 203 rsInterfaces->SetScreenActiveMode(screenId, 0); 204 auto modeInfo = rsInterfaces->GetScreenActiveMode(screenId); 205 EXPECT_EQ(modeInfo.GetScreenModeId(), 0); 206 } 207 208 /* 209 * Function: SetScreenActiveMode 210 * Type: Function 211 * Rank: Important(2) 212 * EnvConditions: N/A 213 * CaseDescription: 1. call SetScreenActiveMode 214 * 2. check 215 */ 216 HWTEST_F(RSInterfacesTest, SetScreenActiveMode002, Function | SmallTest | Level2) 217 { 218 auto screenId = rsInterfaces->GetDefaultScreenId(); 219 EXPECT_NE(screenId, INVALID_SCREEN_ID); 220 221 auto supportedScreenModes = rsInterfaces->GetScreenSupportedModes(screenId); 222 EXPECT_GT(supportedScreenModes.size(), 0); 223 224 rsInterfaces->SetScreenActiveMode(screenId, 0); 225 auto modeInfo = rsInterfaces->GetScreenActiveMode(screenId); 226 EXPECT_EQ(modeInfo.GetScreenModeId(), 0); 227 } 228 229 /* 230 * Function: GetScreenActiveMode 231 * Type: Function 232 * Rank: Important(2) 233 * EnvConditions: N/A 234 * CaseDescription: 1. call SetScreenActiveMode 235 * 2. check 236 */ 237 HWTEST_F(RSInterfacesTest, GetScreenActiveMode001, Function | SmallTest | Level2) 238 { 239 auto screenId = rsInterfaces->GetDefaultScreenId(); 240 EXPECT_NE(screenId, INVALID_SCREEN_ID); 241 242 rsInterfaces->SetScreenActiveMode(screenId, 0); 243 auto modeInfo = rsInterfaces->GetScreenActiveMode(screenId); 244 EXPECT_EQ(modeInfo.GetScreenModeId(), 0); 245 EXPECT_NE(modeInfo.GetScreenRefreshRate(), 0); 246 EXPECT_NE(modeInfo.GetScreenHeight(), -1); 247 EXPECT_NE(modeInfo.GetScreenWidth(), -1); 248 } 249 250 /* 251 * Function: GetScreenActiveMode 252 * Type: Function 253 * Rank: Important(2) 254 * EnvConditions: N/A 255 * CaseDescription: 1. call SetScreenActiveMode with INVALID_SCREEN_ID 256 * 2. check 257 */ 258 HWTEST_F(RSInterfacesTest, GetScreenActiveMode002, Function | SmallTest | Level2) 259 { 260 auto modeInfo = rsInterfaces->GetScreenActiveMode(INVALID_SCREEN_ID); 261 EXPECT_EQ(modeInfo.GetScreenHeight(), -1); 262 EXPECT_EQ(modeInfo.GetScreenWidth(), -1); 263 } 264 265 /* 266 * Function: SetScreenPowerStatus 267 * Type: Function 268 * Rank: Important(2) 269 * EnvConditions: N/A 270 * CaseDescription: 1. call SetScreenPowerStatus with INVALID_SCREEN_ID 271 * 2. check 272 */ 273 HWTEST_F(RSInterfacesTest, SetScreenPowerStatus001, Function | SmallTest | Level2) 274 { 275 auto screenId = rsInterfaces->GetDefaultScreenId(); 276 EXPECT_NE(screenId, INVALID_SCREEN_ID); 277 278 rsInterfaces->SetScreenPowerStatus(INVALID_SCREEN_ID, ScreenPowerStatus::POWER_STATUS_STANDBY); 279 } 280 281 /* 282 * Function: SetScreenPowerStatus 283 * Type: Function 284 * Rank: Important(2) 285 * EnvConditions: N/A 286 * CaseDescription: 1. call SetScreenPowerStatus with value of POWER_STATUS_ON 287 * 2. check 288 */ 289 HWTEST_F(RSInterfacesTest, SetScreenPowerStatus002, Function | SmallTest | Level2) 290 { 291 auto screenId = rsInterfaces->GetDefaultScreenId(); 292 EXPECT_NE(screenId, INVALID_SCREEN_ID); 293 294 rsInterfaces->SetScreenPowerStatus(screenId, ScreenPowerStatus::POWER_STATUS_ON); 295 usleep(50000); // wait 50000us to ensure SetScreenPowerStatus done. 296 auto powerStatus = rsInterfaces->GetScreenPowerStatus(screenId); 297 EXPECT_EQ(powerStatus, ScreenPowerStatus::POWER_STATUS_ON); 298 } 299 300 /* 301 * Function: GetScreenPowerStatus 302 * Type: Function 303 * Rank: Important(2) 304 * EnvConditions: N/A 305 * CaseDescription: 1. call GetScreenPowerStatus when set POWER_STATUS_ON 306 * 2. check 307 */ 308 HWTEST_F(RSInterfacesTest, GetScreenPowerStatus001, Function | SmallTest | Level2) 309 { 310 auto screenId = rsInterfaces->GetDefaultScreenId(); 311 EXPECT_NE(screenId, INVALID_SCREEN_ID); 312 313 rsInterfaces->SetScreenPowerStatus(screenId, ScreenPowerStatus::POWER_STATUS_ON); 314 usleep(50000); // wait 50000us to ensure SetScreenPowerStatus done. 315 auto powerStatus = rsInterfaces->GetScreenPowerStatus(screenId); 316 EXPECT_EQ(powerStatus, ScreenPowerStatus::POWER_STATUS_ON); 317 } 318 319 /* 320 * Function: GetScreenPowerStatus 321 * Type: Function 322 * Rank: Important(2) 323 * EnvConditions: N/A 324 * CaseDescription: 1. call GetScreenPowerStatus when INVALID screenID 325 * 2. check 326 */ 327 HWTEST_F(RSInterfacesTest, GetScreenPowerStatus002, Function | SmallTest | Level2) 328 { 329 auto powerStatus = rsInterfaces->GetScreenPowerStatus(INVALID_SCREEN_ID); 330 EXPECT_EQ(powerStatus, ScreenPowerStatus::INVALID_POWER_STATUS); 331 } 332 333 /* 334 * Function: GetScreenCapability 335 * Type: Function 336 * Rank: Important(2) 337 * EnvConditions: N/A 338 * CaseDescription: 1. call GetScreenCapability 339 * 2. check 340 */ 341 HWTEST_F(RSInterfacesTest, GetScreenCapability001, Function | SmallTest | Level2) 342 { 343 auto screenId = rsInterfaces->GetDefaultScreenId(); 344 EXPECT_NE(screenId, INVALID_SCREEN_ID); 345 346 auto screenCapability = rsInterfaces->GetScreenCapability(screenId); 347 EXPECT_NE(screenCapability.GetType(), DISP_INVALID); 348 } 349 350 /* 351 * Function: GetScreenCapability 352 * Type: Function 353 * Rank: Important(2) 354 * EnvConditions: N/A 355 * CaseDescription: 1. call GetScreenCapability with INVALID_SCREEN_ID 356 * 2. check 357 */ 358 HWTEST_F(RSInterfacesTest, GetScreenCapability002, Function | SmallTest | Level2) 359 { 360 auto screenCapability = rsInterfaces->GetScreenCapability(INVALID_SCREEN_ID); 361 EXPECT_EQ(screenCapability.GetPhyWidth(), 0); 362 EXPECT_EQ(screenCapability.GetPhyHeight(), 0); 363 } 364 365 /* 366 * Function: GetScreenData 367 * Type: Function 368 * Rank: Important(2) 369 * EnvConditions: N/A 370 * CaseDescription: 1. call GetScreenData 371 * 2. check 372 */ 373 HWTEST_F(RSInterfacesTest, GetScreenData001, Function | SmallTest | Level2) 374 { 375 auto screenId = rsInterfaces->GetDefaultScreenId(); 376 EXPECT_NE(screenId, INVALID_SCREEN_ID); 377 378 auto screenData = rsInterfaces->GetScreenData(screenId); 379 EXPECT_GT(screenData.GetSupportModeInfo().size(), 0); 380 381 auto screenCapability = screenData.GetCapability(); 382 EXPECT_NE(screenCapability.GetType(), DISP_INVALID); 383 384 auto modeInfo = screenData.GetActivityModeInfo(); 385 EXPECT_NE(modeInfo.GetScreenModeId(), -1); 386 EXPECT_NE(modeInfo.GetScreenRefreshRate(), 0); 387 EXPECT_NE(modeInfo.GetScreenHeight(), -1); 388 EXPECT_NE(modeInfo.GetScreenWidth(), -1); 389 } 390 391 /* 392 * Function: GetScreenData 393 * Type: Function 394 * Rank: Important(2) 395 * EnvConditions: N/A 396 * CaseDescription: 1. call GetScreenData with INVALID_SCREEN_ID 397 * 2. check 398 */ 399 HWTEST_F(RSInterfacesTest, GetScreenData002, Function | SmallTest | Level2) 400 { 401 auto screenData = rsInterfaces->GetScreenData(INVALID_SCREEN_ID); 402 EXPECT_EQ(screenData.GetSupportModeInfo().size(), 0); 403 404 auto screenCapability = screenData.GetCapability(); 405 EXPECT_EQ(screenCapability.GetPhyWidth(), 0); 406 EXPECT_EQ(screenCapability.GetPhyHeight(), 0); 407 408 auto modeInfo = screenData.GetActivityModeInfo(); 409 EXPECT_EQ(modeInfo.GetScreenHeight(), -1); 410 EXPECT_EQ(modeInfo.GetScreenWidth(), -1); 411 } 412 413 /* 414 * Function: SetScreenBacklight 415 * Type: Function 416 * Rank: Important(2) 417 * EnvConditions: N/A 418 * CaseDescription: 1. call SetScreenBacklight with value:50 419 * 2. check 420 */ 421 HWTEST_F(RSInterfacesTest, SetScreenBacklight001, Function | SmallTest | Level2) 422 { 423 auto screenId = rsInterfaces->GetDefaultScreenId(); 424 EXPECT_NE(screenId, INVALID_SCREEN_ID); 425 426 rsInterfaces->SetScreenBacklight(screenId, 50); 427 auto backLight = rsInterfaces->GetScreenBacklight(screenId); 428 EXPECT_EQ(backLight, 50); 429 } 430 431 /* 432 * Function: SetScreenBacklight 433 * Type: Function 434 * Rank: Important(2) 435 * EnvConditions: N/A 436 * CaseDescription: 1. call SetScreenBacklight with value:100 437 * 2. check 438 */ 439 HWTEST_F(RSInterfacesTest, SetScreenBacklight002, Function | SmallTest | Level2) 440 { 441 auto screenId = rsInterfaces->GetDefaultScreenId(); 442 EXPECT_NE(screenId, INVALID_SCREEN_ID); 443 444 rsInterfaces->SetScreenBacklight(screenId, 100); 445 auto backLight = rsInterfaces->GetScreenBacklight(screenId); 446 EXPECT_EQ(backLight, 100); 447 } 448 449 /* 450 * Function: GetScreenBacklight 451 * Type: Function 452 * Rank: Important(2) 453 * EnvConditions: N/A 454 * CaseDescription: 1. call GetScreenBacklight with value: 50 455 * 2. check 456 */ 457 HWTEST_F(RSInterfacesTest, GetScreenBacklight001, Function | SmallTest | Level2) 458 { 459 auto screenId = rsInterfaces->GetDefaultScreenId(); 460 EXPECT_NE(screenId, INVALID_SCREEN_ID); 461 462 rsInterfaces->SetScreenBacklight(screenId, 50); 463 auto backLight = rsInterfaces->GetScreenBacklight(screenId); 464 EXPECT_EQ(backLight, 50); 465 } 466 467 /* 468 * Function: GetScreenBacklight 469 * Type: Function 470 * Rank: Important(2) 471 * EnvConditions: N/A 472 * CaseDescription: 1. call GetScreenBacklight INVALID_SCREEN_ID 473 * 2. check 474 */ 475 HWTEST_F(RSInterfacesTest, GetScreenBacklight002, Function | SmallTest | Level2) 476 { 477 auto backLight = rsInterfaces->GetScreenBacklight(INVALID_SCREEN_ID); 478 EXPECT_EQ(backLight, -1); 479 } 480 481 /* 482 * Function: SetScreenChangeCallback 483 * Type: Function 484 * Rank: Important(2) 485 * EnvConditions: N/A 486 * CaseDescription: 1. call SetScreenChangeCallback 487 * 2. wait 2s and check the ret 488 */ 489 HWTEST_F(RSInterfacesTest, SetScreenChangeCallback, Function | SmallTest | Level2) 490 { 491 ScreenId screenId = INVALID_SCREEN_ID; 492 ScreenEvent screenEvent = ScreenEvent::UNKNOWN; 493 bool callbacked = false; __anona8837f0f0102(ScreenId id, ScreenEvent event) 494 auto callback = [&screenId, &screenEvent, &callbacked](ScreenId id, ScreenEvent event) { 495 screenId = id; 496 screenEvent = event; 497 callbacked = true; 498 }; 499 int32_t status = rsInterfaces->SetScreenChangeCallback(callback); 500 EXPECT_EQ(status, StatusCode::SUCCESS); 501 sleep(2); // wait 2s to check if the callback returned. 502 if (status == StatusCode::SUCCESS) { 503 EXPECT_NE(screenId, INVALID_SCREEN_ID); 504 EXPECT_NE(screenEvent, ScreenEvent::UNKNOWN); 505 } else { 506 EXPECT_EQ(screenId, INVALID_SCREEN_ID); 507 EXPECT_EQ(screenEvent, ScreenEvent::UNKNOWN); 508 } 509 } 510 511 /* 512 * Function: GetScreenSupportedColorGamuts 513 * Type: Function 514 * Rank: Important(2) 515 * EnvConditions: N/A 516 * CaseDescription: 1. call GetScreenSupportedColorGamuts with INVALID_SCREEN_ID 517 * 2. check ret 518 */ 519 HWTEST_F(RSInterfacesTest, GetScreenSupportedColorGamuts002, Function | SmallTest | Level2) 520 { 521 std::vector<ScreenColorGamut> modes; 522 int ret = rsInterfaces->GetScreenSupportedColorGamuts(INVALID_SCREEN_ID, modes); 523 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 524 } 525 526 /* 527 * Function: GetScreenSupportedMetaDataKeys 528 * Type: Function 529 * Rank: Important(2) 530 * EnvConditions: N/A 531 * CaseDescription: 1. call GetScreenSupportedMetaDataKeys 532 * 2. check ret 533 * @tc.require: IssueI5KGK4 534 */ 535 HWTEST_F(RSInterfacesTest, GetScreenSupportedMetaDataKeys001, Function | SmallTest | Level2) 536 { 537 auto screenId = rsInterfaces->GetDefaultScreenId(); 538 EXPECT_NE(screenId, INVALID_SCREEN_ID); 539 std::vector<ScreenHDRMetadataKey> keys; 540 int ret = rsInterfaces->GetScreenSupportedMetaDataKeys(screenId, keys); 541 EXPECT_EQ(ret, StatusCode::SUCCESS); 542 EXPECT_EQ(keys[0], ScreenHDRMetadataKey::MATAKEY_RED_PRIMARY_X); // ScreenHDRMetadataKey now is mock data. 543 } 544 545 /* 546 * Function: GetScreenSupportedMetaDataKeys 547 * Type: Function 548 * Rank: Important(2) 549 * EnvConditions: N/A 550 * CaseDescription: 1. call GetScreenSupportedMetaDataKeys with INVALID_SCREEN_ID 551 * 2. check ret 552 * @tc.require: IssueI5KGK4 553 */ 554 HWTEST_F(RSInterfacesTest, GetScreenSupportedMetaDataKeys002, Function | SmallTest | Level2) 555 { 556 std::vector<ScreenHDRMetadataKey> keys; 557 int ret = rsInterfaces->GetScreenSupportedMetaDataKeys(INVALID_SCREEN_ID, keys); 558 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 559 } 560 561 /* 562 * Function: GetScreenColorGamut 563 * Type: Function 564 * Rank: Important(2) 565 * EnvConditions: N/A 566 * CaseDescription: 1. call GetScreenColorGamut with INVALID_SCREEN_ID 567 * 2. check ret 568 */ 569 HWTEST_F(RSInterfacesTest, GetScreenColorGamut002, Function | SmallTest | Level2) 570 { 571 ScreenColorGamut mode = ScreenColorGamut::COLOR_GAMUT_INVALID; 572 int ret = rsInterfaces->GetScreenColorGamut(INVALID_SCREEN_ID, mode); 573 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 574 } 575 576 /* 577 * Function: SetScreenColorGamut 578 * Type: Function 579 * Rank: Important(2) 580 * EnvConditions: N/A 581 * CaseDescription: 1. call SetScreenColorGamut with INVALID_SCREEN_ID 582 * 2. check ret 583 */ 584 HWTEST_F(RSInterfacesTest, SetScreenColorGamut002, Function | SmallTest | Level2) 585 { 586 int ret = rsInterfaces->SetScreenColorGamut(INVALID_SCREEN_ID, 0); 587 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 588 } 589 590 /* 591 * Function: SetScreenGamutMap 592 * Type: Function 593 * Rank: Important(2) 594 * EnvConditions: N/A 595 * CaseDescription: 1. call SetScreenGamutMap with INVALID_SCREEN_ID 596 * 2. check ret 597 */ 598 HWTEST_F(RSInterfacesTest, SetScreenGamutMap002, Function | SmallTest | Level2) 599 { 600 ScreenGamutMap gamutMap = ScreenGamutMap::GAMUT_MAP_CONSTANT; 601 int ret = rsInterfaces->SetScreenGamutMap(INVALID_SCREEN_ID, gamutMap); 602 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 603 } 604 605 /* 606 * Function: GetScreenGamutMap 607 * Type: Function 608 * Rank: Important(2) 609 * EnvConditions: N/A 610 * CaseDescription: 1. call GetScreenGamutMap with INVALID_SCREEN_ID 611 * 2. check ret 612 */ 613 HWTEST_F(RSInterfacesTest, GetScreenGamutMap002, Function | SmallTest | Level2) 614 { 615 ScreenGamutMap gamutMap = ScreenGamutMap::GAMUT_MAP_CONSTANT; 616 int ret = rsInterfaces->GetScreenGamutMap(INVALID_SCREEN_ID, gamutMap); 617 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 618 } 619 620 /* 621 * Function: GetScreenHDRCapability 622 * Type: Function 623 * Rank: Important(2) 624 * EnvConditions: N/A 625 * CaseDescription: 1. call GetScreenHDRCapability 626 * 2. check ret 627 * @tc.require: IssueI5KGK4 628 */ 629 HWTEST_F(RSInterfacesTest, GetScreenHDRCapability001, Function | SmallTest | Level2) 630 { 631 auto screenId = rsInterfaces->GetDefaultScreenId(); 632 EXPECT_NE(screenId, INVALID_SCREEN_ID); 633 634 RSScreenHDRCapability hdrCapability; 635 int ret = rsInterfaces->GetScreenHDRCapability(screenId, hdrCapability); 636 EXPECT_EQ(ret, StatusCode::SUCCESS); 637 EXPECT_EQ(hdrCapability.GetMaxLum(), 1000); // maxLum now is mock data 638 } 639 640 /* 641 * Function: GetScreenHDRCapability 642 * Type: Function 643 * Rank: Important(2) 644 * EnvConditions: N/A 645 * CaseDescription: 1. call GetScreenHDRCapability with INVALID_SCREEN_ID 646 * 2. check ret 647 * @tc.require: IssueI5KGK4 648 */ 649 HWTEST_F(RSInterfacesTest, GetScreenHDRCapability002, Function | SmallTest | Level2) 650 { 651 RSScreenHDRCapability hdrCapability; 652 int ret = rsInterfaces->GetScreenHDRCapability(INVALID_SCREEN_ID, hdrCapability); 653 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 654 } 655 656 /* 657 * Function: GetScreenType 658 * Type: Function 659 * Rank: Important(2) 660 * EnvConditions: N/A 661 * CaseDescription: 1. call GetScreenType 662 * 2. check ret 663 */ 664 HWTEST_F(RSInterfacesTest, GetScreenType001, Function | SmallTest | Level2) 665 { 666 auto screenId = rsInterfaces->GetDefaultScreenId(); 667 EXPECT_NE(screenId, INVALID_SCREEN_ID); 668 669 RSScreenType type; 670 int ret = rsInterfaces->GetScreenType(screenId, type); 671 EXPECT_EQ(ret, StatusCode::SUCCESS); 672 } 673 674 /* 675 * Function: GetScreenType 676 * Type: Function 677 * Rank: Important(2) 678 * EnvConditions: N/A 679 * CaseDescription: 1. call GetScreenType with INVALID_SCREEN_ID 680 * 2. check ret 681 */ 682 HWTEST_F(RSInterfacesTest, GetScreenType002, Function | SmallTest | Level2) 683 { 684 RSScreenType type; 685 int ret = rsInterfaces->GetScreenType(INVALID_SCREEN_ID, type); 686 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 687 } 688 689 /* 690 * Function: SetVirtualScreenResolution/GetVirtualScreenResolution 691 * Type: Function 692 * Rank: Important(2) 693 * EnvConditions: N/A 694 * CaseDescription: 1. Call CreateVirtualScreen, use normal parameters. 695 * 2. Use SetVirtualScreenResolution to change the width and height of virtualScreen 696 * 3. Use GetVirtualScreenResolution to get current width and height of virtualScreen 697 * 4. Check current width and height of virtualScreen 698 */ 699 HWTEST_F(RSInterfacesTest, SetVirtualScreenResolution001, Function | SmallTest | Level2) 700 { 701 auto csurface = Surface::CreateSurfaceAsConsumer(); 702 EXPECT_NE(csurface, nullptr); 703 auto producer = csurface->GetProducer(); 704 auto psurface = Surface::CreateSurfaceAsProducer(producer); 705 uint32_t defaultWidth = 720; 706 uint32_t defaultHeight = 1280; 707 uint32_t newWidth = 1920; 708 uint32_t newHeight = 1080; 709 EXPECT_NE(psurface, nullptr); 710 711 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 712 "virtual5", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 713 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 714 715 auto curVirtualScreenResolution = rsInterfaces->GetVirtualScreenResolution(virtualScreenId); 716 EXPECT_EQ(curVirtualScreenResolution.GetVirtualScreenWidth(), defaultWidth); 717 EXPECT_EQ(curVirtualScreenResolution.GetVirtualScreenHeight(), defaultHeight); 718 719 rsInterfaces->SetVirtualScreenResolution(virtualScreenId, newWidth, newHeight); 720 721 curVirtualScreenResolution = rsInterfaces->GetVirtualScreenResolution(virtualScreenId); 722 EXPECT_EQ(curVirtualScreenResolution.GetVirtualScreenWidth(), newWidth); 723 EXPECT_EQ(curVirtualScreenResolution.GetVirtualScreenHeight(), newHeight); 724 725 rsInterfaces->RemoveVirtualScreen(virtualScreenId); 726 } 727 728 /* 729 * Function: GetAllScreenIds 730 * Type: Function 731 * Rank: Important(2) 732 * EnvConditions: N/A 733 * CaseDescription: 1. call GetAllScreenIds 734 * 2. check vector size 735 */ 736 HWTEST_F(RSInterfacesTest, GetAllScreenIds, Function | SmallTest | Level2) 737 { 738 std::vector<ScreenId> ids = rsInterfaces->GetAllScreenIds(); 739 int32_t size = ids.size(); 740 EXPECT_GT(ids.size(), 0); 741 auto csurface = Surface::CreateSurfaceAsConsumer(); 742 EXPECT_NE(csurface, nullptr); 743 auto producer = csurface->GetProducer(); 744 auto psurface = Surface::CreateSurfaceAsProducer(producer); 745 uint32_t defaultWidth = 720; 746 uint32_t defaultHeight = 1280; 747 EXPECT_NE(psurface, nullptr); 748 749 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 750 "virtual6", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 751 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 752 ids = rsInterfaces->GetAllScreenIds(); 753 EXPECT_EQ(size + 1, ids.size()); 754 } 755 756 /* 757 * Function: SetScreenSkipFrameInterval 758 * Type: Function 759 * Rank: Important(2) 760 * EnvConditions: N/A 761 * CaseDescription: 1. call SetScreenSkipFrameInterval with invalid parameters and check ret 762 */ 763 HWTEST_F(RSInterfacesTest, SetScreenSkipFrameInterval001, Function | SmallTest | Level2) 764 { 765 ScreenId screenId = INVALID_SCREEN_ID; 766 uint32_t skipFrameInterval = 1; 767 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 768 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 769 } 770 771 /* 772 * Function: SetScreenSkipFrameInterval 773 * Type: Function 774 * Rank: Important(2) 775 * EnvConditions: N/A 776 * CaseDescription: 1. call SetScreenSkipFrameInterval with invalid parameters and check ret 777 */ 778 HWTEST_F(RSInterfacesTest, SetScreenSkipFrameInterval002, Function | SmallTest | Level2) 779 { 780 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 781 EXPECT_NE(screenId, INVALID_SCREEN_ID); 782 uint32_t skipFrameInterval = 0; 783 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 784 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 785 } 786 787 /* 788 * Function: SetScreenSkipFrameInterval 789 * Type: Function 790 * Rank: Important(2) 791 * EnvConditions: N/A 792 * CaseDescription: 1. call SetScreenSkipFrameInterval with invalid parameters and check ret 793 */ 794 HWTEST_F(RSInterfacesTest, SetScreenSkipFrameInterval003, Function | SmallTest | Level2) 795 { 796 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 797 EXPECT_NE(screenId, INVALID_SCREEN_ID); 798 uint32_t skipFrameInterval = 100; // for test 799 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 800 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 801 } 802 803 /* 804 * Function: SetScreenSkipFrameInterval 805 * Type: Function 806 * Rank: Important(1) 807 * EnvConditions: N/A 808 * CaseDescription: 1. call SetScreenSkipFrameInterval with valid parameters and check ret 809 */ 810 HWTEST_F(RSInterfacesTest, SetScreenSkipFrameInterval004, Function | SmallTest | Level1) 811 { 812 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 813 EXPECT_NE(screenId, INVALID_SCREEN_ID); 814 float skipFrameInterval = 2.1; // for test 815 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 816 EXPECT_EQ(ret, StatusCode::SUCCESS); 817 } 818 819 /* 820 * Function: SetScreenSkipFrameInterval 821 * Type: Function 822 * Rank: Important(1) 823 * EnvConditions: N/A 824 * CaseDescription: 1. call SetScreenSkipFrameInterval with valid parameters and check ret 825 */ 826 HWTEST_F(RSInterfacesTest, SetScreenSkipFrameInterval005, Function | SmallTest | Level1) 827 { 828 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 829 EXPECT_NE(screenId, INVALID_SCREEN_ID); 830 uint32_t skipFrameInterval = 1; 831 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 832 ASSERT_EQ(ret, StatusCode::SUCCESS); 833 } 834 835 /* 836 * @tc.name: ScreenGamutMap_001 837 * @tc.desc: Test SetScreenGamutMap And GetScreenGamutMap 838 * @tc.type: FUNC 839 * @tc.require: issueI60RFZ 840 */ 841 HWTEST_F(RSInterfacesTest, ScreenGamutMap_001, Function | SmallTest | Level2) 842 { 843 ScreenId defaultScreenId = rsInterfaces->GetDefaultScreenId(); 844 ScreenGamutMap mode = ScreenGamutMap::GAMUT_MAP_CONSTANT; 845 uint32_t statusMode = rsInterfaces->SetScreenGamutMap(defaultScreenId, mode); 846 ASSERT_EQ(statusMode, StatusCode::HDI_ERROR); 847 statusMode = rsInterfaces->GetScreenGamutMap(defaultScreenId, mode); 848 ASSERT_EQ(statusMode, StatusCode::HDI_ERROR); 849 } 850 851 /* 852 * @tc.name: RegisterOcclusionChangeCallback Test 853 * @tc.desc: RegisterOcclusionChangeCallback Test 854 * @tc.type: FUNC 855 * @tc.require: 856 */ 857 HWTEST_F(RSInterfacesTest, RegisterOcclusionChangeCallback_Test, Function | SmallTest | Level2) 858 { 859 ASSERT_NE(rsInterfaces, nullptr); __anona8837f0f0202(std::shared_ptr<RSOcclusionData> data)860 OcclusionChangeCallback cb = [](std::shared_ptr<RSOcclusionData> data){}; 861 int32_t ret = rsInterfaces->RegisterOcclusionChangeCallback(cb); 862 ASSERT_EQ(ret, 0); 863 } 864 865 /* 866 * @tc.name: UnRegisterOcclusionChangeCallback Test 867 * @tc.desc: UnRegisterOcclusionChangeCallback Test 868 * @tc.type: FUNC 869 * @tc.require: 870 */ 871 HWTEST_F(RSInterfacesTest, UnRegisterOcclusionChangeCallback_Test, Function | SmallTest | Level2) 872 { 873 ASSERT_NE(rsInterfaces, nullptr); __anona8837f0f0302(std::shared_ptr<RSOcclusionData> data)874 OcclusionChangeCallback cb = [](std::shared_ptr<RSOcclusionData> data){}; 875 int32_t ret = rsInterfaces->UnRegisterOcclusionChangeCallback(cb); 876 ASSERT_EQ(ret, 0); 877 } 878 879 /* 880 * @tc.name: SetRenderModeChangeCallback Test 881 * @tc.desc: SetRenderModeChangeCallback Test 882 * @tc.type: FUNC 883 * @tc.require: 884 */ 885 HWTEST_F(RSInterfacesTest, SetRenderModeChangeCallback_Test, Function | SmallTest | Level2) 886 { 887 ASSERT_NE(rsInterfaces, nullptr); __anona8837f0f0402(bool flag)888 RenderModeChangeCallback cb = [](bool flag){}; 889 int32_t ret = rsInterfaces->SetRenderModeChangeCallback(cb); 890 ASSERT_EQ(ret, 0); 891 } 892 893 /* 894 * @tc.name: UpdateRenderMode True Test 895 * @tc.desc: UpdateRenderMode True Test 896 * @tc.type: FUNC 897 * @tc.require: 898 */ 899 HWTEST_F(RSInterfacesTest, UpdateRenderMode_True, Function | SmallTest | Level2) 900 { 901 ASSERT_NE(rsInterfaces, nullptr); 902 rsInterfaces->UpdateRenderMode(true); 903 } 904 905 /* 906 * @tc.name: UpdateRenderMode False Test 907 * @tc.desc: UpdateRenderMode False Test 908 * @tc.type: FUNC 909 * @tc.require: 910 */ 911 HWTEST_F(RSInterfacesTest, UpdateRenderMode_False, Function | SmallTest | Level2) 912 { 913 ASSERT_NE(rsInterfaces, nullptr); 914 rsInterfaces->UpdateRenderMode(false); 915 } 916 917 /* 918 * @tc.name: SetVirtualScreenSurface Test a notfound id 919 * @tc.desc: SetVirtualScreenSurface Test a notfound id 920 * @tc.type: FUNC 921 * @tc.require: 922 */ 923 HWTEST_F(RSInterfacesTest, SetVirtualScreenSurface_Test, Function | SmallTest | Level2) 924 { 925 ASSERT_NE(rsInterfaces, nullptr); 926 auto csurface = Surface::CreateSurfaceAsConsumer(); 927 ASSERT_NE(csurface, nullptr); 928 auto producer = csurface->GetProducer(); 929 auto psurface = Surface::CreateSurfaceAsProducer(producer); 930 ASSERT_NE(psurface, nullptr); 931 932 int32_t ret = rsInterfaces->SetVirtualScreenSurface(123, psurface); 933 ASSERT_EQ(ret, 0); 934 } 935 } // namespace Rosen 936 } // namespace OHOS 937