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 <cstdint> 17 #include <gtest/gtest.h> 18 #include <hilog/log.h> 19 #include <memory> 20 #include <unistd.h> 21 #include <iostream> 22 23 #include "transaction/rs_interfaces.h" 24 25 #include "accesstoken_kit.h" 26 #include "nativetoken_kit.h" 27 #include "token_setproc.h" 28 29 using namespace testing::ext; 30 31 namespace OHOS { 32 namespace Rosen { 33 class RSScreenSkipFrameTest : public testing::Test { 34 public: 35 static constexpr HiviewDFX::HiLogLabel LOG_LABEL = { LOG_CORE, 0, "RSScreenSkipFrameTest" }; 36 SetUpTestCase()37 static void SetUpTestCase() 38 { 39 rsInterfaces = &(RSInterfaces::GetInstance()); 40 uint64_t tokenId; 41 const char* perms[1]; 42 perms[0] = "ohos.permission.CAPTURE_SCREEN"; 43 NativeTokenInfoParams infoInstance = { 44 .dcapsNum = 0, 45 .permsNum = 1, 46 .aclsNum = 0, 47 .dcaps = NULL, 48 .perms = perms, 49 .acls = NULL, 50 .processName = "foundation", 51 .aplStr = "system_basic", 52 }; 53 tokenId = GetAccessTokenId(&infoInstance); 54 SetSelfTokenID(tokenId); 55 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); 56 } 57 TearDownTestCase()58 static void TearDownTestCase() 59 { 60 rsInterfaces = nullptr; 61 } 62 63 static inline RSInterfaces* rsInterfaces = nullptr; 64 ConvertScreenModeToRefreshRate(int32_t modeId)65 uint32_t ConvertScreenModeToRefreshRate(int32_t modeId) 66 { 67 uint32_t refreshRate = 0; 68 switch (modeId) { 69 case 0: // modeId 0 means 120hz 70 refreshRate = 120; // modeId 0 means 120hz 71 break; 72 case 1: // modeId 1 means 90hz 73 refreshRate = 90; // modeId 1 means 90hz 74 break; 75 case 2: // modeId 2 means 60hz 76 refreshRate = 60; // modeId 2 means 60hz 77 break; 78 case 3: // modeId 3 means 30hz 79 refreshRate = 30; // modeId 3 means 30hz 80 break; 81 default: 82 refreshRate = 0; 83 break; 84 } 85 return refreshRate; 86 } 87 88 private: 89 static constexpr uint32_t SET_REFRESHRATE_SLEEP_US = 50000; // wait for refreshrate change 90 uint32_t virtualScreenMirrorId = 1; 91 }; 92 93 /* 94 * Function: SetScreenSkipFrameInterval 95 * Type: Function 96 * Rank: Important(2) 97 * EnvConditions: N/A 98 * CaseDescription: 1. call SetScreenSkipFrameInterval with screenId 0 99 */ 100 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval001, Function | SmallTest | Level2) 101 { 102 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 103 EXPECT_NE(screenId, INVALID_SCREEN_ID); 104 uint32_t skipFrameInterval = 1; 105 std::cout << "Set screenId:" << 0 << ", skipFrameInterval:" << skipFrameInterval << std::endl; 106 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(0, skipFrameInterval); 107 if (screenId == 0) { 108 EXPECT_EQ(ret, StatusCode::SUCCESS); 109 } else { 110 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 111 } 112 } 113 114 /* 115 * Function: SetScreenSkipFrameInterval 116 * Type: Function 117 * Rank: Important(2) 118 * EnvConditions: N/A 119 * CaseDescription: 1. call SetScreenSkipFrameInterval with invalid screenId 120 */ 121 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval002, Function | SmallTest | Level2) 122 { 123 ScreenId screenId = INVALID_SCREEN_ID; 124 uint32_t skipFrameInterval = 1; 125 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 126 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 127 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 128 } 129 130 /* 131 * Function: SetScreenSkipFrameInterval 132 * Type: Function 133 * Rank: Important(2) 134 * EnvConditions: N/A 135 * CaseDescription: 1. call Set primary screen with skipFrameInterval 0 136 */ 137 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval003, Function | SmallTest | Level2) 138 { 139 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 140 EXPECT_NE(screenId, INVALID_SCREEN_ID); 141 uint32_t skipFrameInterval = 0; 142 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 143 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 144 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 145 } 146 147 /* 148 * Function: SetScreenSkipFrameInterval 149 * Type: Function 150 * Rank: Important(2) 151 * EnvConditions: N/A 152 * CaseDescription: 1. call Set primary screen with skipFrameInterval 1 153 */ 154 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval004, Function | SmallTest | Level2) 155 { 156 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 157 EXPECT_NE(screenId, INVALID_SCREEN_ID); 158 uint32_t skipFrameInterval = 1; 159 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 160 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 161 EXPECT_EQ(ret, StatusCode::SUCCESS); 162 } 163 164 /* 165 * Function: SetScreenSkipFrameInterval 166 * Type: Function 167 * Rank: Important(1) 168 * EnvConditions: N/A 169 * CaseDescription: 1. Set primary screen with skipFrameInterval 2 170 */ 171 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval005, Function | SmallTest | Level1) 172 { 173 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 174 EXPECT_NE(screenId, INVALID_SCREEN_ID); 175 uint32_t skipFrameInterval = 2; 176 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 177 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 178 EXPECT_EQ(ret, StatusCode::SUCCESS); 179 180 // recover 181 ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, 1); 182 EXPECT_EQ(ret, StatusCode::SUCCESS); 183 } 184 185 /* 186 * Function: SetScreenSkipFrameInterval 187 * Type: Function 188 * Rank: Important(1) 189 * EnvConditions: N/A 190 * CaseDescription: 1. Set primary screen with the most screen refreshrate 191 */ 192 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval006, Function | SmallTest | Level1) 193 { 194 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 195 EXPECT_NE(screenId, INVALID_SCREEN_ID); 196 auto formerModeInfo = rsInterfaces->GetScreenActiveMode(screenId); 197 uint32_t skipFrameInterval = formerModeInfo.GetScreenRefreshRate(); 198 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 199 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 200 EXPECT_EQ(ret, StatusCode::SUCCESS); 201 202 // recover 203 ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, 1); 204 EXPECT_EQ(ret, StatusCode::SUCCESS); 205 } 206 207 /* 208 * Function: SetScreenSkipFrameInterval 209 * Type: Function 210 * Rank: Important(1) 211 * EnvConditions: N/A 212 * CaseDescription: 1. Set primary screen with the most screen refreshrate pluse 1 213 */ 214 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval007, Function | SmallTest | Level1) 215 { 216 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 217 EXPECT_NE(screenId, INVALID_SCREEN_ID); 218 auto formerModeInfo = rsInterfaces->GetScreenActiveMode(screenId); 219 uint32_t skipFrameInterval = formerModeInfo.GetScreenRefreshRate() + 1; 220 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 221 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 222 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 223 224 // recover 225 ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, 1); 226 EXPECT_EQ(ret, StatusCode::SUCCESS); 227 } 228 229 /* 230 * Function: SetScreenSkipFrameInterval 231 * Type: Function 232 * Rank: Important(1) 233 * EnvConditions: N/A 234 * CaseDescription: 1. Set virtual screen with skipFrameInterval 0 235 */ 236 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval008, Function | SmallTest | Level1) 237 { 238 auto csurface = IConsumerSurface::Create(); 239 EXPECT_NE(csurface, nullptr); 240 auto producer = csurface->GetProducer(); 241 auto psurface = Surface::CreateSurfaceAsProducer(producer); 242 uint32_t defaultWidth = 720; 243 uint32_t defaultHeight = 1280; 244 EXPECT_NE(psurface, nullptr); 245 246 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 247 "virtualScreen01", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 248 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 249 250 uint32_t skipFrameInterval = 0; 251 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 252 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 253 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 254 } 255 256 /* 257 * Function: SetScreenSkipFrameInterval 258 * Type: Function 259 * Rank: Important(1) 260 * EnvConditions: N/A 261 * CaseDescription: 1. Set virtual screen with skipFrameInterval 1 262 */ 263 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval009, Function | SmallTest | Level1) 264 { 265 auto csurface = IConsumerSurface::Create(); 266 EXPECT_NE(csurface, nullptr); 267 auto producer = csurface->GetProducer(); 268 auto psurface = Surface::CreateSurfaceAsProducer(producer); 269 uint32_t defaultWidth = 720; 270 uint32_t defaultHeight = 1280; 271 EXPECT_NE(psurface, nullptr); 272 273 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 274 "virtualScreen02", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 275 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 276 277 uint32_t skipFrameInterval = 1; 278 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 279 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 280 EXPECT_EQ(ret, StatusCode::SUCCESS); 281 } 282 283 /* 284 * Function: SetScreenSkipFrameInterval 285 * Type: Function 286 * Rank: Important(1) 287 * EnvConditions: N/A 288 * CaseDescription: 1. Set virtual screen with skipFrameInterval 2 289 */ 290 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval010, Function | SmallTest | Level1) 291 { 292 auto csurface = IConsumerSurface::Create(); 293 EXPECT_NE(csurface, nullptr); 294 auto producer = csurface->GetProducer(); 295 auto psurface = Surface::CreateSurfaceAsProducer(producer); 296 uint32_t defaultWidth = 720; 297 uint32_t defaultHeight = 1280; 298 EXPECT_NE(psurface, nullptr); 299 300 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 301 "virtualScreen03", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 302 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 303 304 uint32_t skipFrameInterval = 2; 305 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 306 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 307 EXPECT_EQ(ret, StatusCode::SUCCESS); 308 309 // recover 310 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 311 EXPECT_EQ(ret, StatusCode::SUCCESS); 312 } 313 314 /* 315 * Function: SetScreenSkipFrameInterval 316 * Type: Function 317 * Rank: Important(1) 318 * EnvConditions: N/A 319 * CaseDescription: 1. Set virtual screen with the most screen refreshrate 320 */ 321 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval011, Function | SmallTest | Level1) 322 { 323 auto csurface = IConsumerSurface::Create(); 324 EXPECT_NE(csurface, nullptr); 325 auto producer = csurface->GetProducer(); 326 auto psurface = Surface::CreateSurfaceAsProducer(producer); 327 uint32_t defaultWidth = 720; 328 uint32_t defaultHeight = 1280; 329 EXPECT_NE(psurface, nullptr); 330 331 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 332 "virtualScreen04", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 333 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 334 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 335 EXPECT_NE(screenId, INVALID_SCREEN_ID); 336 auto formerModeInfo = rsInterfaces->GetScreenActiveMode(screenId); 337 338 uint32_t skipFrameInterval = formerModeInfo.GetScreenRefreshRate(); 339 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 340 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 341 EXPECT_EQ(ret, StatusCode::SUCCESS); 342 343 // recover 344 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 345 EXPECT_EQ(ret, StatusCode::SUCCESS); 346 } 347 348 /* 349 * Function: SetScreenSkipFrameInterval 350 * Type: Function 351 * Rank: Important(1) 352 * EnvConditions: N/A 353 * CaseDescription: 1. Set virtual screen with the most screen refreshrate pluse 1 354 */ 355 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval012, Function | SmallTest | Level1) 356 { 357 auto csurface = IConsumerSurface::Create(); 358 EXPECT_NE(csurface, nullptr); 359 auto producer = csurface->GetProducer(); 360 auto psurface = Surface::CreateSurfaceAsProducer(producer); 361 uint32_t defaultWidth = 720; 362 uint32_t defaultHeight = 1280; 363 EXPECT_NE(psurface, nullptr); 364 365 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 366 "virtualScreen05", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 367 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 368 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 369 EXPECT_NE(screenId, INVALID_SCREEN_ID); 370 auto formerModeInfo = rsInterfaces->GetScreenActiveMode(screenId); 371 372 uint32_t skipFrameInterval = formerModeInfo.GetScreenRefreshRate() + 1; 373 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 374 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 375 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 376 377 // recover 378 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 379 EXPECT_EQ(ret, StatusCode::SUCCESS); 380 } 381 382 /* 383 * Function: SetScreenSkipFrameInterval 384 * Type: Function 385 * Rank: Important(1) 386 * EnvConditions: N/A 387 * CaseDescription: 1. Set virtual screen with skipFrameInterval 99999 388 */ 389 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval013, Function | SmallTest | Level1) 390 { 391 auto csurface = IConsumerSurface::Create(); 392 EXPECT_NE(csurface, nullptr); 393 auto producer = csurface->GetProducer(); 394 auto psurface = Surface::CreateSurfaceAsProducer(producer); 395 uint32_t defaultWidth = 720; 396 uint32_t defaultHeight = 1280; 397 EXPECT_NE(psurface, nullptr); 398 399 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 400 "virtualScreen06", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 401 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 402 403 uint32_t skipFrameInterval = 99999; 404 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 405 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 406 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 407 408 // recover 409 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 410 EXPECT_EQ(ret, StatusCode::SUCCESS); 411 } 412 413 /* 414 * Function: SetScreenSkipFrameInterval 415 * Type: Function 416 * Rank: Important(1) 417 * EnvConditions: N/A 418 * CaseDescription: 1. Set virtual screen with skipFrameInterval 2.1 419 */ 420 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval014, Function | SmallTest | Level1) 421 { 422 auto csurface = IConsumerSurface::Create(); 423 EXPECT_NE(csurface, nullptr); 424 auto producer = csurface->GetProducer(); 425 auto psurface = Surface::CreateSurfaceAsProducer(producer); 426 uint32_t defaultWidth = 720; 427 uint32_t defaultHeight = 1280; 428 EXPECT_NE(psurface, nullptr); 429 430 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 431 "virtualScreen07", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 432 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 433 434 float skipFrameInterval = 2.1; 435 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 436 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 437 EXPECT_EQ(ret, StatusCode::SUCCESS); 438 439 // recover 440 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 441 EXPECT_EQ(ret, StatusCode::SUCCESS); 442 } 443 444 /* 445 * Function: SetScreenSkipFrameInterval 446 * Type: Function 447 * Rank: Important(1) 448 * EnvConditions: N/A 449 * CaseDescription: 1. Set virtual screen and primary screen with skipFrameInterval 2 450 */ 451 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval015, Function | SmallTest | Level1) 452 { 453 auto csurface = IConsumerSurface::Create(); 454 EXPECT_NE(csurface, nullptr); 455 auto producer = csurface->GetProducer(); 456 auto psurface = Surface::CreateSurfaceAsProducer(producer); 457 uint32_t defaultWidth = 720; 458 uint32_t defaultHeight = 1280; 459 EXPECT_NE(psurface, nullptr); 460 461 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 462 "virtualScreen08", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 463 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 464 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 465 EXPECT_NE(screenId, INVALID_SCREEN_ID); 466 467 uint32_t skipFrameInterval = 2; 468 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 469 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 470 EXPECT_EQ(ret, StatusCode::SUCCESS); 471 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 472 ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 473 EXPECT_EQ(ret, StatusCode::SUCCESS); 474 475 // recover 476 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 477 EXPECT_EQ(ret, StatusCode::SUCCESS); 478 ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, 1); 479 EXPECT_EQ(ret, StatusCode::SUCCESS); 480 } 481 } // namespace Rosen 482 } // namespace OHOS 483