1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <array> 18 #include <unordered_set> 19 #include <unordered_map> 20 #include <gtest/gtest.h> 21 #include <dlfcn.h> 22 #include <android-base/unique_fd.h> 23 #include <hardware/hardware.h> 24 #include <sync/sync.h> 25 26 #define HWC2_INCLUDE_STRINGIFICATION 27 #define HWC2_USE_CPP11 28 #include <hardware/hwcomposer2.h> 29 #undef HWC2_INCLUDE_STRINGIFICATION 30 #undef HWC2_USE_CPP11 31 32 #include "Hwc2TestLayer.h" 33 #include "Hwc2TestLayers.h" 34 #include "Hwc2TestClientTarget.h" 35 #include "Hwc2TestVirtualDisplay.h" 36 37 void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData, 38 hwc2_display_t display, int32_t connected); 39 void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData, 40 hwc2_display_t display, int64_t timestamp); 41 42 class Hwc2Test : public testing::Test { 43 public: 44 45 virtual void SetUp() 46 { 47 hw_module_t const* hwc2Module; 48 49 int err = hw_get_module(HWC_HARDWARE_MODULE_ID, &hwc2Module); 50 ASSERT_GE(err, 0) << "failed to get hwc hardware module: " 51 << strerror(-err); 52 53 /* The following method will fail if you have not run 54 * "adb shell stop" */ 55 err = hwc2_open(hwc2Module, &mHwc2Device); 56 ASSERT_GE(err, 0) << "failed to open hwc hardware module: " 57 << strerror(-err); 58 59 populateDisplays(); 60 } 61 62 virtual void TearDown() 63 { 64 65 for (auto itr = mLayers.begin(); itr != mLayers.end();) { 66 hwc2_display_t display = itr->first; 67 hwc2_layer_t layer = itr->second; 68 itr++; 69 /* Destroys and removes the layer from mLayers */ 70 destroyLayer(display, layer); 71 } 72 73 for (auto itr = mActiveDisplays.begin(); itr != mActiveDisplays.end();) { 74 hwc2_display_t display = *itr; 75 itr++; 76 /* Sets power mode to off and removes the display from 77 * mActiveDisplays */ 78 setPowerMode(display, HWC2_POWER_MODE_OFF); 79 } 80 81 for (auto itr = mVirtualDisplays.begin(); itr != mVirtualDisplays.end();) { 82 hwc2_display_t display = *itr; 83 itr++; 84 /* Destroys virtual displays */ 85 destroyVirtualDisplay(display); 86 } 87 88 if (mHwc2Device) 89 hwc2_close(mHwc2Device); 90 } 91 92 void registerCallback(hwc2_callback_descriptor_t descriptor, 93 hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer, 94 hwc2_error_t* outErr = nullptr) 95 { 96 auto pfn = reinterpret_cast<HWC2_PFN_REGISTER_CALLBACK>( 97 getFunction(HWC2_FUNCTION_REGISTER_CALLBACK)); 98 ASSERT_TRUE(pfn) << "failed to get function"; 99 100 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, descriptor, 101 callbackData, pointer)); 102 if (outErr) { 103 *outErr = err; 104 } else { 105 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to register callback"; 106 } 107 } 108 109 void getDisplayType(hwc2_display_t display, hwc2_display_type_t* outType, 110 hwc2_error_t* outErr = nullptr) 111 { 112 auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_TYPE>( 113 getFunction(HWC2_FUNCTION_GET_DISPLAY_TYPE)); 114 ASSERT_TRUE(pfn) << "failed to get function"; 115 116 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 117 reinterpret_cast<int32_t*>(outType))); 118 if (outErr) { 119 *outErr = err; 120 } else { 121 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display type"; 122 } 123 } 124 125 /* If the populateDisplays function is still receiving displays and the 126 * display is connected, the display handle is stored in mDisplays. */ 127 void hotplugCallback(hwc2_display_t display, int32_t connected) 128 { 129 std::lock_guard<std::mutex> lock(mHotplugMutex); 130 131 if (mHotplugStatus != Hwc2TestHotplugStatus::Receiving) 132 return; 133 134 if (connected == HWC2_CONNECTION_CONNECTED) 135 mDisplays.insert(display); 136 137 mHotplugCv.notify_all(); 138 } 139 140 void createLayer(hwc2_display_t display, hwc2_layer_t* outLayer, 141 hwc2_error_t* outErr = nullptr) 142 { 143 auto pfn = reinterpret_cast<HWC2_PFN_CREATE_LAYER>( 144 getFunction(HWC2_FUNCTION_CREATE_LAYER)); 145 ASSERT_TRUE(pfn) << "failed to get function"; 146 147 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 148 outLayer)); 149 150 if (err == HWC2_ERROR_NONE) 151 mLayers.insert(std::make_pair(display, *outLayer)); 152 153 if (outErr) { 154 *outErr = err; 155 } else { 156 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create layer"; 157 } 158 } 159 160 void destroyLayer(hwc2_display_t display, hwc2_layer_t layer, 161 hwc2_error_t* outErr = nullptr) 162 { 163 auto pfn = reinterpret_cast<HWC2_PFN_DESTROY_LAYER>( 164 getFunction(HWC2_FUNCTION_DESTROY_LAYER)); 165 ASSERT_TRUE(pfn) << "failed to get function"; 166 167 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer)); 168 169 if (err == HWC2_ERROR_NONE) 170 mLayers.erase(std::make_pair(display, layer)); 171 172 if (outErr) { 173 *outErr = err; 174 } else { 175 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to destroy layer " 176 << layer; 177 } 178 } 179 180 void getDisplayAttribute(hwc2_display_t display, hwc2_config_t config, 181 hwc2_attribute_t attribute, int32_t* outValue, 182 hwc2_error_t* outErr = nullptr) 183 { 184 auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>( 185 getFunction(HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE)); 186 ASSERT_TRUE(pfn) << "failed to get function"; 187 188 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, config, 189 attribute, outValue)); 190 191 if (outErr) { 192 *outErr = err; 193 } else { 194 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display attribute " 195 << getAttributeName(attribute) << " for config " << config; 196 } 197 } 198 199 void getDisplayConfigs(hwc2_display_t display, 200 std::vector<hwc2_config_t>* outConfigs, 201 hwc2_error_t* outErr = nullptr) 202 { 203 auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_CONFIGS>( 204 getFunction(HWC2_FUNCTION_GET_DISPLAY_CONFIGS)); 205 ASSERT_TRUE(pfn) << "failed to get function"; 206 207 uint32_t numConfigs = 0; 208 209 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 210 &numConfigs, nullptr)); 211 212 if (err == HWC2_ERROR_NONE) { 213 outConfigs->resize(numConfigs); 214 215 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 216 &numConfigs, outConfigs->data())); 217 } 218 219 if (outErr) { 220 *outErr = err; 221 } else { 222 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get configs for" 223 " display " << display; 224 } 225 } 226 227 void getActiveConfig(hwc2_display_t display, hwc2_config_t* outConfig, 228 hwc2_error_t* outErr = nullptr) 229 { 230 auto pfn = reinterpret_cast<HWC2_PFN_GET_ACTIVE_CONFIG>( 231 getFunction(HWC2_FUNCTION_GET_ACTIVE_CONFIG)); 232 ASSERT_TRUE(pfn) << "failed to get function"; 233 234 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 235 outConfig)); 236 if (outErr) { 237 *outErr = err; 238 } else { 239 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get active config on" 240 " display " << display; 241 } 242 } 243 244 void setActiveConfig(hwc2_display_t display, hwc2_config_t config, 245 hwc2_error_t* outErr = nullptr) 246 { 247 auto pfn = reinterpret_cast<HWC2_PFN_SET_ACTIVE_CONFIG>( 248 getFunction(HWC2_FUNCTION_SET_ACTIVE_CONFIG)); 249 ASSERT_TRUE(pfn) << "failed to get function"; 250 251 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, config)); 252 if (outErr) { 253 *outErr = err; 254 } else { 255 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set active config " 256 << config; 257 } 258 } 259 260 void getDozeSupport(hwc2_display_t display, int32_t* outSupport, 261 hwc2_error_t* outErr = nullptr) 262 { 263 auto pfn = reinterpret_cast<HWC2_PFN_GET_DOZE_SUPPORT>( 264 getFunction(HWC2_FUNCTION_GET_DOZE_SUPPORT)); 265 ASSERT_TRUE(pfn) << "failed to get function"; 266 267 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 268 outSupport)); 269 if (outErr) { 270 *outErr = err; 271 } else { 272 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get doze support on" 273 " display " << display; 274 } 275 } 276 277 void setPowerMode(hwc2_display_t display, hwc2_power_mode_t mode, 278 hwc2_error_t* outErr = nullptr) 279 { 280 auto pfn = reinterpret_cast<HWC2_PFN_SET_POWER_MODE>( 281 getFunction(HWC2_FUNCTION_SET_POWER_MODE)); 282 ASSERT_TRUE(pfn) << "failed to get function"; 283 284 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 285 mode)); 286 if (outErr) { 287 *outErr = err; 288 if (err != HWC2_ERROR_NONE) 289 return; 290 } else { 291 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set power mode " 292 << getPowerModeName(mode) << " on display " << display; 293 } 294 295 if (mode == HWC2_POWER_MODE_OFF) { 296 mActiveDisplays.erase(display); 297 } else { 298 mActiveDisplays.insert(display); 299 } 300 } 301 302 void setVsyncEnabled(hwc2_display_t display, hwc2_vsync_t enabled, 303 hwc2_error_t* outErr = nullptr) 304 { 305 auto pfn = reinterpret_cast<HWC2_PFN_SET_VSYNC_ENABLED>( 306 getFunction(HWC2_FUNCTION_SET_VSYNC_ENABLED)); 307 ASSERT_TRUE(pfn) << "failed to get function"; 308 309 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 310 enabled)); 311 if (outErr) { 312 *outErr = err; 313 } else { 314 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set vsync enabled " 315 << getVsyncName(enabled); 316 } 317 } 318 319 void vsyncCallback(hwc2_display_t display, int64_t timestamp) 320 { 321 std::lock_guard<std::mutex> lock(mVsyncMutex); 322 mVsyncDisplay = display; 323 mVsyncTimestamp = timestamp; 324 mVsyncCv.notify_all(); 325 } 326 327 void getDisplayName(hwc2_display_t display, std::string* outName, 328 hwc2_error_t* outErr = nullptr) 329 { 330 auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_NAME>( 331 getFunction(HWC2_FUNCTION_GET_DISPLAY_NAME)); 332 ASSERT_TRUE(pfn) << "failed to get function"; 333 334 uint32_t size = 0; 335 336 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, &size, 337 nullptr)); 338 339 if (err == HWC2_ERROR_NONE) { 340 std::vector<char> name(size); 341 342 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, &size, 343 name.data())); 344 345 outName->assign(name.data()); 346 } 347 348 if (outErr) { 349 *outErr = err; 350 } else { 351 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display name for " 352 << display; 353 } 354 } 355 356 void setLayerCompositionType(hwc2_display_t display, hwc2_layer_t layer, 357 hwc2_composition_t composition, hwc2_error_t* outErr = nullptr) 358 { 359 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>( 360 getFunction(HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE)); 361 ASSERT_TRUE(pfn) << "failed to get function"; 362 363 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, 364 composition)); 365 if (outErr) { 366 *outErr = err; 367 } else { 368 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer composition" 369 " type " << getCompositionName(composition); 370 } 371 } 372 373 void setCursorPosition(hwc2_display_t display, hwc2_layer_t layer, 374 int32_t x, int32_t y, hwc2_error_t* outErr = nullptr) 375 { 376 auto pfn = reinterpret_cast<HWC2_PFN_SET_CURSOR_POSITION>( 377 getFunction(HWC2_FUNCTION_SET_CURSOR_POSITION)); 378 ASSERT_TRUE(pfn) << "failed to get function"; 379 380 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, x, 381 y)); 382 if (outErr) { 383 *outErr = err; 384 } else { 385 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set cursor position"; 386 } 387 } 388 389 void setLayerBlendMode(hwc2_display_t display, hwc2_layer_t layer, 390 hwc2_blend_mode_t mode, hwc2_error_t* outErr = nullptr) 391 { 392 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_BLEND_MODE>( 393 getFunction(HWC2_FUNCTION_SET_LAYER_BLEND_MODE)); 394 ASSERT_TRUE(pfn) << "failed to get function"; 395 396 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, 397 mode)); 398 if (outErr) { 399 *outErr = err; 400 } else { 401 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer blend mode " 402 << getBlendModeName(mode); 403 } 404 } 405 406 void setLayerBuffer(hwc2_display_t display, hwc2_layer_t layer, 407 buffer_handle_t buffer, int32_t acquireFence, 408 hwc2_error_t* outErr = nullptr) 409 { 410 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_BUFFER>( 411 getFunction(HWC2_FUNCTION_SET_LAYER_BUFFER)); 412 ASSERT_TRUE(pfn) << "failed to get function"; 413 414 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, 415 buffer, acquireFence)); 416 if (outErr) { 417 *outErr = err; 418 } else { 419 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer buffer"; 420 } 421 } 422 423 void setLayerColor(hwc2_display_t display, hwc2_layer_t layer, 424 hwc_color_t color, hwc2_error_t* outErr = nullptr) 425 { 426 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_COLOR>( 427 getFunction(HWC2_FUNCTION_SET_LAYER_COLOR)); 428 ASSERT_TRUE(pfn) << "failed to get function"; 429 430 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, 431 color)); 432 if (outErr) { 433 *outErr = err; 434 } else { 435 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer color"; 436 } 437 } 438 439 void setLayerDataspace(hwc2_display_t display, hwc2_layer_t layer, 440 android_dataspace_t dataspace, hwc2_error_t* outErr = nullptr) 441 { 442 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_DATASPACE>( 443 getFunction(HWC2_FUNCTION_SET_LAYER_DATASPACE)); 444 ASSERT_TRUE(pfn) << "failed to get function"; 445 446 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 447 layer, dataspace)); 448 if (outErr) { 449 *outErr = err; 450 } else { 451 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer dataspace"; 452 } 453 } 454 455 void setLayerDisplayFrame(hwc2_display_t display, hwc2_layer_t layer, 456 const hwc_rect_t& displayFrame, hwc2_error_t* outErr = nullptr) 457 { 458 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>( 459 getFunction(HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME)); 460 ASSERT_TRUE(pfn) << "failed to get function"; 461 462 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, 463 displayFrame)); 464 if (outErr) { 465 *outErr = err; 466 } else { 467 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer display" 468 " frame"; 469 } 470 } 471 472 void setLayerPlaneAlpha(hwc2_display_t display, hwc2_layer_t layer, 473 float alpha, hwc2_error_t* outErr = nullptr) 474 { 475 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_PLANE_ALPHA>( 476 getFunction(HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA)); 477 ASSERT_TRUE(pfn) << "failed to get function"; 478 479 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, 480 alpha)); 481 if (outErr) { 482 *outErr = err; 483 } else { 484 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer plane alpha " 485 << alpha; 486 } 487 } 488 489 void setLayerSourceCrop(hwc2_display_t display, hwc2_layer_t layer, 490 const hwc_frect_t& sourceCrop, hwc2_error_t* outErr = nullptr) 491 { 492 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_SOURCE_CROP>( 493 getFunction(HWC2_FUNCTION_SET_LAYER_SOURCE_CROP)); 494 ASSERT_TRUE(pfn) << "failed to get function"; 495 496 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, 497 sourceCrop)); 498 if (outErr) { 499 *outErr = err; 500 } else { 501 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer source crop"; 502 } 503 } 504 505 void setLayerSurfaceDamage(hwc2_display_t display, hwc2_layer_t layer, 506 const hwc_region_t& surfaceDamage, hwc2_error_t* outErr = nullptr) 507 { 508 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>( 509 getFunction(HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE)); 510 ASSERT_TRUE(pfn) << "failed to get function"; 511 512 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, 513 surfaceDamage)); 514 if (outErr) { 515 *outErr = err; 516 } else { 517 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer surface" 518 " damage"; 519 } 520 } 521 522 void setLayerTransform(hwc2_display_t display, hwc2_layer_t layer, 523 hwc_transform_t transform, hwc2_error_t* outErr = nullptr) 524 { 525 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_TRANSFORM>( 526 getFunction(HWC2_FUNCTION_SET_LAYER_TRANSFORM)); 527 ASSERT_TRUE(pfn) << "failed to get function"; 528 529 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, 530 transform)); 531 if (outErr) { 532 *outErr = err; 533 } else { 534 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer transform " 535 << getTransformName(transform); 536 } 537 } 538 539 void setLayerVisibleRegion(hwc2_display_t display, hwc2_layer_t layer, 540 const hwc_region_t& visibleRegion, hwc2_error_t* outErr = nullptr) 541 { 542 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_VISIBLE_REGION>( 543 getFunction(HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION)); 544 ASSERT_TRUE(pfn) << "failed to get function"; 545 546 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, 547 visibleRegion)); 548 if (outErr) { 549 *outErr = err; 550 } else { 551 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer visible" 552 " region"; 553 } 554 } 555 556 void setLayerZOrder(hwc2_display_t display, hwc2_layer_t layer, 557 uint32_t zOrder, hwc2_error_t* outErr = nullptr) 558 { 559 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_Z_ORDER>( 560 getFunction(HWC2_FUNCTION_SET_LAYER_Z_ORDER)); 561 ASSERT_TRUE(pfn) << "failed to get function"; 562 563 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, 564 zOrder)); 565 if (outErr) { 566 *outErr = err; 567 } else { 568 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer z order " 569 << zOrder; 570 } 571 } 572 573 void validateDisplay(hwc2_display_t display, uint32_t* outNumTypes, 574 uint32_t* outNumRequests, hwc2_error_t* outErr) 575 { 576 auto pfn = reinterpret_cast<HWC2_PFN_VALIDATE_DISPLAY>( 577 getFunction(HWC2_FUNCTION_VALIDATE_DISPLAY)); 578 ASSERT_TRUE(pfn) << "failed to get function"; 579 580 *outErr = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 581 outNumTypes, outNumRequests)); 582 } 583 584 void validateDisplay(hwc2_display_t display, uint32_t* outNumTypes, 585 uint32_t* outNumRequests, bool* outHasChanges) 586 { 587 hwc2_error_t err = HWC2_ERROR_NONE; 588 589 EXPECT_NO_FATAL_FAILURE(validateDisplay(display, outNumTypes, 590 outNumRequests, &err)); 591 592 if (err != HWC2_ERROR_HAS_CHANGES) { 593 *outHasChanges = false; 594 EXPECT_EQ(err, HWC2_ERROR_NONE) << "failed to validate display"; 595 } else { 596 *outHasChanges = true; 597 } 598 } 599 600 void getDisplayRequests(hwc2_display_t display, 601 hwc2_display_request_t* outDisplayRequests, 602 std::vector<hwc2_layer_t>* outLayers, 603 std::vector<hwc2_layer_request_t>* outLayerRequests, 604 hwc2_error_t* outErr = nullptr) 605 { 606 auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_REQUESTS>( 607 getFunction(HWC2_FUNCTION_GET_DISPLAY_REQUESTS)); 608 ASSERT_TRUE(pfn) << "failed to get function"; 609 610 uint32_t numElements = 0; 611 612 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 613 reinterpret_cast<int32_t*>(outDisplayRequests), &numElements, 614 nullptr, nullptr)); 615 616 if (err == HWC2_ERROR_NONE && numElements > 0) { 617 outLayers->resize(numElements); 618 outLayerRequests->resize(numElements); 619 620 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 621 reinterpret_cast<int32_t*>(outDisplayRequests), &numElements, 622 reinterpret_cast<uint64_t*>(outLayers->data()), 623 reinterpret_cast<int32_t*>(outLayerRequests->data()))); 624 } 625 626 if (outErr) { 627 *outErr = err; 628 } else { 629 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display requests"; 630 } 631 } 632 633 void handleRequests(hwc2_display_t display, 634 const std::vector<hwc2_layer_t>& layers, uint32_t numRequests, 635 std::set<hwc2_layer_t>* outClearLayers = nullptr, 636 bool* outFlipClientTarget = nullptr) 637 { 638 hwc2_display_request_t displayRequest = 639 static_cast<hwc2_display_request_t>(0); 640 std::vector<hwc2_layer_t> requestedLayers; 641 std::vector<hwc2_layer_request_t> requests; 642 643 ASSERT_NO_FATAL_FAILURE(getDisplayRequests(display, &displayRequest, 644 &requestedLayers, &requests)); 645 646 EXPECT_EQ(numRequests, requests.size()) << "validate returned " 647 << numRequests << " requests and get display requests returned " 648 << requests.size() << " requests"; 649 650 for (size_t i = 0; i < requests.size(); i++) { 651 hwc2_layer_t requestedLayer = requestedLayers.at(i); 652 hwc2_layer_request_t request = requests.at(i); 653 654 EXPECT_EQ(std::count(layers.begin(), layers.end(), requestedLayer), 655 0) << "get display requests returned an unknown layer"; 656 EXPECT_NE(request, 0) << "returned empty request for layer " 657 << requestedLayer; 658 659 if (outClearLayers && request 660 == HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET) 661 outClearLayers->insert(requestedLayer); 662 } 663 664 if (outFlipClientTarget) 665 *outFlipClientTarget = displayRequest 666 & HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET; 667 } 668 669 void getChangedCompositionTypes(hwc2_display_t display, 670 std::vector<hwc2_layer_t>* outLayers, 671 std::vector<hwc2_composition_t>* outTypes, 672 hwc2_error_t* outErr = nullptr) 673 { 674 auto pfn = reinterpret_cast<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>( 675 getFunction(HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES)); 676 ASSERT_TRUE(pfn) << "failed to get function"; 677 678 uint32_t numElements = 0; 679 680 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 681 &numElements, nullptr, nullptr)); 682 683 if (err == HWC2_ERROR_NONE && numElements > 0) { 684 outLayers->resize(numElements); 685 outTypes->resize(numElements); 686 687 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 688 &numElements, reinterpret_cast<uint64_t*>(outLayers->data()), 689 reinterpret_cast<int32_t*>(outTypes->data()))); 690 } 691 692 if (outErr) { 693 *outErr = err; 694 } else { 695 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get changed" 696 " composition types"; 697 } 698 } 699 700 void handleCompositionChanges(hwc2_display_t display, 701 const Hwc2TestLayers& testLayers, 702 const std::vector<hwc2_layer_t>& layers, uint32_t numTypes, 703 std::set<hwc2_layer_t>* outClientLayers = nullptr) 704 { 705 std::vector<hwc2_layer_t> changedLayers; 706 std::vector<hwc2_composition_t> types; 707 708 ASSERT_NO_FATAL_FAILURE(getChangedCompositionTypes(display, 709 &changedLayers, &types)); 710 711 EXPECT_EQ(numTypes, types.size()) << "validate returned " 712 << numTypes << " types and get changed composition types" 713 " returned " << types.size() << " types"; 714 715 for (size_t i = 0; i < types.size(); i++) { 716 717 auto layer = std::find(layers.begin(), layers.end(), 718 changedLayers.at(i)); 719 720 EXPECT_TRUE(layer != layers.end() || !testLayers.contains(*layer)) 721 << "get changed composition types returned an unknown layer"; 722 723 hwc2_composition_t requestedType = testLayers.getComposition(*layer); 724 hwc2_composition_t returnedType = types.at(i); 725 726 EXPECT_NE(returnedType, HWC2_COMPOSITION_INVALID) << "get changed" 727 " composition types returned invalid composition"; 728 729 switch (requestedType) { 730 case HWC2_COMPOSITION_CLIENT: 731 EXPECT_TRUE(false) << getCompositionName(returnedType) 732 << " cannot be changed"; 733 break; 734 case HWC2_COMPOSITION_DEVICE: 735 case HWC2_COMPOSITION_SOLID_COLOR: 736 EXPECT_EQ(returnedType, HWC2_COMPOSITION_CLIENT) 737 << "composition of type " 738 << getCompositionName(requestedType) 739 << " can only be changed to " 740 << getCompositionName(HWC2_COMPOSITION_CLIENT); 741 break; 742 case HWC2_COMPOSITION_CURSOR: 743 case HWC2_COMPOSITION_SIDEBAND: 744 EXPECT_TRUE(returnedType == HWC2_COMPOSITION_CLIENT 745 || returnedType == HWC2_COMPOSITION_DEVICE) 746 << "composition of type " 747 << getCompositionName(requestedType) 748 << " can only be changed to " 749 << getCompositionName(HWC2_COMPOSITION_CLIENT) << " or " 750 << getCompositionName(HWC2_COMPOSITION_DEVICE); 751 break; 752 default: 753 EXPECT_TRUE(false) << "unknown type " 754 << getCompositionName(requestedType); 755 break; 756 } 757 758 if (outClientLayers) 759 if (returnedType == HWC2_COMPOSITION_CLIENT) 760 outClientLayers->insert(*layer); 761 } 762 763 if (outClientLayers) { 764 for (auto layer : layers) { 765 if (testLayers.getComposition(layer) == HWC2_COMPOSITION_CLIENT) 766 outClientLayers->insert(layer); 767 } 768 } 769 } 770 771 void acceptDisplayChanges(hwc2_display_t display, 772 hwc2_error_t* outErr = nullptr) 773 { 774 auto pfn = reinterpret_cast<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>( 775 getFunction(HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES)); 776 ASSERT_TRUE(pfn) << "failed to get function"; 777 778 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display)); 779 if (outErr) { 780 *outErr = err; 781 } else { 782 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to accept display changes"; 783 } 784 } 785 786 void getClientTargetSupport(hwc2_display_t display, int32_t width, 787 int32_t height, android_pixel_format_t format, 788 android_dataspace_t dataspace, hwc2_error_t* outErr = nullptr) 789 { 790 auto pfn = reinterpret_cast<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>( 791 getFunction(HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT)); 792 ASSERT_TRUE(pfn) << "failed to get function"; 793 794 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, width, 795 height, format, dataspace)); 796 if (outErr) { 797 *outErr = err; 798 } else { 799 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get client target" 800 " support"; 801 } 802 } 803 804 void setClientTarget(hwc2_display_t display, buffer_handle_t handle, 805 int32_t acquireFence, android_dataspace_t dataspace, 806 hwc_region_t damage, hwc2_error_t* outErr = nullptr) 807 { 808 auto pfn = reinterpret_cast<HWC2_PFN_SET_CLIENT_TARGET>( 809 getFunction(HWC2_FUNCTION_SET_CLIENT_TARGET)); 810 ASSERT_TRUE(pfn) << "failed to get function"; 811 812 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, handle, 813 acquireFence, dataspace, damage)); 814 if (outErr) { 815 *outErr = err; 816 } else { 817 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set client target"; 818 } 819 } 820 821 void presentDisplay(hwc2_display_t display, int32_t* outPresentFence, 822 hwc2_error_t* outErr = nullptr) 823 { 824 auto pfn = reinterpret_cast<HWC2_PFN_PRESENT_DISPLAY>( 825 getFunction(HWC2_FUNCTION_PRESENT_DISPLAY)); 826 ASSERT_TRUE(pfn) << "failed to get function"; 827 828 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 829 outPresentFence)); 830 if (outErr) { 831 *outErr = err; 832 } else { 833 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to present display"; 834 } 835 } 836 837 void getReleaseFences(hwc2_display_t display, 838 std::vector<hwc2_layer_t>* outLayers, 839 std::vector<int32_t>* outFences, hwc2_error_t* outErr = nullptr) 840 { 841 auto pfn = reinterpret_cast<HWC2_PFN_GET_RELEASE_FENCES>( 842 getFunction(HWC2_FUNCTION_GET_RELEASE_FENCES)); 843 ASSERT_TRUE(pfn) << "failed to get function"; 844 845 uint32_t numElements = 0; 846 847 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 848 &numElements, nullptr, nullptr)); 849 850 if (err == HWC2_ERROR_NONE) { 851 outLayers->resize(numElements); 852 outFences->resize(numElements); 853 854 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 855 &numElements, outLayers->data(), outFences->data())); 856 } 857 858 if (outErr) { 859 *outErr = err; 860 } else { 861 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get release fences"; 862 } 863 } 864 865 void getColorModes(hwc2_display_t display, 866 std::vector<android_color_mode_t>* outColorModes, 867 hwc2_error_t* outErr = nullptr) 868 { 869 auto pfn = reinterpret_cast<HWC2_PFN_GET_COLOR_MODES>( 870 getFunction(HWC2_FUNCTION_GET_COLOR_MODES)); 871 ASSERT_TRUE(pfn) << "failed to get function"; 872 873 uint32_t numColorModes = 0; 874 875 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 876 &numColorModes, nullptr)); 877 if (err == HWC2_ERROR_NONE) { 878 outColorModes->resize(numColorModes); 879 880 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 881 &numColorModes, 882 reinterpret_cast<int32_t*>(outColorModes->data()))); 883 } 884 885 if (outErr) { 886 *outErr = err; 887 } else { 888 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get color modes for" 889 " display " << display; 890 } 891 } 892 893 void setColorMode(hwc2_display_t display, android_color_mode_t colorMode, 894 hwc2_error_t* outErr = nullptr) 895 { 896 auto pfn = reinterpret_cast<HWC2_PFN_SET_COLOR_MODE>( 897 getFunction(HWC2_FUNCTION_SET_COLOR_MODE)); 898 ASSERT_TRUE(pfn) << "failed to get function"; 899 900 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 901 static_cast<int32_t>(colorMode))); 902 if (outErr) { 903 *outErr = err; 904 } else { 905 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set color mode " 906 << colorMode; 907 } 908 } 909 910 void getHdrCapabilities(hwc2_display_t display, 911 std::vector<android_hdr_t>* outTypes, float* outMaxLuminance, 912 float* outMaxAverageLuminance, float* outMinLuminance, 913 hwc2_error_t* outErr = nullptr) 914 { 915 auto pfn = reinterpret_cast<HWC2_PFN_GET_HDR_CAPABILITIES>( 916 getFunction(HWC2_FUNCTION_GET_HDR_CAPABILITIES)); 917 ASSERT_TRUE(pfn) << "failed to get function"; 918 919 uint32_t numTypes = 0; 920 921 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 922 &numTypes, nullptr, outMaxLuminance, outMaxAverageLuminance, 923 outMinLuminance)); 924 925 if (err == HWC2_ERROR_NONE) { 926 outTypes->resize(numTypes); 927 928 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, &numTypes, 929 reinterpret_cast<int32_t*>(outTypes->data()), outMaxLuminance, 930 outMaxAverageLuminance, outMinLuminance)); 931 } 932 933 if (outErr) { 934 *outErr = err; 935 } else { 936 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get hdr capabilities" 937 " for display " << display; 938 } 939 } 940 941 void setColorTransform(hwc2_display_t display, 942 const std::array<float, 16>& matrix, android_color_transform_t hint, 943 hwc2_error_t* outErr = nullptr) 944 { 945 auto pfn = reinterpret_cast<HWC2_PFN_SET_COLOR_TRANSFORM>( 946 getFunction(HWC2_FUNCTION_SET_COLOR_TRANSFORM)); 947 ASSERT_TRUE(pfn) << "failed to get function"; 948 949 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, 950 matrix.data(), hint)); 951 952 if (outErr) { 953 *outErr = err; 954 } else { 955 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set color transform " 956 << hint; 957 } 958 } 959 960 void createVirtualDisplay(uint32_t width, uint32_t height, 961 android_pixel_format_t* outFormat, hwc2_display_t* outDisplay, 962 hwc2_error_t* outErr = nullptr) 963 { 964 auto pfn = reinterpret_cast<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>( 965 getFunction(HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY)); 966 ASSERT_TRUE(pfn) << "failed to get function"; 967 968 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, width, height, 969 reinterpret_cast<int32_t*>(outFormat), outDisplay)); 970 971 if (err == HWC2_ERROR_NONE) 972 mVirtualDisplays.insert(*outDisplay); 973 974 if (outErr) { 975 *outErr = err; 976 } else { 977 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create virtual display"; 978 } 979 } 980 981 void destroyVirtualDisplay(hwc2_display_t display, 982 hwc2_error_t* outErr = nullptr) 983 { 984 auto pfn = reinterpret_cast<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>( 985 getFunction(HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY)); 986 ASSERT_TRUE(pfn) << "failed to get function"; 987 988 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display)); 989 990 if (err == HWC2_ERROR_NONE) 991 mVirtualDisplays.erase(display); 992 993 if (outErr) { 994 *outErr = err; 995 } else { 996 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to destroy virtual display"; 997 } 998 } 999 1000 void getMaxVirtualDisplayCount(uint32_t* outMaxCnt) 1001 { 1002 auto pfn = reinterpret_cast<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>( 1003 getFunction(HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT)); 1004 ASSERT_TRUE(pfn) << "failed to get function"; 1005 1006 *outMaxCnt = pfn(mHwc2Device); 1007 } 1008 1009 void setOutputBuffer(hwc2_display_t display, buffer_handle_t buffer, 1010 int32_t releaseFence, hwc2_error_t* outErr = nullptr) 1011 { 1012 auto pfn = reinterpret_cast<HWC2_PFN_SET_OUTPUT_BUFFER>( 1013 getFunction(HWC2_FUNCTION_SET_OUTPUT_BUFFER)); 1014 ASSERT_TRUE(pfn) << "failed to get function"; 1015 1016 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, buffer, 1017 releaseFence)); 1018 if (outErr) { 1019 *outErr = err; 1020 } else { 1021 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set output buffer"; 1022 } 1023 } 1024 1025 void dump(std::string* outBuffer) 1026 { 1027 auto pfn = reinterpret_cast<HWC2_PFN_DUMP>( 1028 getFunction(HWC2_FUNCTION_DUMP)); 1029 ASSERT_TRUE(pfn) << "failed to get function"; 1030 1031 uint32_t size = 0; 1032 1033 pfn(mHwc2Device, &size, nullptr); 1034 1035 std::vector<char> buffer(size); 1036 1037 pfn(mHwc2Device, &size, buffer.data()); 1038 1039 outBuffer->assign(buffer.data()); 1040 } 1041 1042 void getBadDisplay(hwc2_display_t* outDisplay) 1043 { 1044 for (hwc2_display_t display = 0; display < UINT64_MAX; display++) { 1045 if (mDisplays.count(display) == 0) { 1046 *outDisplay = display; 1047 return; 1048 } 1049 } 1050 ASSERT_TRUE(false) << "Unable to find bad display. UINT64_MAX displays" 1051 " are registered. This should never happen."; 1052 } 1053 1054 void waitForVsync(hwc2_display_t* outDisplay = nullptr, 1055 int64_t* outTimestamp = nullptr) 1056 { 1057 std::unique_lock<std::mutex> lock(mVsyncMutex); 1058 ASSERT_EQ(mVsyncCv.wait_for(lock, std::chrono::seconds(3)), 1059 std::cv_status::no_timeout) << "timed out attempting to get" 1060 " vsync callback"; 1061 if (outDisplay) 1062 *outDisplay = mVsyncDisplay; 1063 if (outTimestamp) 1064 *outTimestamp = mVsyncTimestamp; 1065 } 1066 1067 void enableVsync(hwc2_display_t display) 1068 { 1069 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, this, 1070 reinterpret_cast<hwc2_function_pointer_t>( 1071 hwc2TestVsyncCallback))); 1072 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); 1073 } 1074 1075 void disableVsync(hwc2_display_t display) 1076 { 1077 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); 1078 } 1079 1080 protected: 1081 hwc2_function_pointer_t getFunction(hwc2_function_descriptor_t descriptor) 1082 { 1083 return mHwc2Device->getFunction(mHwc2Device, descriptor); 1084 } 1085 1086 void getCapabilities(std::vector<hwc2_capability_t>* outCapabilities) 1087 { 1088 uint32_t num = 0; 1089 1090 mHwc2Device->getCapabilities(mHwc2Device, &num, nullptr); 1091 1092 outCapabilities->resize(num); 1093 1094 mHwc2Device->getCapabilities(mHwc2Device, &num, 1095 reinterpret_cast<int32_t*>(outCapabilities->data())); 1096 } 1097 1098 /* Registers a hotplug callback and waits for hotplug callbacks. This 1099 * function will have no effect if called more than once. */ 1100 void populateDisplays() 1101 { 1102 /* Sets the hotplug status to receiving */ 1103 { 1104 std::lock_guard<std::mutex> lock(mHotplugMutex); 1105 1106 if (mHotplugStatus != Hwc2TestHotplugStatus::Init) 1107 return; 1108 mHotplugStatus = Hwc2TestHotplugStatus::Receiving; 1109 } 1110 1111 /* Registers the callback. This function call cannot be locked because 1112 * a callback could happen on the same thread */ 1113 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_HOTPLUG, this, 1114 reinterpret_cast<hwc2_function_pointer_t>( 1115 hwc2TestHotplugCallback))); 1116 1117 /* Waits for hotplug events. If a hotplug event has not come within 1 1118 * second, stop waiting. */ 1119 std::unique_lock<std::mutex> lock(mHotplugMutex); 1120 1121 while (mHotplugCv.wait_for(lock, std::chrono::seconds(1)) != 1122 std::cv_status::timeout) { } 1123 1124 /* Sets the hotplug status to done. Future calls will have no effect */ 1125 mHotplugStatus = Hwc2TestHotplugStatus::Done; 1126 } 1127 1128 /* NOTE: will create min(newlayerCnt, max supported layers) layers */ 1129 void createLayers(hwc2_display_t display, 1130 std::vector<hwc2_layer_t>* outLayers, size_t newLayerCnt) 1131 { 1132 std::vector<hwc2_layer_t> newLayers; 1133 hwc2_layer_t layer; 1134 hwc2_error_t err = HWC2_ERROR_NONE; 1135 1136 for (size_t i = 0; i < newLayerCnt; i++) { 1137 1138 EXPECT_NO_FATAL_FAILURE(createLayer(display, &layer, &err)); 1139 if (err == HWC2_ERROR_NO_RESOURCES) 1140 break; 1141 if (err != HWC2_ERROR_NONE) { 1142 newLayers.clear(); 1143 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create layer"; 1144 } 1145 newLayers.push_back(layer); 1146 } 1147 1148 *outLayers = std::move(newLayers); 1149 } 1150 1151 void destroyLayers(hwc2_display_t display, 1152 std::vector<hwc2_layer_t>&& layers) 1153 { 1154 for (hwc2_layer_t layer : layers) { 1155 EXPECT_NO_FATAL_FAILURE(destroyLayer(display, layer)); 1156 } 1157 } 1158 1159 void getInvalidConfig(hwc2_display_t display, hwc2_config_t* outConfig) 1160 { 1161 std::vector<hwc2_config_t> configs; 1162 1163 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 1164 1165 hwc2_config_t CONFIG_MAX = UINT32_MAX; 1166 1167 ASSERT_LE(configs.size() - 1, CONFIG_MAX) << "every config value" 1168 " (2^32 values) has been taken which shouldn't happen"; 1169 1170 hwc2_config_t config; 1171 for (config = 0; config < CONFIG_MAX; config++) { 1172 if (std::count(configs.begin(), configs.end(), config) == 0) 1173 break; 1174 } 1175 1176 *outConfig = config; 1177 } 1178 1179 /* Calls a set property function from Hwc2Test to set a property value from 1180 * Hwc2TestLayer to hwc2_layer_t on hwc2_display_t */ 1181 using TestLayerPropertyFunction = void (*)(Hwc2Test* test, 1182 hwc2_display_t display, hwc2_layer_t layer, 1183 Hwc2TestLayer* testLayer, hwc2_error_t* outErr); 1184 1185 /* Calls a set property function from Hwc2Test to set property values from 1186 * Hwc2TestLayers to hwc2_layer_t on hwc2_display_t */ 1187 using TestLayerPropertiesFunction = void (*)(Hwc2Test* test, 1188 hwc2_display_t display, hwc2_layer_t layer, 1189 Hwc2TestLayers* testLayers); 1190 1191 /* Calls a set property function from Hwc2Test to set a bad property value 1192 * on hwc2_layer_t on hwc2_display_t */ 1193 using TestLayerPropertyBadLayerFunction = void (*)(Hwc2Test* test, 1194 hwc2_display_t display, hwc2_layer_t layer, 1195 Hwc2TestLayer* testLayer, hwc2_error_t* outErr); 1196 1197 /* Calls a set property function from Hwc2Test to set a bad property value 1198 * on hwc2_layer_t on hwc2_display_t */ 1199 using TestLayerPropertyBadParameterFunction = void (*)(Hwc2Test* test, 1200 hwc2_display_t display, hwc2_layer_t layer, hwc2_error_t* outErr); 1201 1202 /* Is called after a display is powered on and all layer properties have 1203 * been set. It should be used to test functions such as validate, accepting 1204 * changes, present, etc. */ 1205 using TestDisplayLayersFunction = void (*)(Hwc2Test* test, 1206 hwc2_display_t display, const std::vector<hwc2_layer_t>& layers, 1207 Hwc2TestLayers* testLayers); 1208 1209 /* It is called on an non validated display */ 1210 using TestDisplayNonValidatedLayersFunction = void (*)(Hwc2Test* test, 1211 hwc2_display_t display, std::vector<hwc2_layer_t>* layers); 1212 1213 /* Tests client target support on a particular display and config */ 1214 using TestClientTargetSupportFunction = void (*)(Hwc2Test* test, 1215 hwc2_display_t display, 1216 const Hwc2TestClientTargetSupport& testClientTargetSupport); 1217 1218 /* Tests a particular active display config */ 1219 using TestActiveDisplayConfigFunction = void (*)(Hwc2Test* test, 1220 hwc2_display_t display); 1221 1222 /* Tests a newly created virtual display */ 1223 using TestCreateVirtualDisplayFunction = void (*)(Hwc2Test* test, 1224 hwc2_display_t display, Hwc2TestVirtualDisplay* testVirtualDisplay); 1225 1226 /* Advances a property of Hwc2TestLayer */ 1227 using AdvanceProperty = bool (*)(Hwc2TestLayer* testLayer); 1228 1229 /* Advances properties of Hwc2TestLayers */ 1230 using AdvanceProperties = bool (*)(Hwc2TestLayers* testLayer); 1231 1232 /* Advances properties of Hwc2TestClientTargetSupport */ 1233 using AdvanceClientTargetSupport = bool (*)( 1234 Hwc2TestClientTargetSupport* testClientTargetSupport); 1235 1236 /* For each active display it cycles through each display config and tests 1237 * each property value. It creates a layer, sets the property and then 1238 * destroys the layer */ 1239 void setLayerProperty(Hwc2TestCoverage coverage, 1240 TestLayerPropertyFunction function, AdvanceProperty advance) 1241 { 1242 for (auto display : mDisplays) { 1243 std::vector<hwc2_config_t> configs; 1244 1245 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 1246 1247 for (auto config : configs) { 1248 hwc2_layer_t layer; 1249 Area displayArea; 1250 1251 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 1252 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, 1253 &displayArea)); 1254 Hwc2TestLayer testLayer(coverage, displayArea); 1255 1256 do { 1257 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); 1258 1259 ASSERT_NO_FATAL_FAILURE(function(this, display, layer, 1260 &testLayer, nullptr)); 1261 1262 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); 1263 } while (advance(&testLayer)); 1264 } 1265 } 1266 } 1267 1268 /* For each active display it cycles through each display config and tests 1269 * each property value. It creates a layer, cycles through each property 1270 * value and updates the layer property value and then destroys the layer */ 1271 void setLayerPropertyUpdate(Hwc2TestCoverage coverage, 1272 TestLayerPropertyFunction function, AdvanceProperty advance) 1273 { 1274 for (auto display : mDisplays) { 1275 std::vector<hwc2_config_t> configs; 1276 1277 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 1278 1279 for (auto config : configs) { 1280 hwc2_layer_t layer; 1281 Area displayArea; 1282 1283 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 1284 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, 1285 &displayArea)); 1286 Hwc2TestLayer testLayer(coverage, displayArea); 1287 1288 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); 1289 1290 do { 1291 ASSERT_NO_FATAL_FAILURE(function(this, display, layer, 1292 &testLayer, nullptr)); 1293 } while (advance(&testLayer)); 1294 1295 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); 1296 } 1297 } 1298 } 1299 1300 /* For each active display it cycles through each display config and tests 1301 * each property value. It creates multiple layers, calls the 1302 * TestLayerPropertiesFunction to set property values and then 1303 * destroys the layers */ 1304 void setLayerProperties(Hwc2TestCoverage coverage, size_t layerCnt, 1305 TestLayerPropertiesFunction function, AdvanceProperties advance) 1306 { 1307 for (auto display : mDisplays) { 1308 std::vector<hwc2_config_t> configs; 1309 1310 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 1311 1312 for (auto config : configs) { 1313 std::vector<hwc2_layer_t> layers; 1314 Area displayArea; 1315 1316 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 1317 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, 1318 &displayArea)); 1319 1320 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); 1321 Hwc2TestLayers testLayers(layers, coverage, displayArea); 1322 1323 do { 1324 for (auto layer : layers) { 1325 EXPECT_NO_FATAL_FAILURE(function(this, display, layer, 1326 &testLayers)); 1327 } 1328 } while (advance(&testLayers)); 1329 1330 ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers))); 1331 } 1332 } 1333 } 1334 1335 /* For each active display it cycles through each display config. 1336 * 1) It attempts to set a valid property value to bad layer handle. 1337 * 2) It creates a layer x and attempts to set a valid property value to 1338 * layer x + 1 1339 * 3) It destroys the layer x and attempts to set a valid property value to 1340 * the destroyed layer x. 1341 */ 1342 void setLayerPropertyBadLayer(Hwc2TestCoverage coverage, 1343 TestLayerPropertyBadLayerFunction function) 1344 { 1345 for (auto display : mDisplays) { 1346 std::vector<hwc2_config_t> configs; 1347 1348 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 1349 1350 for (auto config : configs) { 1351 hwc2_layer_t layer = 0; 1352 Area displayArea; 1353 hwc2_error_t err = HWC2_ERROR_NONE; 1354 1355 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 1356 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, 1357 &displayArea)); 1358 Hwc2TestLayer testLayer(coverage, displayArea); 1359 1360 ASSERT_NO_FATAL_FAILURE(function(this, display, layer, 1361 &testLayer, &err)); 1362 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; 1363 1364 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); 1365 1366 ASSERT_NO_FATAL_FAILURE(function(this, display, layer + 1, 1367 &testLayer, &err)); 1368 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; 1369 1370 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); 1371 1372 ASSERT_NO_FATAL_FAILURE(function(this, display, layer, 1373 &testLayer, &err)); 1374 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; 1375 } 1376 } 1377 } 1378 1379 /* For each active display it cycles through each display config and tests 1380 * each property value. It creates a layer, sets a bad property value and 1381 * then destroys the layer */ 1382 void setLayerPropertyBadParameter(TestLayerPropertyBadParameterFunction function) 1383 { 1384 for (auto display : mDisplays) { 1385 std::vector<hwc2_config_t> configs; 1386 1387 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 1388 1389 for (auto config : configs) { 1390 hwc2_layer_t layer; 1391 hwc2_error_t err = HWC2_ERROR_NONE; 1392 1393 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 1394 1395 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); 1396 1397 ASSERT_NO_FATAL_FAILURE(function(this, display, layer, &err)); 1398 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong" 1399 " error code"; 1400 1401 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); 1402 } 1403 } 1404 } 1405 1406 /* For each active display it powers on the display, cycles through each 1407 * config and creates a set of layers with a certain amount of coverage. 1408 * For each active display, for each config and for each set of layers, 1409 * it calls the TestDisplayLayersFunction */ 1410 void displayLayers(Hwc2TestCoverage coverage, size_t layerCnt, 1411 TestDisplayLayersFunction function) 1412 { 1413 for (auto display : mDisplays) { 1414 std::vector<hwc2_config_t> configs; 1415 1416 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 1417 1418 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 1419 1420 for (auto config : configs) { 1421 Area displayArea; 1422 std::vector<hwc2_layer_t> layers; 1423 1424 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 1425 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, &displayArea)); 1426 1427 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); 1428 Hwc2TestLayers testLayers(layers, coverage, displayArea); 1429 1430 do { 1431 bool skip; 1432 1433 ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers, 1434 &testLayers, &skip)); 1435 if (!skip) 1436 EXPECT_NO_FATAL_FAILURE(function(this, display, layers, 1437 &testLayers)); 1438 1439 } while (testLayers.advance()); 1440 1441 ASSERT_NO_FATAL_FAILURE(destroyLayers(display, 1442 std::move(layers))); 1443 } 1444 1445 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 1446 } 1447 } 1448 1449 /* For each active display, it calls the 1450 * TestDisplayNonValidatedLayersFunction on a variety on non-validated 1451 * layer combinations */ 1452 void displayNonValidatedLayers(size_t layerCnt, 1453 TestDisplayNonValidatedLayersFunction function) 1454 { 1455 for (auto display : mDisplays) { 1456 uint32_t numTypes, numRequests; 1457 std::vector<hwc2_layer_t> layers; 1458 bool hasChanges; 1459 1460 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 1461 1462 EXPECT_NO_FATAL_FAILURE(function(this, display, &layers)); 1463 1464 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); 1465 1466 EXPECT_NO_FATAL_FAILURE(function(this, display, &layers)); 1467 1468 for (auto layer : layers) { 1469 ASSERT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer, 1470 HWC2_COMPOSITION_CLIENT)); 1471 } 1472 1473 EXPECT_NO_FATAL_FAILURE(function(this, display, &layers)); 1474 1475 ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes, 1476 &numRequests, &hasChanges)); 1477 1478 for (auto layer : layers) { 1479 ASSERT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer, 1480 HWC2_COMPOSITION_DEVICE)); 1481 } 1482 1483 EXPECT_NO_FATAL_FAILURE(function(this, display, &layers)); 1484 1485 ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers))); 1486 1487 EXPECT_NO_FATAL_FAILURE(function(this, display, &layers)); 1488 1489 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 1490 } 1491 } 1492 1493 /* Test client target support on each config on each active display */ 1494 void setClientTargetSupport(Hwc2TestCoverage coverage, 1495 TestClientTargetSupportFunction function, 1496 AdvanceClientTargetSupport advance) 1497 { 1498 for (auto display : mDisplays) { 1499 std::vector<hwc2_config_t> configs; 1500 1501 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 1502 1503 for (auto config : configs) { 1504 Area displayArea; 1505 1506 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 1507 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, 1508 &displayArea)); 1509 Hwc2TestClientTargetSupport testClientTargetSupport(coverage, 1510 displayArea); 1511 1512 do { 1513 EXPECT_NO_FATAL_FAILURE(function(this, display, 1514 testClientTargetSupport)); 1515 1516 } while (advance(&testClientTargetSupport)); 1517 } 1518 } 1519 } 1520 1521 /* Cycles through each config on each active display and calls 1522 * a TestActiveDisplayConfigFunction */ 1523 void setActiveDisplayConfig(TestActiveDisplayConfigFunction function) 1524 { 1525 for (auto display : mDisplays) { 1526 std::vector<hwc2_config_t> configs; 1527 1528 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 1529 1530 for (auto config : configs) { 1531 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 1532 1533 EXPECT_NO_FATAL_FAILURE(function(this, display)); 1534 } 1535 } 1536 } 1537 1538 /* Creates a virtual display for testing */ 1539 void createVirtualDisplay(Hwc2TestCoverage coverage, 1540 TestCreateVirtualDisplayFunction function) 1541 { 1542 Hwc2TestVirtualDisplay testVirtualDisplay(coverage); 1543 1544 do { 1545 hwc2_display_t display; 1546 hwc2_error_t err = HWC2_ERROR_NONE; 1547 1548 const UnsignedArea& dimension = 1549 testVirtualDisplay.getDisplayDimension(); 1550 android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888; 1551 1552 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(dimension.width, 1553 dimension.height, &desiredFormat, &display, &err)); 1554 1555 EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_NO_RESOURCES 1556 || err == HWC2_ERROR_UNSUPPORTED) 1557 << "returned wrong error code"; 1558 EXPECT_GE(desiredFormat, 0) << "invalid format"; 1559 1560 if (err != HWC2_ERROR_NONE) 1561 continue; 1562 1563 EXPECT_NO_FATAL_FAILURE(function(this, display, 1564 &testVirtualDisplay)); 1565 1566 ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display)); 1567 1568 } while (testVirtualDisplay.advance()); 1569 } 1570 1571 1572 void getActiveConfigAttribute(hwc2_display_t display, 1573 hwc2_attribute_t attribute, int32_t* outValue) 1574 { 1575 hwc2_config_t config; 1576 ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &config)); 1577 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, 1578 attribute, outValue)); 1579 ASSERT_GE(*outValue, 0) << "failed to get valid " 1580 << getAttributeName(attribute); 1581 } 1582 1583 void getActiveDisplayArea(hwc2_display_t display, Area* displayArea) 1584 { 1585 ASSERT_NO_FATAL_FAILURE(getActiveConfigAttribute(display, 1586 HWC2_ATTRIBUTE_WIDTH, &displayArea->width)); 1587 ASSERT_NO_FATAL_FAILURE(getActiveConfigAttribute(display, 1588 HWC2_ATTRIBUTE_HEIGHT, &displayArea->height)); 1589 } 1590 1591 void closeFences(hwc2_display_t display, int32_t presentFence) 1592 { 1593 std::vector<hwc2_layer_t> layers; 1594 std::vector<int32_t> fences; 1595 const int msWait = 3000; 1596 1597 if (presentFence >= 0) { 1598 ASSERT_GE(sync_wait(presentFence, msWait), 0); 1599 close(presentFence); 1600 } 1601 1602 ASSERT_NO_FATAL_FAILURE(getReleaseFences(display, &layers, &fences)); 1603 EXPECT_EQ(layers.size(), fences.size()); 1604 1605 for (int32_t fence : fences) { 1606 EXPECT_GE(sync_wait(fence, msWait), 0); 1607 if (fence >= 0) 1608 close(fence); 1609 } 1610 } 1611 1612 void setLayerProperties(hwc2_display_t display, hwc2_layer_t layer, 1613 Hwc2TestLayers* testLayers, bool* outSkip) 1614 { 1615 hwc2_composition_t composition; 1616 buffer_handle_t handle = nullptr; 1617 int32_t acquireFence; 1618 hwc2_error_t err = HWC2_ERROR_NONE; 1619 *outSkip = true; 1620 1621 if (!testLayers->contains(layer)) 1622 return; 1623 1624 composition = testLayers->getComposition(layer); 1625 1626 /* If the device cannot support a buffer format, then do not continue */ 1627 if ((composition == HWC2_COMPOSITION_DEVICE 1628 || composition == HWC2_COMPOSITION_CURSOR) 1629 && testLayers->getBuffer(layer, &handle, &acquireFence) < 0) 1630 return; 1631 1632 EXPECT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer, 1633 composition, &err)); 1634 if (err == HWC2_ERROR_UNSUPPORTED) 1635 EXPECT_TRUE(composition != HWC2_COMPOSITION_CLIENT 1636 && composition != HWC2_COMPOSITION_DEVICE); 1637 1638 const hwc_rect_t cursor = testLayers->getCursorPosition(layer); 1639 1640 EXPECT_NO_FATAL_FAILURE(setLayerBuffer(display, layer, handle, 1641 acquireFence)); 1642 EXPECT_NO_FATAL_FAILURE(setLayerBlendMode(display, layer, 1643 testLayers->getBlendMode(layer))); 1644 EXPECT_NO_FATAL_FAILURE(setLayerColor(display, layer, 1645 testLayers->getColor(layer))); 1646 EXPECT_NO_FATAL_FAILURE(setCursorPosition(display, layer, cursor.left, 1647 cursor.top)); 1648 EXPECT_NO_FATAL_FAILURE(setLayerDataspace(display, layer, 1649 testLayers->getDataspace(layer))); 1650 EXPECT_NO_FATAL_FAILURE(setLayerDisplayFrame(display, layer, 1651 testLayers->getDisplayFrame(layer))); 1652 EXPECT_NO_FATAL_FAILURE(setLayerPlaneAlpha(display, layer, 1653 testLayers->getPlaneAlpha(layer))); 1654 EXPECT_NO_FATAL_FAILURE(setLayerSourceCrop(display, layer, 1655 testLayers->getSourceCrop(layer))); 1656 EXPECT_NO_FATAL_FAILURE(setLayerSurfaceDamage(display, layer, 1657 testLayers->getSurfaceDamage(layer))); 1658 EXPECT_NO_FATAL_FAILURE(setLayerTransform(display, layer, 1659 testLayers->getTransform(layer))); 1660 EXPECT_NO_FATAL_FAILURE(setLayerVisibleRegion(display, layer, 1661 testLayers->getVisibleRegion(layer))); 1662 EXPECT_NO_FATAL_FAILURE(setLayerZOrder(display, layer, 1663 testLayers->getZOrder(layer))); 1664 1665 *outSkip = false; 1666 } 1667 1668 void setLayerProperties(hwc2_display_t display, 1669 const std::vector<hwc2_layer_t>& layers, 1670 Hwc2TestLayers* testLayers, bool* outSkip) 1671 { 1672 for (auto layer : layers) { 1673 EXPECT_NO_FATAL_FAILURE(setLayerProperties(display, layer, 1674 testLayers, outSkip)); 1675 if (*outSkip) 1676 return; 1677 } 1678 } 1679 1680 void setClientTarget(hwc2_display_t display, 1681 Hwc2TestClientTarget* testClientTarget, 1682 const Hwc2TestLayers& testLayers, 1683 const std::set<hwc2_layer_t>& clientLayers, 1684 const std::set<hwc2_layer_t>& clearLayers, bool flipClientTarget, 1685 const Area& displayArea) 1686 { 1687 android_dataspace_t dataspace = HAL_DATASPACE_UNKNOWN; 1688 hwc_region_t damage = { }; 1689 buffer_handle_t handle; 1690 int32_t acquireFence; 1691 1692 ASSERT_EQ(testClientTarget->getBuffer(testLayers, clientLayers, 1693 clearLayers, flipClientTarget, displayArea, &handle, 1694 &acquireFence), 0); 1695 EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle, acquireFence, 1696 dataspace, damage)); 1697 } 1698 1699 void presentDisplays(size_t layerCnt, Hwc2TestCoverage coverage, 1700 const std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage>& 1701 coverageExceptions, bool optimize) 1702 { 1703 for (auto display : mDisplays) { 1704 std::vector<hwc2_config_t> configs; 1705 1706 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 1707 ASSERT_NO_FATAL_FAILURE(enableVsync(display)); 1708 1709 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 1710 1711 for (auto config : configs) { 1712 Area displayArea; 1713 std::vector<hwc2_layer_t> layers; 1714 1715 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 1716 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, 1717 &displayArea)); 1718 1719 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); 1720 Hwc2TestLayers testLayers(layers, coverage, displayArea, 1721 coverageExceptions); 1722 1723 if (optimize && !testLayers.optimizeLayouts()) 1724 continue; 1725 1726 std::set<hwc2_layer_t> clientLayers; 1727 std::set<hwc2_layer_t> clearLayers; 1728 Hwc2TestClientTarget testClientTarget; 1729 1730 do { 1731 uint32_t numTypes, numRequests; 1732 bool hasChanges, skip; 1733 bool flipClientTarget; 1734 int32_t presentFence; 1735 1736 ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers, 1737 &testLayers, &skip)); 1738 if (skip) 1739 continue; 1740 1741 ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes, 1742 &numRequests, &hasChanges)); 1743 if (hasChanges) 1744 EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size())) 1745 << "wrong number of requests"; 1746 1747 ASSERT_NO_FATAL_FAILURE(handleCompositionChanges(display, 1748 testLayers, layers, numTypes, &clientLayers)); 1749 ASSERT_NO_FATAL_FAILURE(handleRequests(display, layers, 1750 numRequests, &clearLayers, &flipClientTarget)); 1751 ASSERT_NO_FATAL_FAILURE(setClientTarget(display, 1752 &testClientTarget, testLayers, clientLayers, 1753 clearLayers, flipClientTarget, displayArea)); 1754 ASSERT_NO_FATAL_FAILURE(acceptDisplayChanges(display)); 1755 1756 ASSERT_NO_FATAL_FAILURE(waitForVsync()); 1757 1758 EXPECT_NO_FATAL_FAILURE(presentDisplay(display, 1759 &presentFence)); 1760 1761 ASSERT_NO_FATAL_FAILURE(closeFences(display, presentFence)); 1762 1763 } while (testLayers.advance()); 1764 1765 ASSERT_NO_FATAL_FAILURE(destroyLayers(display, 1766 std::move(layers))); 1767 } 1768 1769 ASSERT_NO_FATAL_FAILURE(disableVsync(display)); 1770 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 1771 } 1772 } 1773 1774 hwc2_device_t* mHwc2Device = nullptr; 1775 1776 enum class Hwc2TestHotplugStatus { 1777 Init = 1, 1778 Receiving, 1779 Done, 1780 }; 1781 1782 std::mutex mHotplugMutex; 1783 std::condition_variable mHotplugCv; 1784 Hwc2TestHotplugStatus mHotplugStatus = Hwc2TestHotplugStatus::Init; 1785 std::unordered_set<hwc2_display_t> mDisplays; 1786 1787 /* Store all created layers that have not been destroyed. If an ASSERT_* 1788 * fails, then destroy the layers on exit */ 1789 std::set<std::pair<hwc2_display_t, hwc2_layer_t>> mLayers; 1790 1791 /* Store the power mode state. If it is not HWC2_POWER_MODE_OFF when 1792 * tearing down the test cases, change it to HWC2_POWER_MODE_OFF */ 1793 std::set<hwc2_display_t> mActiveDisplays; 1794 1795 /* Store all created virtual displays that have not been destroyed. If an 1796 * ASSERT_* fails, then destroy the virtual displays on exit */ 1797 std::set<hwc2_display_t> mVirtualDisplays; 1798 1799 std::mutex mVsyncMutex; 1800 std::condition_variable mVsyncCv; 1801 hwc2_display_t mVsyncDisplay; 1802 int64_t mVsyncTimestamp = -1; 1803 }; 1804 1805 void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData, 1806 hwc2_display_t display, int32_t connection) 1807 { 1808 if (callbackData) 1809 static_cast<Hwc2Test*>(callbackData)->hotplugCallback(display, 1810 connection); 1811 } 1812 1813 void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData, 1814 hwc2_display_t display, int64_t timestamp) 1815 { 1816 if (callbackData) 1817 static_cast<Hwc2Test*>(callbackData)->vsyncCallback(display, 1818 timestamp); 1819 } 1820 1821 void setBlendMode(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1822 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1823 { 1824 EXPECT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer, 1825 testLayer->getBlendMode(), outErr)); 1826 } 1827 1828 void setBuffer(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1829 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1830 { 1831 buffer_handle_t handle; 1832 android::base::unique_fd acquireFence; 1833 hwc2_composition_t composition = testLayer->getComposition(); 1834 1835 if (composition == HWC2_COMPOSITION_CLIENT 1836 || composition == HWC2_COMPOSITION_SOLID_COLOR 1837 || composition == HWC2_COMPOSITION_SIDEBAND) 1838 return; 1839 1840 if (testLayer->getBuffer(&handle, &acquireFence) < 0) 1841 return; 1842 1843 ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, layer, 1844 composition)); 1845 EXPECT_NO_FATAL_FAILURE(test->setLayerBuffer(display, layer, 1846 handle, acquireFence, outErr)); 1847 } 1848 1849 void setColor(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1850 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1851 { 1852 ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, 1853 layer, HWC2_COMPOSITION_SOLID_COLOR)); 1854 ASSERT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display, 1855 layer, testLayer->getPlaneAlpha())); 1856 ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, 1857 layer, testLayer->getBlendMode())); 1858 EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer, 1859 testLayer->getColor(), outErr)); 1860 } 1861 1862 void setComposition(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1863 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1864 { 1865 hwc2_composition_t composition = testLayer->getComposition(); 1866 hwc2_error_t err = HWC2_ERROR_NONE; 1867 1868 ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, layer, 1869 composition, &err)); 1870 if (outErr) { 1871 *outErr = err; 1872 return; 1873 } 1874 1875 if (composition != HWC2_COMPOSITION_SIDEBAND) { 1876 EXPECT_EQ(err, HWC2_ERROR_NONE) << "returned wrong error code"; 1877 } else { 1878 EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_UNSUPPORTED) 1879 << "returned wrong error code"; 1880 } 1881 } 1882 1883 void setCursorPosition(Hwc2Test* test, hwc2_display_t display, 1884 hwc2_layer_t layer, Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1885 { 1886 ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, 1887 layer, HWC2_COMPOSITION_CURSOR)); 1888 1889 const hwc_rect_t cursorPosition = testLayer->getCursorPosition(); 1890 EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, layer, 1891 cursorPosition.left, cursorPosition.top, outErr)); 1892 } 1893 1894 void setDataspace(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1895 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1896 { 1897 EXPECT_NO_FATAL_FAILURE(test->setLayerDataspace(display, layer, 1898 testLayer->getDataspace(), outErr)); 1899 } 1900 1901 void setDisplayFrame(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1902 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1903 { 1904 EXPECT_NO_FATAL_FAILURE(test->setLayerDisplayFrame(display, layer, 1905 testLayer->getDisplayFrame(), outErr)); 1906 } 1907 1908 void setPlaneAlpha(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1909 Hwc2TestLayer* testLayer, hwc2_error_t *outErr) 1910 { 1911 ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer, 1912 testLayer->getBlendMode())); 1913 EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display, layer, 1914 testLayer->getPlaneAlpha(), outErr)); 1915 } 1916 1917 void setSourceCrop(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1918 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1919 { 1920 EXPECT_NO_FATAL_FAILURE(test->setLayerSourceCrop(display, layer, 1921 testLayer->getSourceCrop(), outErr)); 1922 } 1923 1924 void setSurfaceDamage(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1925 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1926 { 1927 EXPECT_NO_FATAL_FAILURE(test->setLayerSurfaceDamage(display, layer, 1928 testLayer->getSurfaceDamage(), outErr)); 1929 } 1930 1931 void setTransform(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1932 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1933 { 1934 EXPECT_NO_FATAL_FAILURE(test->setLayerTransform(display, layer, 1935 testLayer->getTransform(), outErr)); 1936 } 1937 1938 void setVisibleRegion(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1939 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1940 { 1941 EXPECT_NO_FATAL_FAILURE(test->setLayerVisibleRegion(display, layer, 1942 testLayer->getVisibleRegion(), outErr)); 1943 } 1944 1945 void setZOrder(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 1946 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) 1947 { 1948 EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer, 1949 testLayer->getZOrder(), outErr)); 1950 } 1951 1952 bool advanceBlendMode(Hwc2TestLayer* testLayer) 1953 { 1954 return testLayer->advanceBlendMode(); 1955 } 1956 1957 bool advanceBuffer(Hwc2TestLayer* testLayer) 1958 { 1959 if (testLayer->advanceComposition()) 1960 return true; 1961 return testLayer->advanceBufferArea(); 1962 } 1963 1964 bool advanceColor(Hwc2TestLayer* testLayer) 1965 { 1966 /* Color depends on blend mode so advance blend mode last so color is not 1967 * force to update as often */ 1968 if (testLayer->advancePlaneAlpha()) 1969 return true; 1970 if (testLayer->advanceColor()) 1971 return true; 1972 return testLayer->advanceBlendMode(); 1973 } 1974 1975 bool advanceComposition(Hwc2TestLayer* testLayer) 1976 { 1977 return testLayer->advanceComposition(); 1978 } 1979 1980 bool advanceCursorPosition(Hwc2TestLayer* testLayer) 1981 { 1982 return testLayer->advanceCursorPosition(); 1983 } 1984 1985 bool advanceDataspace(Hwc2TestLayer* testLayer) 1986 { 1987 return testLayer->advanceDataspace(); 1988 } 1989 1990 bool advanceDisplayFrame(Hwc2TestLayer* testLayer) 1991 { 1992 return testLayer->advanceDisplayFrame(); 1993 } 1994 1995 bool advancePlaneAlpha(Hwc2TestLayer* testLayer) 1996 { 1997 return testLayer->advancePlaneAlpha(); 1998 } 1999 2000 bool advanceSourceCrop(Hwc2TestLayer* testLayer) 2001 { 2002 if (testLayer->advanceSourceCrop()) 2003 return true; 2004 return testLayer->advanceBufferArea(); 2005 } 2006 2007 bool advanceSurfaceDamage(Hwc2TestLayer* testLayer) 2008 { 2009 if (testLayer->advanceSurfaceDamage()) 2010 return true; 2011 return testLayer->advanceBufferArea(); 2012 } 2013 2014 bool advanceTransform(Hwc2TestLayer* testLayer) 2015 { 2016 return testLayer->advanceTransform(); 2017 } 2018 2019 bool advanceVisibleRegions(Hwc2TestLayers* testLayers) 2020 { 2021 return testLayers->advanceVisibleRegions(); 2022 } 2023 2024 bool advanceClientTargetSupport( 2025 Hwc2TestClientTargetSupport* testClientTargetSupport) 2026 { 2027 return testClientTargetSupport->advance(); 2028 } 2029 2030 static const std::array<hwc2_function_descriptor_t, 42> requiredFunctions = {{ 2031 HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES, 2032 HWC2_FUNCTION_CREATE_LAYER, 2033 HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY, 2034 HWC2_FUNCTION_DESTROY_LAYER, 2035 HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY, 2036 HWC2_FUNCTION_DUMP, 2037 HWC2_FUNCTION_GET_ACTIVE_CONFIG, 2038 HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES, 2039 HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT, 2040 HWC2_FUNCTION_GET_COLOR_MODES, 2041 HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE, 2042 HWC2_FUNCTION_GET_DISPLAY_CONFIGS, 2043 HWC2_FUNCTION_GET_DISPLAY_NAME, 2044 HWC2_FUNCTION_GET_DISPLAY_REQUESTS, 2045 HWC2_FUNCTION_GET_DISPLAY_TYPE, 2046 HWC2_FUNCTION_GET_DOZE_SUPPORT, 2047 HWC2_FUNCTION_GET_HDR_CAPABILITIES, 2048 HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT, 2049 HWC2_FUNCTION_GET_RELEASE_FENCES, 2050 HWC2_FUNCTION_PRESENT_DISPLAY, 2051 HWC2_FUNCTION_REGISTER_CALLBACK, 2052 HWC2_FUNCTION_SET_ACTIVE_CONFIG, 2053 HWC2_FUNCTION_SET_CLIENT_TARGET, 2054 HWC2_FUNCTION_SET_COLOR_MODE, 2055 HWC2_FUNCTION_SET_COLOR_TRANSFORM, 2056 HWC2_FUNCTION_SET_CURSOR_POSITION, 2057 HWC2_FUNCTION_SET_LAYER_BLEND_MODE, 2058 HWC2_FUNCTION_SET_LAYER_BUFFER, 2059 HWC2_FUNCTION_SET_LAYER_COLOR, 2060 HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE, 2061 HWC2_FUNCTION_SET_LAYER_DATASPACE, 2062 HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME, 2063 HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA, 2064 HWC2_FUNCTION_SET_LAYER_SOURCE_CROP, 2065 HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE, 2066 HWC2_FUNCTION_SET_LAYER_TRANSFORM, 2067 HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION, 2068 HWC2_FUNCTION_SET_LAYER_Z_ORDER, 2069 HWC2_FUNCTION_SET_OUTPUT_BUFFER, 2070 HWC2_FUNCTION_SET_POWER_MODE, 2071 HWC2_FUNCTION_SET_VSYNC_ENABLED, 2072 HWC2_FUNCTION_VALIDATE_DISPLAY, 2073 }}; 2074 2075 /* TESTCASE: Tests that the HWC2 supports all required functions. */ 2076 TEST_F(Hwc2Test, GET_FUNCTION) 2077 { 2078 for (hwc2_function_descriptor_t descriptor : requiredFunctions) { 2079 hwc2_function_pointer_t pfn = getFunction(descriptor); 2080 EXPECT_TRUE(pfn) << "failed to get function " 2081 << getFunctionDescriptorName(descriptor); 2082 } 2083 } 2084 2085 /* TESTCASE: Tests that the HWC2 fails to retrieve and invalid function. */ 2086 TEST_F(Hwc2Test, GET_FUNCTION_invalid_function) 2087 { 2088 hwc2_function_pointer_t pfn = getFunction(HWC2_FUNCTION_INVALID); 2089 EXPECT_FALSE(pfn) << "failed to get invalid function"; 2090 } 2091 2092 /* TESTCASE: Tests that the HWC2 does not return an invalid capability. */ 2093 TEST_F(Hwc2Test, GET_CAPABILITIES) 2094 { 2095 std::vector<hwc2_capability_t> capabilities; 2096 2097 getCapabilities(&capabilities); 2098 2099 EXPECT_EQ(std::count(capabilities.begin(), capabilities.end(), 2100 HWC2_CAPABILITY_INVALID), 0); 2101 } 2102 2103 static const std::array<hwc2_callback_descriptor_t, 3> callbackDescriptors = {{ 2104 HWC2_CALLBACK_HOTPLUG, 2105 HWC2_CALLBACK_REFRESH, 2106 HWC2_CALLBACK_VSYNC, 2107 }}; 2108 2109 /* TESTCASE: Tests that the HWC2 can successfully register all required 2110 * callback functions. */ 2111 TEST_F(Hwc2Test, REGISTER_CALLBACK) 2112 { 2113 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( 2114 const_cast<char*>("data")); 2115 2116 for (auto descriptor : callbackDescriptors) { 2117 ASSERT_NO_FATAL_FAILURE(registerCallback(descriptor, data, 2118 []() { return; })); 2119 } 2120 } 2121 2122 /* TESTCASE: Test that the HWC2 fails to register invalid callbacks. */ 2123 TEST_F(Hwc2Test, REGISTER_CALLBACK_bad_parameter) 2124 { 2125 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( 2126 const_cast<char*>("data")); 2127 hwc2_error_t err = HWC2_ERROR_NONE; 2128 2129 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_INVALID, data, 2130 []() { return; }, &err)); 2131 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code"; 2132 } 2133 2134 /* TESTCASE: Tests that the HWC2 can register a callback with null data. */ 2135 TEST_F(Hwc2Test, REGISTER_CALLBACK_null_data) 2136 { 2137 hwc2_callback_data_t data = nullptr; 2138 2139 for (auto descriptor : callbackDescriptors) { 2140 ASSERT_NO_FATAL_FAILURE(registerCallback(descriptor, data, 2141 []() { return; })); 2142 } 2143 } 2144 2145 /* TESTCASE: Tests that the HWC2 returns the correct display type for each 2146 * physical display. */ 2147 TEST_F(Hwc2Test, GET_DISPLAY_TYPE) 2148 { 2149 for (auto display : mDisplays) { 2150 hwc2_display_type_t type; 2151 2152 ASSERT_NO_FATAL_FAILURE(getDisplayType(display, &type)); 2153 EXPECT_EQ(type, HWC2_DISPLAY_TYPE_PHYSICAL) << "failed to return" 2154 " correct display type"; 2155 } 2156 } 2157 2158 /* TESTCASE: Tests that the HWC2 returns an error when the display type of a bad 2159 * display is requested. */ 2160 TEST_F(Hwc2Test, GET_DISPLAY_TYPE_bad_display) 2161 { 2162 hwc2_display_t display; 2163 hwc2_display_type_t type; 2164 hwc2_error_t err = HWC2_ERROR_NONE; 2165 2166 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 2167 2168 ASSERT_NO_FATAL_FAILURE(getDisplayType(display, &type, &err)); 2169 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2170 } 2171 2172 /* TESTCASE: Tests that the HWC2 can create and destroy layers. */ 2173 TEST_F(Hwc2Test, CREATE_DESTROY_LAYER) 2174 { 2175 for (auto display : mDisplays) { 2176 hwc2_layer_t layer; 2177 2178 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); 2179 2180 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); 2181 } 2182 } 2183 2184 /* TESTCASE: Tests that the HWC2 cannot create a layer for a bad display */ 2185 TEST_F(Hwc2Test, CREATE_LAYER_bad_display) 2186 { 2187 hwc2_display_t display; 2188 hwc2_layer_t layer; 2189 hwc2_error_t err = HWC2_ERROR_NONE; 2190 2191 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 2192 2193 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer, &err)); 2194 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2195 } 2196 2197 /* TESTCASE: Tests that the HWC2 will either support a large number of resources 2198 * or will return no resources. */ 2199 TEST_F(Hwc2Test, CREATE_LAYER_no_resources) 2200 { 2201 const size_t layerCnt = 1000; 2202 2203 for (auto display : mDisplays) { 2204 std::vector<hwc2_layer_t> layers; 2205 2206 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); 2207 2208 ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers))); 2209 } 2210 } 2211 2212 /* TESTCASE: Tests that the HWC2 cannot destroy a layer for a bad display */ 2213 TEST_F(Hwc2Test, DESTROY_LAYER_bad_display) 2214 { 2215 hwc2_display_t badDisplay; 2216 2217 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&badDisplay)); 2218 2219 for (auto display : mDisplays) { 2220 hwc2_layer_t layer = 0; 2221 hwc2_error_t err = HWC2_ERROR_NONE; 2222 2223 ASSERT_NO_FATAL_FAILURE(destroyLayer(badDisplay, layer, &err)); 2224 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2225 2226 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); 2227 2228 ASSERT_NO_FATAL_FAILURE(destroyLayer(badDisplay, layer, &err)); 2229 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2230 2231 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); 2232 } 2233 } 2234 2235 /* TESTCASE: Tests that the HWC2 cannot destory a bad layer */ 2236 TEST_F(Hwc2Test, DESTROY_LAYER_bad_layer) 2237 { 2238 for (auto display : mDisplays) { 2239 hwc2_layer_t layer; 2240 hwc2_error_t err = HWC2_ERROR_NONE; 2241 2242 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX / 2, &err)); 2243 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; 2244 2245 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, 0, &err)); 2246 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; 2247 2248 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX - 1, &err)); 2249 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; 2250 2251 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, 1, &err)); 2252 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; 2253 2254 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX, &err)); 2255 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; 2256 2257 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); 2258 2259 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer + 1, &err)); 2260 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; 2261 2262 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); 2263 2264 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer, &err)); 2265 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; 2266 } 2267 } 2268 2269 static const std::array<hwc2_attribute_t, 2> requiredAttributes = {{ 2270 HWC2_ATTRIBUTE_WIDTH, 2271 HWC2_ATTRIBUTE_HEIGHT, 2272 }}; 2273 2274 static const std::array<hwc2_attribute_t, 3> optionalAttributes = {{ 2275 HWC2_ATTRIBUTE_VSYNC_PERIOD, 2276 HWC2_ATTRIBUTE_DPI_X, 2277 HWC2_ATTRIBUTE_DPI_Y, 2278 }}; 2279 2280 /* TESTCASE: Tests that the HWC2 can return display attributes for a valid 2281 * config. */ 2282 TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE) 2283 { 2284 for (auto display : mDisplays) { 2285 std::vector<hwc2_config_t> configs; 2286 2287 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 2288 2289 for (auto config : configs) { 2290 int32_t value; 2291 2292 for (auto attribute : requiredAttributes) { 2293 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, 2294 attribute, &value)); 2295 EXPECT_GE(value, 0) << "missing required attribute " 2296 << getAttributeName(attribute) << " for config " 2297 << config; 2298 } 2299 for (auto attribute : optionalAttributes) { 2300 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, 2301 attribute, &value)); 2302 } 2303 } 2304 } 2305 } 2306 2307 /* TESTCASE: Tests that the HWC2 will return a value of -1 for an invalid 2308 * attribute */ 2309 TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_invalid_attribute) 2310 { 2311 const hwc2_attribute_t attribute = HWC2_ATTRIBUTE_INVALID; 2312 2313 for (auto display : mDisplays) { 2314 std::vector<hwc2_config_t> configs; 2315 2316 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 2317 2318 for (auto config : configs) { 2319 int32_t value; 2320 hwc2_error_t err = HWC2_ERROR_NONE; 2321 2322 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, 2323 attribute, &value, &err)); 2324 EXPECT_EQ(value, -1) << "failed to return -1 for an invalid" 2325 " attribute for config " << config; 2326 } 2327 } 2328 } 2329 2330 /* TESTCASE: Tests that the HWC2 will fail to get attributes for a bad display */ 2331 TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_bad_display) 2332 { 2333 hwc2_display_t display; 2334 const hwc2_config_t config = 0; 2335 int32_t value; 2336 hwc2_error_t err = HWC2_ERROR_NONE; 2337 2338 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 2339 2340 for (auto attribute : requiredAttributes) { 2341 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, attribute, 2342 &value, &err)); 2343 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2344 } 2345 2346 for (auto attribute : optionalAttributes) { 2347 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, attribute, 2348 &value, &err)); 2349 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2350 } 2351 } 2352 2353 /* TESTCASE: Tests that the HWC2 will fail to get attributes for a bad config */ 2354 TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_bad_config) 2355 { 2356 for (auto display : mDisplays) { 2357 hwc2_config_t config; 2358 int32_t value; 2359 hwc2_error_t err = HWC2_ERROR_NONE; 2360 2361 ASSERT_NO_FATAL_FAILURE(getInvalidConfig(display, &config)); 2362 2363 for (auto attribute : requiredAttributes) { 2364 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, 2365 attribute, &value, &err)); 2366 EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code"; 2367 } 2368 2369 for (auto attribute : optionalAttributes) { 2370 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, 2371 attribute, &value, &err)); 2372 EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code"; 2373 } 2374 } 2375 } 2376 2377 /* TESTCASE: Tests that the HWC2 will get display configs for active displays */ 2378 TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS) 2379 { 2380 for (auto display : mDisplays) { 2381 std::vector<hwc2_config_t> configs; 2382 2383 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 2384 } 2385 } 2386 2387 /* TESTCASE: Tests that the HWC2 will not get display configs for bad displays */ 2388 TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_bad_display) 2389 { 2390 hwc2_display_t display; 2391 std::vector<hwc2_config_t> configs; 2392 hwc2_error_t err = HWC2_ERROR_NONE; 2393 2394 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 2395 2396 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs, &err)); 2397 2398 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2399 EXPECT_TRUE(configs.empty()) << "returned configs for bad display"; 2400 } 2401 2402 /* TESTCASE: Tests that the HWC2 will return the same config list multiple 2403 * times in a row. */ 2404 TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_same) 2405 { 2406 for (auto display : mDisplays) { 2407 std::vector<hwc2_config_t> configs1, configs2; 2408 2409 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs1)); 2410 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs2)); 2411 2412 EXPECT_TRUE(std::is_permutation(configs1.begin(), configs1.end(), 2413 configs2.begin())) << "returned two different config sets"; 2414 } 2415 } 2416 2417 /* TESTCASE: Tests that the HWC2 does not return duplicate display configs */ 2418 TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_duplicate) 2419 { 2420 for (auto display : mDisplays) { 2421 std::vector<hwc2_config_t> configs; 2422 2423 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 2424 2425 std::unordered_set<hwc2_config_t> configsSet(configs.begin(), 2426 configs.end()); 2427 EXPECT_EQ(configs.size(), configsSet.size()) << "returned duplicate" 2428 " configs"; 2429 } 2430 } 2431 2432 /* TESTCASE: Tests that the HWC2 returns the active config for a display */ 2433 TEST_F(Hwc2Test, GET_ACTIVE_CONFIG) 2434 { 2435 for (auto display : mDisplays) { 2436 std::vector<hwc2_config_t> configs; 2437 2438 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 2439 2440 for (auto config : configs) { 2441 hwc2_config_t activeConfig; 2442 2443 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 2444 ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig)); 2445 2446 EXPECT_EQ(activeConfig, config) << "failed to get active config"; 2447 } 2448 } 2449 } 2450 2451 /* TESTCASE: Tests that the HWC2 does not return an active config for a bad 2452 * display. */ 2453 TEST_F(Hwc2Test, GET_ACTIVE_CONFIG_bad_display) 2454 { 2455 hwc2_display_t display; 2456 hwc2_config_t activeConfig; 2457 hwc2_error_t err = HWC2_ERROR_NONE; 2458 2459 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 2460 2461 ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig, &err)); 2462 2463 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2464 } 2465 2466 /* TESTCASE: Tests that the HWC2 either begins with a valid active config 2467 * or returns an error when getActiveConfig is called. */ 2468 TEST_F(Hwc2Test, GET_ACTIVE_CONFIG_bad_config) 2469 { 2470 for (auto display : mDisplays) { 2471 std::vector<hwc2_config_t> configs; 2472 hwc2_config_t activeConfig; 2473 hwc2_error_t err = HWC2_ERROR_NONE; 2474 2475 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 2476 2477 if (configs.empty()) 2478 return; 2479 2480 ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig, &err)); 2481 if (err == HWC2_ERROR_NONE) { 2482 EXPECT_NE(std::count(configs.begin(), configs.end(), 2483 activeConfig), 0) << "active config is not found in " 2484 " configs for display"; 2485 } else { 2486 EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code"; 2487 } 2488 } 2489 } 2490 2491 /* TESTCASE: Tests that the HWC2 can set every display config as an active 2492 * config */ 2493 TEST_F(Hwc2Test, SET_ACTIVE_CONFIG) 2494 { 2495 for (auto display : mDisplays) { 2496 std::vector<hwc2_config_t> configs; 2497 2498 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 2499 2500 for (auto config : configs) { 2501 EXPECT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 2502 } 2503 } 2504 } 2505 2506 /* TESTCASE: Tests that the HWC2 cannot set an active config for a bad display */ 2507 TEST_F(Hwc2Test, SET_ACTIVE_CONFIG_bad_display) 2508 { 2509 hwc2_display_t display; 2510 const hwc2_config_t config = 0; 2511 hwc2_error_t err = HWC2_ERROR_NONE; 2512 2513 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 2514 2515 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config, &err)); 2516 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2517 } 2518 2519 /* TESTCASE: Tests that the HWC2 cannot set an invalid active config */ 2520 TEST_F(Hwc2Test, SET_ACTIVE_CONFIG_bad_config) 2521 { 2522 for (auto display : mDisplays) { 2523 hwc2_config_t config; 2524 hwc2_error_t err = HWC2_ERROR_NONE; 2525 2526 ASSERT_NO_FATAL_FAILURE(getInvalidConfig(display, &config)); 2527 2528 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config, &err)); 2529 EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code"; 2530 } 2531 } 2532 2533 /* TESTCASE: Tests that the HWC2 returns a valid value for getDozeSupport. */ 2534 TEST_F(Hwc2Test, GET_DOZE_SUPPORT) 2535 { 2536 for (auto display : mDisplays) { 2537 int32_t support = -1; 2538 2539 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support)); 2540 2541 EXPECT_TRUE(support == 0 || support == 1) << "invalid doze support value"; 2542 } 2543 } 2544 2545 /* TESTCASE: Tests that the HWC2 cannot get doze support for a bad display. */ 2546 TEST_F(Hwc2Test, GET_DOZE_SUPPORT_bad_display) 2547 { 2548 hwc2_display_t display; 2549 int32_t support = -1; 2550 hwc2_error_t err = HWC2_ERROR_NONE; 2551 2552 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 2553 2554 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err)); 2555 2556 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2557 } 2558 2559 /* TESTCASE: Tests that the HWC2 can set all supported power modes */ 2560 TEST_F(Hwc2Test, SET_POWER_MODE) 2561 { 2562 for (auto display : mDisplays) { 2563 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 2564 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2565 2566 int32_t support = -1; 2567 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support)); 2568 if (support != 1) 2569 return; 2570 2571 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE)); 2572 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, 2573 HWC2_POWER_MODE_DOZE_SUSPEND)); 2574 2575 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2576 } 2577 } 2578 2579 /* TESTCASE: Tests that the HWC2 cannot set a power mode for a bad display. */ 2580 TEST_F(Hwc2Test, SET_POWER_MODE_bad_display) 2581 { 2582 hwc2_display_t display; 2583 hwc2_error_t err = HWC2_ERROR_NONE; 2584 2585 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 2586 2587 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON, &err)); 2588 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2589 2590 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF, &err)); 2591 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2592 2593 int32_t support = -1; 2594 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err)); 2595 if (support != 1) 2596 return; 2597 2598 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE, &err)); 2599 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2600 2601 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE_SUSPEND, 2602 &err)); 2603 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2604 } 2605 2606 /* TESTCASE: Tests that the HWC2 cannot set an invalid power mode value. */ 2607 TEST_F(Hwc2Test, SET_POWER_MODE_bad_parameter) 2608 { 2609 for (auto display : mDisplays) { 2610 hwc2_power_mode_t mode = static_cast<hwc2_power_mode_t>( 2611 HWC2_POWER_MODE_DOZE_SUSPEND + 1); 2612 hwc2_error_t err = HWC2_ERROR_NONE; 2613 2614 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, mode, &err)); 2615 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code " 2616 << mode; 2617 } 2618 } 2619 2620 /* TESTCASE: Tests that the HWC2 will return unsupported if it does not support 2621 * an optional power mode. */ 2622 TEST_F(Hwc2Test, SET_POWER_MODE_unsupported) 2623 { 2624 for (auto display : mDisplays) { 2625 int32_t support = -1; 2626 hwc2_error_t err = HWC2_ERROR_NONE; 2627 2628 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err)); 2629 if (support == 1) 2630 return; 2631 2632 ASSERT_EQ(support, 0) << "invalid doze support value"; 2633 2634 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE, 2635 &err)); 2636 EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code"; 2637 2638 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, 2639 HWC2_POWER_MODE_DOZE_SUSPEND, &err)); 2640 EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code"; 2641 } 2642 } 2643 2644 /* TESTCASE: Tests that the HWC2 can set the same power mode multiple times. */ 2645 TEST_F(Hwc2Test, SET_POWER_MODE_stress) 2646 { 2647 for (auto display : mDisplays) { 2648 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2649 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2650 2651 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 2652 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 2653 2654 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2655 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2656 2657 int32_t support = -1; 2658 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support)); 2659 if (support != 1) 2660 return; 2661 2662 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE)); 2663 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE)); 2664 2665 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, 2666 HWC2_POWER_MODE_DOZE_SUSPEND)); 2667 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, 2668 HWC2_POWER_MODE_DOZE_SUSPEND)); 2669 2670 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2671 } 2672 } 2673 2674 /* TESTCASE: Tests that the HWC2 can enable and disable vsync on active 2675 * displays */ 2676 TEST_F(Hwc2Test, SET_VSYNC_ENABLED) 2677 { 2678 for (auto display : mDisplays) { 2679 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( 2680 const_cast<char*>("data")); 2681 2682 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 2683 2684 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data, 2685 []() { return; })); 2686 2687 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); 2688 2689 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); 2690 2691 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2692 } 2693 } 2694 2695 /* TESTCASE: Tests that the HWC2 issues a valid vsync callback. */ 2696 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_callback) 2697 { 2698 for (auto display : mDisplays) { 2699 hwc2_display_t receivedDisplay; 2700 int64_t receivedTimestamp; 2701 2702 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 2703 2704 ASSERT_NO_FATAL_FAILURE(enableVsync(display)); 2705 2706 ASSERT_NO_FATAL_FAILURE(waitForVsync(&receivedDisplay, 2707 &receivedTimestamp)); 2708 2709 EXPECT_EQ(receivedDisplay, display) << "failed to get correct display"; 2710 EXPECT_GE(receivedTimestamp, 0) << "failed to get valid timestamp"; 2711 2712 ASSERT_NO_FATAL_FAILURE(disableVsync(display)); 2713 2714 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2715 } 2716 } 2717 2718 /* TESTCASE: Tests that the HWC2 cannot enable a vsync for a bad display */ 2719 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_bad_display) 2720 { 2721 hwc2_display_t display; 2722 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( 2723 const_cast<char*>("data")); 2724 hwc2_error_t err = HWC2_ERROR_NONE; 2725 2726 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 2727 2728 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data, 2729 []() { return; })); 2730 2731 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE, &err)); 2732 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2733 2734 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE, &err)); 2735 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2736 } 2737 2738 /* TESTCASE: Tests that the HWC2 cannot enable an invalid vsync value */ 2739 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_bad_parameter) 2740 { 2741 for (auto display : mDisplays) { 2742 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( 2743 const_cast<char*>("data")); 2744 hwc2_error_t err = HWC2_ERROR_NONE; 2745 2746 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 2747 2748 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data, 2749 []() { return; })); 2750 2751 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_INVALID, 2752 &err)); 2753 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code"; 2754 2755 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2756 } 2757 } 2758 2759 /* TESTCASE: Tests that the HWC2 can enable and disable a vsync value multiple 2760 * times. */ 2761 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_stress) 2762 { 2763 for (auto display : mDisplays) { 2764 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( 2765 const_cast<char*>("data")); 2766 2767 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 2768 2769 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data, 2770 []() { return; })); 2771 2772 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); 2773 2774 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); 2775 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); 2776 2777 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); 2778 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); 2779 2780 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2781 } 2782 } 2783 2784 /* TESTCASE: Tests that the HWC2 can set a vsync enable value when the display 2785 * is off and no callback is registered. */ 2786 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_no_callback_no_power) 2787 { 2788 const uint secs = 1; 2789 2790 for (auto display : mDisplays) { 2791 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); 2792 2793 sleep(secs); 2794 2795 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); 2796 } 2797 } 2798 2799 /* TESTCASE: Tests that the HWC2 can set a vsync enable value when no callback 2800 * is registered. */ 2801 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_no_callback) 2802 { 2803 const uint secs = 1; 2804 2805 for (auto display : mDisplays) { 2806 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 2807 2808 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); 2809 2810 sleep(secs); 2811 2812 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); 2813 2814 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 2815 } 2816 } 2817 2818 /* TESTCASE: Tests that the HWC2 returns a display name for each display */ 2819 TEST_F(Hwc2Test, GET_DISPLAY_NAME) 2820 { 2821 for (auto display : mDisplays) { 2822 std::string name; 2823 2824 ASSERT_NO_FATAL_FAILURE(getDisplayName(display, &name)); 2825 } 2826 } 2827 2828 /* TESTCASE: Tests that the HWC2 does not return a display name for a bad 2829 * display */ 2830 TEST_F(Hwc2Test, GET_DISPLAY_NAME_bad_display) 2831 { 2832 hwc2_display_t display; 2833 std::string name; 2834 hwc2_error_t err = HWC2_ERROR_NONE; 2835 2836 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 2837 2838 ASSERT_NO_FATAL_FAILURE(getDisplayName(display, &name, &err)); 2839 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2840 } 2841 2842 /* TESTCASE: Tests that the HWC2 can set basic composition types. */ 2843 TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE) 2844 { 2845 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 2846 setComposition, advanceComposition)); 2847 } 2848 2849 /* TESTCASE: Tests that the HWC2 can update a basic composition type on a 2850 * layer. */ 2851 TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_update) 2852 { 2853 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, 2854 setComposition, advanceComposition)); 2855 } 2856 2857 /* TESTCASE: Tests that the HWC2 cannot set a composition type for a bad layer */ 2858 TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_bad_layer) 2859 { 2860 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 2861 setComposition)); 2862 } 2863 2864 /* TESTCASE: Tests that the HWC2 cannot set a bad composition type */ 2865 TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_bad_parameter) 2866 { 2867 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter( 2868 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 2869 hwc2_error_t* outErr) { 2870 2871 ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, 2872 layer, HWC2_COMPOSITION_INVALID, outErr)); 2873 } 2874 )); 2875 } 2876 2877 /* TESTCASE: Tests that the HWC2 can set the cursor position of a layer. */ 2878 TEST_F(Hwc2Test, SET_CURSOR_POSITION) 2879 { 2880 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 2881 ::setCursorPosition, advanceCursorPosition)); 2882 } 2883 2884 /* TESTCASE: Tests that the HWC2 can update the cursor position of a layer. */ 2885 TEST_F(Hwc2Test, SET_CURSOR_POSITION_update) 2886 { 2887 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, 2888 ::setCursorPosition, advanceCursorPosition)); 2889 } 2890 2891 /* TESTCASE: Tests that the HWC2 can set the cursor position of a layer when the 2892 * composition type has not been set to HWC2_COMPOSITION_CURSOR. */ 2893 TEST_F(Hwc2Test, SET_CURSOR_POSITION_composition_type_unset) 2894 { 2895 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 2896 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 2897 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) { 2898 2899 const hwc_rect_t cursorPosition = testLayer->getCursorPosition(); 2900 EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, layer, 2901 cursorPosition.left, cursorPosition.top, outErr)); 2902 }, 2903 2904 advanceCursorPosition)); 2905 } 2906 2907 /* TESTCASE: Tests that the HWC2 cannot set the cursor position of a bad 2908 * display. */ 2909 TEST_F(Hwc2Test, SET_CURSOR_POSITION_bad_display) 2910 { 2911 hwc2_display_t display; 2912 hwc2_layer_t layer = 0; 2913 int32_t x = 0, y = 0; 2914 hwc2_error_t err = HWC2_ERROR_NONE; 2915 2916 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 2917 2918 ASSERT_NO_FATAL_FAILURE(setCursorPosition(display, layer, x, y, &err)); 2919 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 2920 } 2921 2922 /* TESTCASE: Tests that the HWC2 cannot set the cursor position of a bad layer. */ 2923 TEST_F(Hwc2Test, SET_CURSOR_POSITION_bad_layer) 2924 { 2925 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 2926 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer, 2927 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) { 2928 2929 const hwc_rect_t cursorPosition = testLayer->getCursorPosition(); 2930 EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, 2931 badLayer, cursorPosition.left, cursorPosition.top, 2932 outErr)); 2933 } 2934 )); 2935 } 2936 2937 /* TESTCASE: Tests that the HWC2 can set a blend mode value of a layer. */ 2938 TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE) 2939 { 2940 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 2941 setBlendMode, advanceBlendMode)); 2942 } 2943 2944 /* TESTCASE: Tests that the HWC2 can update a blend mode value of a layer. */ 2945 TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_update) 2946 { 2947 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, 2948 setBlendMode, advanceBlendMode)); 2949 } 2950 2951 /* TESTCASE: Tests that the HWC2 cannot set a blend mode for a bad layer. */ 2952 TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_layer) 2953 { 2954 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 2955 setBlendMode)); 2956 } 2957 2958 /* TESTCASE: Tests that the HWC2 cannot set an invalid blend mode. */ 2959 TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_parameter) 2960 { 2961 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter( 2962 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 2963 hwc2_error_t* outErr) { 2964 2965 ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, 2966 layer, HWC2_BLEND_MODE_INVALID, outErr)); 2967 } 2968 )); 2969 } 2970 2971 /* TESTCASE: Tests that the HWC2 can set the buffer of a layer. */ 2972 TEST_F(Hwc2Test, SET_LAYER_BUFFER) 2973 { 2974 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 2975 setBuffer, advanceBuffer)); 2976 } 2977 2978 /* TESTCASE: Tests that the HWC2 can update the buffer of a layer. */ 2979 TEST_F(Hwc2Test, SET_LAYER_BUFFER_update) 2980 { 2981 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, 2982 setBuffer, advanceBuffer)); 2983 } 2984 2985 /* TESTCASE: Tests that the HWC2 cannot set the buffer of a bad layer. */ 2986 TEST_F(Hwc2Test, SET_LAYER_BUFFER_bad_layer) 2987 { 2988 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 2989 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer, 2990 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) { 2991 2992 buffer_handle_t handle = nullptr; 2993 android::base::unique_fd acquireFence; 2994 2995 /* If there is not available buffer for the given buffer 2996 * properties, it should not fail this test case */ 2997 if (testLayer->getBuffer(&handle, &acquireFence) == 0) { 2998 *outErr = HWC2_ERROR_BAD_LAYER; 2999 return; 3000 } 3001 3002 ASSERT_NO_FATAL_FAILURE(test->setLayerBuffer(display, badLayer, 3003 handle, acquireFence, outErr)); 3004 } 3005 )); 3006 } 3007 3008 /* TESTCASE: Tests that the HWC2 can set an invalid buffer for a layer. */ 3009 TEST_F(Hwc2Test, SET_LAYER_BUFFER_bad_parameter) 3010 { 3011 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter( 3012 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 3013 hwc2_error_t* outErr) { 3014 3015 buffer_handle_t handle = nullptr; 3016 int32_t acquireFence = -1; 3017 3018 ASSERT_NO_FATAL_FAILURE(test->setLayerBuffer(display, layer, 3019 handle, acquireFence, outErr)); 3020 } 3021 )); 3022 } 3023 3024 /* TESTCASE: Tests that the HWC2 can set the color of a layer. */ 3025 TEST_F(Hwc2Test, SET_LAYER_COLOR) 3026 { 3027 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 3028 setColor, advanceColor)); 3029 } 3030 3031 /* TESTCASE: Tests that the HWC2 can update the color of a layer. */ 3032 TEST_F(Hwc2Test, SET_LAYER_COLOR_update) 3033 { 3034 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, 3035 setColor, advanceColor)); 3036 } 3037 3038 /* TESTCASE: Tests that the HWC2 can set the color of a layer when the 3039 * composition type has not been set to HWC2_COMPOSITION_SOLID_COLOR. */ 3040 TEST_F(Hwc2Test, SET_LAYER_COLOR_composition_type_unset) 3041 { 3042 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Basic, 3043 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 3044 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) { 3045 3046 EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer, 3047 testLayer->getColor(), outErr)); 3048 }, 3049 3050 advanceColor)); 3051 } 3052 3053 /* TESTCASE: Tests that the HWC2 cannot set the color of a bad layer. */ 3054 TEST_F(Hwc2Test, SET_LAYER_COLOR_bad_layer) 3055 { 3056 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 3057 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer, 3058 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) { 3059 3060 EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, badLayer, 3061 testLayer->getColor(), outErr)); 3062 } 3063 )); 3064 } 3065 3066 /* TESTCASE: Tests that the HWC2 can set the dataspace of a layer. */ 3067 TEST_F(Hwc2Test, SET_LAYER_DATASPACE) 3068 { 3069 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 3070 setDataspace, advanceDataspace)); 3071 } 3072 3073 /* TESTCASE: Tests that the HWC2 can update the dataspace of a layer. */ 3074 TEST_F(Hwc2Test, SET_LAYER_DATASPACE_update) 3075 { 3076 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, 3077 setDataspace, advanceDataspace)); 3078 } 3079 3080 /* TESTCASE: Tests that the HWC2 cannot set a dataspace for a bad layer. */ 3081 TEST_F(Hwc2Test, SET_LAYER_DATASPACE_bad_layer) 3082 { 3083 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 3084 setDataspace)); 3085 } 3086 3087 /* TESTCASE: Tests that the HWC2 can set the display frame of a layer. */ 3088 TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME) 3089 { 3090 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 3091 setDisplayFrame, advanceDisplayFrame)); 3092 } 3093 3094 /* TESTCASE: Tests that the HWC2 can update the display frame of a layer. */ 3095 TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME_update) 3096 { 3097 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, 3098 setDisplayFrame, advanceDisplayFrame)); 3099 } 3100 3101 /* TESTCASE: Tests that the HWC2 cannot set the display frame of a bad layer. */ 3102 TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME_bad_layer) 3103 { 3104 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 3105 setDisplayFrame)); 3106 } 3107 3108 /* TESTCASE: Tests that the HWC2 can set the plane alpha of a layer. */ 3109 TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA) 3110 { 3111 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 3112 setPlaneAlpha, advancePlaneAlpha)); 3113 } 3114 3115 /* TESTCASE: Tests that the HWC2 can update the plane alpha of a layer. */ 3116 TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA_update) 3117 { 3118 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, 3119 setPlaneAlpha, advancePlaneAlpha)); 3120 } 3121 3122 /* TESTCASE: Tests that the HWC2 cannot set a plane alpha for a bad layer. */ 3123 TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA_bad_layer) 3124 { 3125 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 3126 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer, 3127 Hwc2TestLayer* testLayer, hwc2_error_t *outErr) { 3128 3129 EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display, 3130 badLayer, testLayer->getPlaneAlpha(), outErr)); 3131 } 3132 )); 3133 } 3134 3135 /* TESTCASE: Tests that the HWC2 can set the source crop of a layer. */ 3136 TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP) 3137 { 3138 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 3139 setSourceCrop, advanceSourceCrop)); 3140 } 3141 3142 /* TESTCASE: Tests that the HWC2 can update the source crop of a layer. */ 3143 TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP_update) 3144 { 3145 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, 3146 setSourceCrop, advanceSourceCrop)); 3147 } 3148 3149 /* TESTCASE: Tests that the HWC2 cannot set the source crop of a bad layer. */ 3150 TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP_bad_layer) 3151 { 3152 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 3153 setSourceCrop)); 3154 } 3155 3156 /* TESTCASE: Tests that the HWC2 can set the surface damage of a layer. */ 3157 TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE) 3158 { 3159 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 3160 setSurfaceDamage, advanceSurfaceDamage)); 3161 } 3162 3163 /* TESTCASE: Tests that the HWC2 can update the surface damage of a layer. */ 3164 TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE_update) 3165 { 3166 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, 3167 setSurfaceDamage, advanceSurfaceDamage)); 3168 } 3169 3170 /* TESTCASE: Tests that the HWC2 cannot set the surface damage of a bad layer. */ 3171 TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE_bad_layer) 3172 { 3173 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 3174 setSurfaceDamage)); 3175 } 3176 3177 /* TESTCASE: Tests that the HWC2 can set the transform value of a layer. */ 3178 TEST_F(Hwc2Test, SET_LAYER_TRANSFORM) 3179 { 3180 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, 3181 setTransform, advanceTransform)); 3182 } 3183 3184 /* TESTCASE: Tests that the HWC2 can update the transform value of a layer. */ 3185 TEST_F(Hwc2Test, SET_LAYER_TRANSFORM_update) 3186 { 3187 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, 3188 setTransform, advanceTransform)); 3189 } 3190 3191 /* TESTCASE: Tests that the HWC2 cannot set the transform for a bad layer. */ 3192 TEST_F(Hwc2Test, SET_LAYER_TRANSFORM_bad_layer) 3193 { 3194 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 3195 setTransform)); 3196 } 3197 3198 /* TESTCASE: Tests that the HWC2 can set the visible region of a layer. */ 3199 TEST_F(Hwc2Test, SET_LAYER_VISIBLE_REGION) 3200 { 3201 ASSERT_NO_FATAL_FAILURE(setLayerProperties(Hwc2TestCoverage::Basic, 5, 3202 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 3203 Hwc2TestLayers* testLayers) { 3204 3205 EXPECT_NO_FATAL_FAILURE(test->setLayerVisibleRegion(display, 3206 layer, testLayers->getVisibleRegion(layer))); 3207 }, 3208 3209 advanceVisibleRegions)); 3210 } 3211 3212 /* TESTCASE: Tests that the HWC2 cannot set the visible region of a bad layer. */ 3213 TEST_F(Hwc2Test, SET_LAYER_VISIBLE_REGION_bad_layer) 3214 { 3215 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 3216 setVisibleRegion)); 3217 } 3218 3219 /* TESTCASE: Tests that the HWC2 can set the z order of a layer. */ 3220 TEST_F(Hwc2Test, SET_LAYER_Z_ORDER) 3221 { 3222 ASSERT_NO_FATAL_FAILURE(setLayerProperties(Hwc2TestCoverage::Complete, 10, 3223 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 3224 Hwc2TestLayers* testLayers) { 3225 3226 EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer, 3227 testLayers->getZOrder(layer))); 3228 }, 3229 3230 /* TestLayer z orders are set during the construction of TestLayers 3231 * and cannot be updated. There is no need (or ability) to cycle 3232 * through additional z order configurations. */ 3233 [] (Hwc2TestLayers* /*testLayers*/) { 3234 return false; 3235 } 3236 )); 3237 } 3238 3239 /* TESTCASE: Tests that the HWC2 can update the z order of a layer. */ 3240 TEST_F(Hwc2Test, SET_LAYER_Z_ORDER_update) 3241 { 3242 const std::vector<uint32_t> zOrders = { static_cast<uint32_t>(0), 3243 static_cast<uint32_t>(1), static_cast<uint32_t>(UINT32_MAX / 4), 3244 static_cast<uint32_t>(UINT32_MAX / 2), 3245 static_cast<uint32_t>(UINT32_MAX) }; 3246 3247 for (auto display : mDisplays) { 3248 std::vector<hwc2_config_t> configs; 3249 3250 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 3251 3252 for (auto config : configs) { 3253 hwc2_layer_t layer; 3254 3255 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 3256 3257 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); 3258 3259 for (uint32_t zOrder : zOrders) { 3260 EXPECT_NO_FATAL_FAILURE(setLayerZOrder(display, layer, zOrder)); 3261 } 3262 3263 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); 3264 } 3265 } 3266 } 3267 3268 /* TESTCASE: Tests that the HWC2 cannot set the z order of a bad layer. */ 3269 TEST_F(Hwc2Test, SET_LAYER_Z_ORDER_bad_layer) 3270 { 3271 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, 3272 setZOrder)); 3273 } 3274 3275 /* TESTCASE: Tests that the HWC2 can display a layer with basic property 3276 * coverage */ 3277 TEST_F(Hwc2Test, VALIDATE_DISPLAY_basic) 3278 { 3279 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1, 3280 [] (Hwc2Test* test, hwc2_display_t display, 3281 const std::vector<hwc2_layer_t>& layers, 3282 Hwc2TestLayers* /*testLayers*/) { 3283 3284 uint32_t numTypes, numRequests; 3285 bool hasChanges = false; 3286 3287 EXPECT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes, 3288 &numRequests, &hasChanges)); 3289 if (hasChanges) 3290 EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size())) 3291 << "wrong number of requests"; 3292 } 3293 )); 3294 } 3295 3296 /* TESTCASE: Tests that the HWC2 can display 5 layers with default coverage. */ 3297 TEST_F(Hwc2Test, VALIDATE_DISPLAY_default_5) 3298 { 3299 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Default, 5, 3300 [] (Hwc2Test* test, hwc2_display_t display, 3301 const std::vector<hwc2_layer_t>& layers, 3302 Hwc2TestLayers* /*testLayers*/) { 3303 3304 uint32_t numTypes, numRequests; 3305 bool hasChanges = false; 3306 3307 EXPECT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes, 3308 &numRequests, &hasChanges)); 3309 if (hasChanges) 3310 EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size())) 3311 << "wrong number of requests"; 3312 } 3313 )); 3314 } 3315 3316 /* TESTCASE: Tests that the HWC2 cannot validate a bad display */ 3317 TEST_F(Hwc2Test, VALIDATE_DISPLAY_bad_display) 3318 { 3319 hwc2_display_t display; 3320 uint32_t numTypes, numRequests; 3321 hwc2_error_t err = HWC2_ERROR_NONE; 3322 3323 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 3324 3325 ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes, &numRequests, 3326 &err)); 3327 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 3328 } 3329 3330 /* TESTCASE: Tests that the HWC2 can get display requests after validating a 3331 * basic layer. */ 3332 TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_basic) 3333 { 3334 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1, 3335 [] (Hwc2Test* test, hwc2_display_t display, 3336 const std::vector<hwc2_layer_t>& layers, 3337 Hwc2TestLayers* /*testLayers*/) { 3338 3339 uint32_t numTypes, numRequests; 3340 bool hasChanges = false; 3341 3342 ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes, 3343 &numRequests, &hasChanges)); 3344 if (hasChanges) 3345 EXPECT_LE(numTypes, layers.size()) 3346 << "wrong number of requests"; 3347 3348 EXPECT_NO_FATAL_FAILURE(test->handleRequests(display, layers, 3349 numRequests)); 3350 } 3351 )); 3352 } 3353 3354 /* TESTCASE: Tests that the HWC2 cannot get display requests from a bad display */ 3355 TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_bad_display) 3356 { 3357 hwc2_display_t display; 3358 hwc2_display_request_t displayRequests; 3359 std::vector<hwc2_layer_t> layers; 3360 std::vector<hwc2_layer_request_t> layerRequests; 3361 hwc2_error_t err = HWC2_ERROR_NONE; 3362 3363 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 3364 3365 EXPECT_NO_FATAL_FAILURE(getDisplayRequests(display, &displayRequests, 3366 &layers, &layerRequests, &err)); 3367 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 3368 } 3369 3370 /* TESTCASE: Tests that the HWC2 cannot get display requests from an non 3371 * validated display. */ 3372 TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_not_validated) 3373 { 3374 ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5, 3375 [] (Hwc2Test* test, hwc2_display_t display, 3376 std::vector<hwc2_layer_t>* layers) { 3377 3378 hwc2_display_request_t displayRequests; 3379 std::vector<hwc2_layer_request_t> layerRequests; 3380 hwc2_error_t err = HWC2_ERROR_NONE; 3381 3382 ASSERT_NO_FATAL_FAILURE(test->getDisplayRequests(display, 3383 &displayRequests, layers, &layerRequests, &err)); 3384 EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED) 3385 << "returned wrong error code"; 3386 } 3387 )); 3388 } 3389 3390 /* TESTCASE: Tests that the HWC2 can get changed composition types after 3391 * validating a basic layer. */ 3392 TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_basic) 3393 { 3394 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1, 3395 [] (Hwc2Test* test, hwc2_display_t display, 3396 const std::vector<hwc2_layer_t>& layers, 3397 Hwc2TestLayers* testLayers) { 3398 3399 uint32_t numTypes, numRequests; 3400 bool hasChanges = false; 3401 3402 ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes, 3403 &numRequests, &hasChanges)); 3404 if (hasChanges) 3405 EXPECT_LE(numTypes, layers.size()) 3406 << "wrong number of requests"; 3407 3408 EXPECT_NO_FATAL_FAILURE(test->handleCompositionChanges(display, 3409 *testLayers, layers, numTypes)); 3410 } 3411 )); 3412 } 3413 3414 /* TESTCASE: Tests that the HWC2 cannot get changed composition types from a bad 3415 * display */ 3416 TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_bad_display) 3417 { 3418 hwc2_display_t display; 3419 std::vector<hwc2_layer_t> layers; 3420 std::vector<hwc2_composition_t> types; 3421 hwc2_error_t err = HWC2_ERROR_NONE; 3422 3423 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 3424 3425 EXPECT_NO_FATAL_FAILURE(getChangedCompositionTypes(display, &layers, 3426 &types, &err)); 3427 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 3428 } 3429 3430 /* TESTCASE: Tests that the HWC2 cannot get changed composition types from an non 3431 * validated display. */ 3432 TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_not_validated) 3433 { 3434 ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5, 3435 [] (Hwc2Test* test, hwc2_display_t display, 3436 std::vector<hwc2_layer_t>* layers) { 3437 3438 std::vector<hwc2_composition_t> types; 3439 hwc2_error_t err = HWC2_ERROR_NONE; 3440 3441 ASSERT_NO_FATAL_FAILURE(test->getChangedCompositionTypes( 3442 display, layers, &types, &err)); 3443 EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED) 3444 << "returned wrong error code"; 3445 } 3446 )); 3447 } 3448 3449 /* TESTCASE: Tests that the HWC2 can accept display changes after validating a 3450 * basic layer. */ 3451 TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_basic) 3452 { 3453 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1, 3454 [] (Hwc2Test* test, hwc2_display_t display, 3455 const std::vector<hwc2_layer_t>& layers, 3456 Hwc2TestLayers* testLayers) { 3457 3458 uint32_t numTypes, numRequests; 3459 bool hasChanges = false; 3460 3461 ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes, 3462 &numRequests, &hasChanges)); 3463 if (hasChanges) 3464 EXPECT_LE(numTypes, layers.size()) 3465 << "wrong number of requests"; 3466 3467 ASSERT_NO_FATAL_FAILURE(test->handleCompositionChanges(display, 3468 *testLayers, layers, numTypes)); 3469 3470 EXPECT_NO_FATAL_FAILURE(test->acceptDisplayChanges(display)); 3471 } 3472 )); 3473 } 3474 3475 /* TESTCASE: Tests that the HWC2 cannot accept display changes from a bad 3476 * display */ 3477 TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_bad_display) 3478 { 3479 hwc2_display_t display; 3480 hwc2_error_t err = HWC2_ERROR_NONE; 3481 3482 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 3483 3484 EXPECT_NO_FATAL_FAILURE(acceptDisplayChanges(display, &err)); 3485 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 3486 } 3487 3488 /* TESTCASE: Tests that the HWC2 cannot accept display changes from an non 3489 * validated display. */ 3490 TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_not_validated) 3491 { 3492 ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5, 3493 [] (Hwc2Test* test, hwc2_display_t display, 3494 std::vector<hwc2_layer_t>* /*layers*/) { 3495 3496 hwc2_error_t err = HWC2_ERROR_NONE; 3497 3498 ASSERT_NO_FATAL_FAILURE(test->acceptDisplayChanges(display, &err)); 3499 EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED) 3500 << "returned wrong error code"; 3501 } 3502 )); 3503 } 3504 3505 /* TESTCASE: Tests that the HWC2 supports client target with required values */ 3506 TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT) 3507 { 3508 ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Default, 3509 [] (Hwc2Test* test, hwc2_display_t display, 3510 const Hwc2TestClientTargetSupport& testClientTargetSupport) { 3511 3512 const Area bufferArea = testClientTargetSupport.getBufferArea(); 3513 const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888; 3514 3515 ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(display, 3516 bufferArea.width, bufferArea.height, format, 3517 testClientTargetSupport.getDataspace())); 3518 }, 3519 3520 advanceClientTargetSupport)); 3521 } 3522 3523 /* TESTCASE: Tests that the HWC2 cannot get client target support for a bad 3524 * display. */ 3525 TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT_bad_display) 3526 { 3527 ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Default, 3528 [] (Hwc2Test* test, hwc2_display_t /*display*/, 3529 const Hwc2TestClientTargetSupport& testClientTargetSupport) { 3530 3531 const Area bufferArea = testClientTargetSupport.getBufferArea(); 3532 const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888; 3533 hwc2_display_t badDisplay; 3534 hwc2_error_t err = HWC2_ERROR_NONE; 3535 3536 ASSERT_NO_FATAL_FAILURE(test->getBadDisplay(&badDisplay)); 3537 3538 ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(badDisplay, 3539 bufferArea.width, bufferArea.height, format, 3540 testClientTargetSupport.getDataspace(), &err)); 3541 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 3542 }, 3543 3544 advanceClientTargetSupport)); 3545 } 3546 3547 /* TESTCASE: Tests that the HWC2 either supports or returns error unsupported 3548 * for a variety of client target values. */ 3549 TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT_unsupported) 3550 { 3551 ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Complete, 3552 [] (Hwc2Test* test, hwc2_display_t display, 3553 const Hwc2TestClientTargetSupport& testClientTargetSupport) { 3554 3555 const Area bufferArea = testClientTargetSupport.getBufferArea(); 3556 const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888; 3557 hwc2_error_t err = HWC2_ERROR_NONE; 3558 3559 ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(display, 3560 bufferArea.width, bufferArea.height, format, 3561 testClientTargetSupport.getDataspace(), &err)); 3562 EXPECT_TRUE(err == HWC2_ERROR_NONE 3563 || err == HWC2_ERROR_UNSUPPORTED) 3564 << "returned wrong error code"; 3565 }, 3566 3567 advanceClientTargetSupport)); 3568 } 3569 3570 /* TESTCASE: Tests that the HWC2 can set a client target buffer for a basic 3571 * layer. */ 3572 TEST_F(Hwc2Test, SET_CLIENT_TARGET_basic) 3573 { 3574 const android_dataspace_t dataspace = HAL_DATASPACE_UNKNOWN; 3575 const hwc_region_t damage = { }; 3576 const size_t layerCnt = 1; 3577 3578 for (auto display : mDisplays) { 3579 std::vector<hwc2_config_t> configs; 3580 3581 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); 3582 3583 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); 3584 3585 for (auto config : configs) { 3586 Area displayArea; 3587 std::vector<hwc2_layer_t> layers; 3588 3589 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); 3590 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, &displayArea)); 3591 3592 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); 3593 Hwc2TestLayers testLayers(layers, Hwc2TestCoverage::Basic, 3594 displayArea); 3595 3596 if (!testLayers.optimizeLayouts()) 3597 continue; 3598 3599 Hwc2TestClientTarget testClientTarget; 3600 3601 do { 3602 std::set<hwc2_layer_t> clientLayers; 3603 std::set<hwc2_layer_t> clearLayers; 3604 uint32_t numTypes, numRequests; 3605 bool hasChanges, skip; 3606 bool flipClientTarget; 3607 buffer_handle_t handle; 3608 int32_t acquireFence; 3609 3610 ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers, 3611 &testLayers, &skip)); 3612 if (skip) 3613 continue; 3614 3615 ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes, 3616 &numRequests, &hasChanges)); 3617 if (hasChanges) 3618 EXPECT_LE(numTypes, layers.size()) 3619 << "wrong number of requests"; 3620 3621 ASSERT_NO_FATAL_FAILURE(handleCompositionChanges(display, 3622 testLayers, layers, numTypes, &clientLayers)); 3623 ASSERT_NO_FATAL_FAILURE(handleRequests(display, layers, 3624 numRequests, &clearLayers, &flipClientTarget)); 3625 ASSERT_EQ(testClientTarget.getBuffer(testLayers, clientLayers, 3626 clearLayers, flipClientTarget, displayArea, &handle, 3627 &acquireFence), 0); 3628 EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle, 3629 acquireFence, dataspace, damage)); 3630 3631 if (acquireFence >= 0) 3632 close(acquireFence); 3633 3634 } while (testLayers.advance()); 3635 3636 ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers))); 3637 } 3638 3639 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); 3640 } 3641 } 3642 3643 /* TESTCASE: Tests that the HWC2 cannot set a client target for a bad display. */ 3644 TEST_F(Hwc2Test, SET_CLIENT_TARGET_bad_display) 3645 { 3646 hwc2_display_t display; 3647 std::vector<hwc2_layer_t> layers; 3648 const Area displayArea = {0, 0}; 3649 Hwc2TestLayers testLayers(layers, Hwc2TestCoverage::Default, displayArea); 3650 std::set<hwc2_layer_t> clientLayers; 3651 std::set<hwc2_layer_t> flipClientTargetLayers; 3652 bool flipClientTarget = true; 3653 const android_dataspace_t dataspace = HAL_DATASPACE_UNKNOWN; 3654 const hwc_region_t damage = { }; 3655 buffer_handle_t handle; 3656 int32_t acquireFence; 3657 hwc2_error_t err = HWC2_ERROR_NONE; 3658 3659 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 3660 3661 Hwc2TestClientTarget testClientTarget; 3662 3663 ASSERT_EQ(testClientTarget.getBuffer(testLayers, clientLayers, 3664 flipClientTargetLayers, flipClientTarget, displayArea, &handle, 3665 &acquireFence), 0); 3666 3667 EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle, acquireFence, 3668 dataspace, damage, &err)); 3669 3670 if (acquireFence >= 0) 3671 close(acquireFence); 3672 3673 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 3674 } 3675 3676 /* TESTCASE: Tests that the HWC2 can present 1 default layer. */ 3677 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_1) 3678 { 3679 const size_t layerCnt = 1; 3680 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3681 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; 3682 bool optimize = false; 3683 3684 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3685 optimize)); 3686 } 3687 3688 /* TESTCASE: Tests that the HWC2 can present 2 default layers. */ 3689 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_2) 3690 { 3691 const size_t layerCnt = 2; 3692 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3693 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; 3694 bool optimize = false; 3695 3696 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3697 optimize)); 3698 } 3699 3700 /* TESTCASE: Tests that the HWC2 can present 3 default layers. */ 3701 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_3) 3702 { 3703 const size_t layerCnt = 3; 3704 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3705 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; 3706 bool optimize = false; 3707 3708 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3709 optimize)); 3710 } 3711 3712 /* TESTCASE: Tests that the HWC2 can present 4 default layers. */ 3713 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_4) 3714 { 3715 const size_t layerCnt = 4; 3716 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3717 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; 3718 bool optimize = false; 3719 3720 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3721 optimize)); 3722 } 3723 3724 /* TESTCASE: Tests that the HWC2 can present 5 default layers. */ 3725 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_5) 3726 { 3727 const size_t layerCnt = 5; 3728 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3729 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; 3730 bool optimize = false; 3731 3732 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3733 optimize)); 3734 } 3735 3736 /* TESTCASE: Tests that the HWC2 can present 6 default layers. */ 3737 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_6) 3738 { 3739 const size_t layerCnt = 6; 3740 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3741 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; 3742 bool optimize = false; 3743 3744 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3745 optimize)); 3746 } 3747 3748 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 3749 * blend mode. */ 3750 TEST_F(Hwc2Test, PRESENT_DISPLAY_blend_mode_1) 3751 { 3752 const size_t layerCnt = 1; 3753 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3754 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3755 {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Complete}, 3756 {Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Basic}, 3757 {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic}}; 3758 bool optimize = false; 3759 3760 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3761 optimize)); 3762 } 3763 3764 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of 3765 * blend mode. */ 3766 TEST_F(Hwc2Test, PRESENT_DISPLAY_blend_mode_2) 3767 { 3768 const size_t layerCnt = 2; 3769 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3770 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3771 {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Complete}, 3772 {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic}}; 3773 bool optimize = false; 3774 3775 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3776 optimize)); 3777 } 3778 3779 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 3780 * buffer. */ 3781 TEST_F(Hwc2Test, PRESENT_DISPLAY_buffer_1) 3782 { 3783 const size_t layerCnt = 1; 3784 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3785 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3786 {{Hwc2TestPropertyName::BufferArea, Hwc2TestCoverage::Complete}}; 3787 bool optimize = true; 3788 3789 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3790 optimize)); 3791 } 3792 3793 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 3794 * color. */ 3795 TEST_F(Hwc2Test, PRESENT_DISPLAY_color_1) 3796 { 3797 const size_t layerCnt = 1; 3798 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3799 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3800 {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}, 3801 {Hwc2TestPropertyName::Color, Hwc2TestCoverage::Complete}}; 3802 bool optimize = true; 3803 3804 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3805 optimize)); 3806 } 3807 3808 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of 3809 * color. */ 3810 TEST_F(Hwc2Test, PRESENT_DISPLAY_color_2) 3811 { 3812 const size_t layerCnt = 2; 3813 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3814 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3815 {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}, 3816 {Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic}, 3817 {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic}, 3818 {Hwc2TestPropertyName::Color, Hwc2TestCoverage::Basic}}; 3819 bool optimize = true; 3820 3821 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3822 optimize)); 3823 } 3824 3825 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 3826 * composition. */ 3827 TEST_F(Hwc2Test, PRESENT_DISPLAY_composition_1) 3828 { 3829 const size_t layerCnt = 1; 3830 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3831 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3832 {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}}; 3833 bool optimize = true; 3834 3835 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3836 optimize)); 3837 } 3838 3839 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 3840 * cursor. */ 3841 TEST_F(Hwc2Test, PRESENT_DISPLAY_cursor_1) 3842 { 3843 const size_t layerCnt = 1; 3844 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3845 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3846 {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}, 3847 {Hwc2TestPropertyName::CursorPosition, Hwc2TestCoverage::Complete}}; 3848 bool optimize = true; 3849 3850 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3851 optimize)); 3852 } 3853 3854 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of 3855 * cursor. */ 3856 TEST_F(Hwc2Test, PRESENT_DISPLAY_cursor_2) 3857 { 3858 const size_t layerCnt = 2; 3859 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3860 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3861 {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}, 3862 {Hwc2TestPropertyName::CursorPosition, Hwc2TestCoverage::Complete}, 3863 {Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Basic}}; 3864 bool optimize = true; 3865 3866 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3867 optimize)); 3868 } 3869 3870 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 3871 * dataspace. */ 3872 TEST_F(Hwc2Test, PRESENT_DISPLAY_dataspace_1) 3873 { 3874 const size_t layerCnt = 1; 3875 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3876 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3877 {{Hwc2TestPropertyName::Dataspace, Hwc2TestCoverage::Complete}}; 3878 bool optimize = true; 3879 3880 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3881 optimize)); 3882 } 3883 3884 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 3885 * display frame. */ 3886 TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_1) 3887 { 3888 const size_t layerCnt = 1; 3889 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3890 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3891 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}}; 3892 bool optimize = true; 3893 3894 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3895 optimize)); 3896 } 3897 3898 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of 3899 * display frame. */ 3900 TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_2) 3901 { 3902 const size_t layerCnt = 2; 3903 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3904 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3905 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}}; 3906 bool optimize = true; 3907 3908 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3909 optimize)); 3910 } 3911 3912 /* TESTCASE: Tests that the HWC2 can present 3 layers with complete coverage of 3913 * display frame. */ 3914 TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_3) 3915 { 3916 const size_t layerCnt = 3; 3917 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3918 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3919 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}}; 3920 bool optimize = true; 3921 3922 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3923 optimize)); 3924 } 3925 3926 /* TESTCASE: Tests that the HWC2 can present 4 layers with complete coverage of 3927 * display frame. */ 3928 TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_4) 3929 { 3930 const size_t layerCnt = 4; 3931 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3932 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3933 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}}; 3934 bool optimize = true; 3935 3936 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3937 optimize)); 3938 } 3939 3940 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 3941 * plane alpha. */ 3942 TEST_F(Hwc2Test, PRESENT_DISPLAY_plane_alpha_1) 3943 { 3944 const size_t layerCnt = 1; 3945 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3946 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3947 {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic}, 3948 {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Complete}}; 3949 bool optimize = false; 3950 3951 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3952 optimize)); 3953 } 3954 3955 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of 3956 * plane alpha. */ 3957 TEST_F(Hwc2Test, PRESENT_DISPLAY_plane_alpha_2) 3958 { 3959 const size_t layerCnt = 2; 3960 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3961 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3962 {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic}, 3963 {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Complete}}; 3964 bool optimize = false; 3965 3966 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3967 optimize)); 3968 } 3969 3970 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 3971 * source crop. */ 3972 TEST_F(Hwc2Test, PRESENT_DISPLAY_source_crop_1) 3973 { 3974 const size_t layerCnt = 1; 3975 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3976 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3977 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}, 3978 {Hwc2TestPropertyName::SourceCrop, Hwc2TestCoverage::Complete}}; 3979 bool optimize = true; 3980 3981 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3982 optimize)); 3983 } 3984 3985 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of 3986 * source crop. */ 3987 TEST_F(Hwc2Test, PRESENT_DISPLAY_source_crop_2) 3988 { 3989 const size_t layerCnt = 2; 3990 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 3991 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 3992 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}, 3993 {Hwc2TestPropertyName::SourceCrop, Hwc2TestCoverage::Complete}}; 3994 bool optimize = true; 3995 3996 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 3997 optimize)); 3998 } 3999 4000 4001 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 4002 * surface damage. */ 4003 TEST_F(Hwc2Test, PRESENT_DISPLAY_surface_damage_1) 4004 { 4005 const size_t layerCnt = 1; 4006 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 4007 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 4008 {{Hwc2TestPropertyName::SurfaceDamage, Hwc2TestCoverage::Complete}}; 4009 bool optimize = true; 4010 4011 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 4012 optimize)); 4013 } 4014 4015 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 4016 * transform. */ 4017 TEST_F(Hwc2Test, PRESENT_DISPLAY_transform_1) 4018 { 4019 const size_t layerCnt = 1; 4020 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 4021 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 4022 {{Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Complete}}; 4023 bool optimize = true; 4024 4025 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 4026 optimize)); 4027 } 4028 4029 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of 4030 * transform. */ 4031 TEST_F(Hwc2Test, PRESENT_DISPLAY_transform_2) 4032 { 4033 const size_t layerCnt = 2; 4034 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; 4035 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = 4036 {{Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Complete}, 4037 {Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Basic}}; 4038 bool optimize = true; 4039 4040 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 4041 optimize)); 4042 } 4043 4044 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of 4045 * basic. */ 4046 TEST_F(Hwc2Test, PRESENT_DISPLAY_basic_1) 4047 { 4048 const size_t layerCnt = 1; 4049 Hwc2TestCoverage coverage = Hwc2TestCoverage::Basic; 4050 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; 4051 bool optimize = true; 4052 4053 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, 4054 optimize)); 4055 } 4056 4057 /* TESTCASE: Tests that the HWC2 cannot present a bad display. */ 4058 TEST_F(Hwc2Test, PRESENT_DISPLAY_bad_display) 4059 { 4060 hwc2_display_t display; 4061 int32_t presentFence; 4062 hwc2_error_t err = HWC2_ERROR_NONE; 4063 4064 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 4065 4066 ASSERT_NO_FATAL_FAILURE(presentDisplay(display, &presentFence, &err)); 4067 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 4068 } 4069 4070 /* TESTCASE: Tests that the HWC2 cannot present an unvalidated display. */ 4071 TEST_F(Hwc2Test, PRESENT_DISPLAY_not_validated) 4072 { 4073 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Default, 1, 4074 [] (Hwc2Test* test, hwc2_display_t display, 4075 const std::vector<hwc2_layer_t>& /*layers*/, 4076 Hwc2TestLayers* /*testLayers*/) { 4077 4078 int32_t presentFence; 4079 hwc2_error_t err = HWC2_ERROR_NONE; 4080 4081 ASSERT_NO_FATAL_FAILURE(test->setPowerMode(display, 4082 HWC2_POWER_MODE_ON)); 4083 ASSERT_NO_FATAL_FAILURE(test->enableVsync(display)); 4084 4085 ASSERT_NO_FATAL_FAILURE(test->waitForVsync()); 4086 4087 ASSERT_NO_FATAL_FAILURE(test->presentDisplay(display, 4088 &presentFence, &err)); 4089 EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED) 4090 << "returned wrong error code"; 4091 4092 ASSERT_NO_FATAL_FAILURE(test->disableVsync(display)); 4093 ASSERT_NO_FATAL_FAILURE(test->setPowerMode(display, 4094 HWC2_POWER_MODE_OFF)); 4095 } 4096 )); 4097 } 4098 4099 /* TESTCASE: Tests that the HWC2 cannot get release fences from a bad display. */ 4100 TEST_F(Hwc2Test, GET_RELEASE_FENCES_bad_display) 4101 { 4102 hwc2_display_t display; 4103 std::vector<hwc2_layer_t> layers; 4104 std::vector<int32_t> fences; 4105 hwc2_error_t err = HWC2_ERROR_NONE; 4106 4107 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 4108 4109 ASSERT_NO_FATAL_FAILURE(getReleaseFences(display, &layers, &fences, &err)); 4110 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 4111 } 4112 4113 static const std::array<android_color_mode, 9> androidColorModes = {{ 4114 HAL_COLOR_MODE_NATIVE, 4115 HAL_COLOR_MODE_STANDARD_BT601_625, 4116 HAL_COLOR_MODE_STANDARD_BT601_625_UNADJUSTED, 4117 HAL_COLOR_MODE_STANDARD_BT601_525, 4118 HAL_COLOR_MODE_STANDARD_BT601_525_UNADJUSTED, 4119 HAL_COLOR_MODE_STANDARD_BT709, 4120 HAL_COLOR_MODE_DCI_P3, 4121 HAL_COLOR_MODE_SRGB, 4122 HAL_COLOR_MODE_ADOBE_RGB, 4123 }}; 4124 4125 /* TESTCASE: Tests that the HWC2 can get the color modes for a display. The 4126 * display must support HAL_COLOR_MODE_NATIVE */ 4127 TEST_F(Hwc2Test, GET_COLOR_MODES) 4128 { 4129 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( 4130 [] (Hwc2Test* test, hwc2_display_t display) { 4131 4132 std::vector<android_color_mode_t> colorModes; 4133 4134 ASSERT_NO_FATAL_FAILURE(test->getColorModes(display, 4135 &colorModes)); 4136 4137 EXPECT_NE(std::count(colorModes.begin(), colorModes.end(), 4138 HAL_COLOR_MODE_NATIVE), 0) << "all displays" 4139 " must support HAL_COLOR_MODE_NATIVE"; 4140 } 4141 )); 4142 } 4143 4144 /* TESTCASE: Tests that the HWC2 cannot get color modes from a bad display. */ 4145 TEST_F(Hwc2Test, GET_COLOR_MODES_bad_display) 4146 { 4147 hwc2_display_t display; 4148 std::vector<android_color_mode_t> colorModes; 4149 hwc2_error_t err = HWC2_ERROR_NONE; 4150 4151 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 4152 4153 ASSERT_NO_FATAL_FAILURE(getColorModes(display, &colorModes, &err)); 4154 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 4155 } 4156 4157 /* TESTCASE: Tests that the HWC2 can set the required color mode on a display. */ 4158 TEST_F(Hwc2Test, SET_COLOR_MODES) 4159 { 4160 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( 4161 [] (Hwc2Test* test, hwc2_display_t display) { 4162 4163 const android_color_mode_t colorMode = HAL_COLOR_MODE_NATIVE; 4164 4165 EXPECT_NO_FATAL_FAILURE(test->setColorMode(display, colorMode)); 4166 } 4167 )); 4168 } 4169 4170 /* TESTCASE: Tests that the HWC2 cannot set a color mode on a bad display. */ 4171 TEST_F(Hwc2Test, SET_COLOR_MODES_bad_display) 4172 { 4173 hwc2_display_t display; 4174 const android_color_mode_t colorMode = HAL_COLOR_MODE_NATIVE; 4175 hwc2_error_t err = HWC2_ERROR_NONE; 4176 4177 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 4178 4179 ASSERT_NO_FATAL_FAILURE(setColorMode(display, colorMode, &err)); 4180 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 4181 } 4182 4183 /* TESTCASE: Tests that the HWC2 cannot set an invalid color mode. */ 4184 TEST_F(Hwc2Test, SET_COLOR_MODES_bad_parameter) 4185 { 4186 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( 4187 [] (Hwc2Test* test, hwc2_display_t display) { 4188 4189 const android_color_mode_t colorMode = 4190 static_cast<android_color_mode_t>(-1); 4191 hwc2_error_t err = HWC2_ERROR_NONE; 4192 4193 ASSERT_NO_FATAL_FAILURE(test->setColorMode(display, colorMode, 4194 &err)); 4195 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) 4196 << "returned wrong error code"; 4197 } 4198 )); 4199 } 4200 4201 /* TESTCASE: Tests that the HWC2 either supports or returns error unsupported 4202 * for all valid color modes. */ 4203 TEST_F(Hwc2Test, SET_COLOR_MODES_unsupported) 4204 { 4205 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( 4206 [] (Hwc2Test* test, hwc2_display_t display) { 4207 4208 for (auto colorMode : androidColorModes) { 4209 hwc2_error_t err = HWC2_ERROR_NONE; 4210 4211 ASSERT_NO_FATAL_FAILURE(test->setColorMode(display, 4212 colorMode, &err)); 4213 4214 EXPECT_TRUE(err == HWC2_ERROR_NONE 4215 || err == HWC2_ERROR_UNSUPPORTED) 4216 << "returned wrong error code"; 4217 } 4218 } 4219 )); 4220 } 4221 4222 /* TESTCASE: Tests that the HWC2 gets the HDR capabilities for a display and 4223 * test if they are valid. */ 4224 TEST_F(Hwc2Test, GET_HDR_CAPABILITIES) 4225 { 4226 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( 4227 [] (Hwc2Test* test, hwc2_display_t display) { 4228 4229 std::vector<android_hdr_t> hdrCapabilities; 4230 float maxLuminance, maxAverageLuminance, minLuminance; 4231 4232 EXPECT_NO_FATAL_FAILURE(test->getHdrCapabilities(display, 4233 &hdrCapabilities, &maxLuminance, &maxAverageLuminance, 4234 &minLuminance)); 4235 4236 if (hdrCapabilities.empty()) 4237 return; 4238 4239 EXPECT_GE(maxLuminance, maxAverageLuminance); 4240 EXPECT_GE(maxAverageLuminance, minLuminance); 4241 } 4242 )); 4243 } 4244 4245 /* TESTCASE: Tests that the HWC2 cannot get hdr capabilities from a bad display */ 4246 TEST_F(Hwc2Test, GET_HDR_CAPABILITIES_bad_display) 4247 { 4248 hwc2_display_t display; 4249 std::vector<android_hdr_t> hdrCapabilities; 4250 float maxLuminance, maxAverageLuminance, minLuminance; 4251 hwc2_error_t err = HWC2_ERROR_NONE; 4252 4253 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 4254 4255 ASSERT_NO_FATAL_FAILURE(getHdrCapabilities(display, &hdrCapabilities, 4256 &maxLuminance, &maxAverageLuminance, &minLuminance, &err)); 4257 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 4258 } 4259 4260 static const std::array<float, 16> identityMatrix = {{ 4261 1.0, 0.0, 0.0, 0.0, 4262 0.0, 1.0, 0.0, 0.0, 4263 0.0, 0.0, 1.0, 0.0, 4264 0.0, 0.0, 0.0, 1.0, 4265 }}; 4266 4267 /* Values for the color transform matrices were precomputed using the source code 4268 * in surfaceflinger/Effects/Daltonizer.cpp. */ 4269 4270 static const std::array<const std::array<float, 16>, 5> exampleMatrices = {{ 4271 identityMatrix, 4272 /* Converts RGB color to the XYZ space */ 4273 {{ 0.4124, 0.2126, 0.0193, 0, 4274 0.3576, 0.7152, 0.1192, 0, 4275 0.1805, 0.0722, 0.9505, 0, 4276 0 , 0 , 0 , 1 }}, 4277 /* Protanomaly */ 4278 {{ 0.068493, 0.931506, 0, 0, 4279 0.068493, 0.931507, 0, 0, 4280 0.013626, -0.013626, 1, 0, 4281 0, 0, 0, 1 }}, 4282 /* Deuteranomaly */ 4283 {{ 0.288299, 0.711701, 0, 0, 4284 0.052709, 0.947291, 0, 0, 4285 -0.257912, 0.257912, 1, 0, 4286 0, 0, 0, 1 }}, 4287 /* Tritanomaly */ 4288 {{ 1, -0.805712, 0.805712, 0, 4289 0, 0.378838, 0.621162, 0, 4290 0, 0.104823, 0.895177, 0, 4291 0, 0, 0, 1 }}, 4292 }}; 4293 4294 /* TESTCASE: Tests that the HWC2 can set the identity color transform */ 4295 TEST_F(Hwc2Test, SET_COLOR_TRANSFORM) 4296 { 4297 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( 4298 [] (Hwc2Test* test, hwc2_display_t display) { 4299 4300 EXPECT_NO_FATAL_FAILURE(test->setColorTransform(display, 4301 identityMatrix, HAL_COLOR_TRANSFORM_IDENTITY)); 4302 } 4303 )); 4304 } 4305 4306 /* TESTCASE: Tests that the HWC2 cannot set the color transform for a bad 4307 * display. */ 4308 TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_bad_display) 4309 { 4310 hwc2_display_t display; 4311 hwc2_error_t err = HWC2_ERROR_NONE; 4312 4313 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 4314 4315 ASSERT_NO_FATAL_FAILURE(setColorTransform(display, identityMatrix, 4316 HAL_COLOR_TRANSFORM_IDENTITY, &err)); 4317 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 4318 } 4319 4320 /* TESTCASE: Tests that the HWC2 cannot set an invalid color transform. */ 4321 TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_bad_parameter) 4322 { 4323 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( 4324 [] (Hwc2Test* test, hwc2_display_t display) { 4325 4326 const android_color_transform_t hint = 4327 static_cast<android_color_transform_t>(-1); 4328 hwc2_error_t err = HWC2_ERROR_NONE; 4329 4330 ASSERT_NO_FATAL_FAILURE(test->setColorTransform(display, 4331 identityMatrix, hint, &err)); 4332 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) 4333 << "returned wrong error code"; 4334 } 4335 )); 4336 } 4337 4338 /* TESTCASE: Tests that the HWC2 can set an arbitrary color matrix. */ 4339 TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_arbitrary_matrix) 4340 { 4341 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( 4342 [] (Hwc2Test* test, hwc2_display_t display) { 4343 4344 const android_color_transform_t hint = 4345 HAL_COLOR_TRANSFORM_ARBITRARY_MATRIX; 4346 4347 for (const std::array<float, 16>& matrix : exampleMatrices) { 4348 EXPECT_NO_FATAL_FAILURE(test->setColorTransform(display, 4349 matrix, hint)); 4350 } 4351 } 4352 )); 4353 } 4354 4355 /* TESTCASE: Tests that the HWC2 create an destory virtual displays. */ 4356 TEST_F(Hwc2Test, CREATE_DESTROY_VIRTUAL_DISPLAY) 4357 { 4358 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Complete, 4359 [] (Hwc2Test* /*test*/, hwc2_display_t /*display*/, 4360 Hwc2TestVirtualDisplay* /*testVirtualDisplay*/) { })); 4361 } 4362 4363 /* TESTCASE: Tests that the HWC2 can create and destroy multiple virtual 4364 * displays. */ 4365 TEST_F(Hwc2Test, CREATE_DESTROY_VIRTUAL_DISPLAY_multiple) 4366 { 4367 Hwc2TestVirtualDisplay testVirtualDisplay(Hwc2TestCoverage::Complete); 4368 std::vector<hwc2_display_t> displays; 4369 4370 do { 4371 const UnsignedArea& dimension = 4372 testVirtualDisplay.getDisplayDimension(); 4373 android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888; 4374 hwc2_display_t display; 4375 hwc2_error_t err = HWC2_ERROR_NONE; 4376 4377 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(dimension.width, 4378 dimension.height, &desiredFormat, &display, &err)); 4379 4380 EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_NO_RESOURCES 4381 || err == HWC2_ERROR_UNSUPPORTED) << "returned wrong error code"; 4382 EXPECT_GE(desiredFormat, 0) << "invalid format"; 4383 4384 if (err == HWC2_ERROR_NONE) 4385 displays.push_back(display); 4386 4387 } while (testVirtualDisplay.advance()); 4388 4389 for (hwc2_display_t display : displays) { 4390 EXPECT_NO_FATAL_FAILURE(destroyVirtualDisplay(display)); 4391 } 4392 } 4393 4394 /* TESTCASE: Tests that the HWC2 cannot destroy a bad virtual displays. */ 4395 TEST_F(Hwc2Test, DESTROY_VIRTUAL_DISPLAY_bad_display) 4396 { 4397 hwc2_display_t display; 4398 hwc2_error_t err = HWC2_ERROR_NONE; 4399 4400 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); 4401 4402 ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display, &err)); 4403 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; 4404 } 4405 4406 /* TESTCASE: Tests that the HWC2 cannot destroy a physical display. */ 4407 TEST_F(Hwc2Test, DESTROY_VIRTUAL_DISPLAY_bad_parameter) 4408 { 4409 hwc2_display_t display = HWC_DISPLAY_PRIMARY; 4410 hwc2_error_t err = HWC2_ERROR_NONE; 4411 4412 ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display, &err)); 4413 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code"; 4414 } 4415 4416 /* TESTCASE: Tests that the HWC2 can get the max virtual display count. */ 4417 TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT) 4418 { 4419 uint32_t maxCnt; 4420 4421 ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt)); 4422 } 4423 4424 /* TESTCASE: Tests that the HWC2 returns the same max virtual display count for 4425 * each call. */ 4426 TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT_duplicate) 4427 { 4428 uint32_t maxCnt1, maxCnt2; 4429 4430 ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt1)); 4431 ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt2)); 4432 4433 EXPECT_EQ(maxCnt1, maxCnt2) << "returned two different max virtual display" 4434 " counts"; 4435 } 4436 4437 /* TESTCASE: Tests that the HWC2 can create the max number of virtual displays 4438 * that it reports. */ 4439 TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT_create_max) 4440 { 4441 std::vector<hwc2_display_t> displays; 4442 uint32_t maxCnt; 4443 4444 ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt)); 4445 4446 while (displays.size() < maxCnt) { 4447 uint32_t width = 1920, height = 1080; 4448 android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888; 4449 hwc2_display_t display; 4450 hwc2_error_t err = HWC2_ERROR_NONE; 4451 4452 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(width, height, 4453 &desiredFormat, &display, &err)); 4454 4455 EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_UNSUPPORTED) 4456 << "returned wrong error code"; 4457 if (err != HWC2_ERROR_NONE) 4458 break; 4459 4460 displays.push_back(display); 4461 } 4462 4463 for (hwc2_display_t display : displays) { 4464 EXPECT_NO_FATAL_FAILURE(destroyVirtualDisplay(display)); 4465 } 4466 } 4467 4468 /* TESTCASE: Tests that the HWC2 can set an output buffer for a virtual 4469 * display. */ 4470 TEST_F(Hwc2Test, SET_OUTPUT_BUFFER) 4471 { 4472 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Complete, 4473 [] (Hwc2Test* test, hwc2_display_t display, 4474 Hwc2TestVirtualDisplay* testVirtualDisplay) { 4475 4476 buffer_handle_t handle; 4477 android::base::unique_fd acquireFence; 4478 4479 if (testVirtualDisplay->getBuffer(&handle, &acquireFence) >= 0) 4480 EXPECT_NO_FATAL_FAILURE(test->setOutputBuffer(display, 4481 handle, acquireFence)); 4482 })); 4483 } 4484 4485 /* TESTCASE: Tests that the HWC2 cannot set an output buffer for a bad display */ 4486 TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_bad_display) 4487 { 4488 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Default, 4489 [] (Hwc2Test* test, hwc2_display_t /*display*/, 4490 Hwc2TestVirtualDisplay* testVirtualDisplay) { 4491 4492 hwc2_display_t badDisplay; 4493 buffer_handle_t handle; 4494 android::base::unique_fd acquireFence; 4495 hwc2_error_t err = HWC2_ERROR_NONE; 4496 4497 ASSERT_NO_FATAL_FAILURE(test->getBadDisplay(&badDisplay)); 4498 4499 if (testVirtualDisplay->getBuffer(&handle, &acquireFence) < 0) 4500 return; 4501 4502 ASSERT_NO_FATAL_FAILURE(test->setOutputBuffer(badDisplay, 4503 handle, acquireFence, &err)); 4504 EXPECT_TRUE(err == HWC2_ERROR_BAD_DISPLAY) 4505 << "returned wrong error code"; 4506 })); 4507 } 4508 4509 /* TESTCASE: Tests that the HWC2 cannot set an invalid output buffer. */ 4510 TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_bad_parameter) 4511 { 4512 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Default, 4513 [] (Hwc2Test* test, hwc2_display_t display, 4514 Hwc2TestVirtualDisplay* /*testVirtualDisplay*/) { 4515 4516 const buffer_handle_t handle = nullptr; 4517 uint32_t releaseFence = -1; 4518 hwc2_error_t err = HWC2_ERROR_NONE; 4519 4520 ASSERT_NO_FATAL_FAILURE(test->setOutputBuffer(display, handle, 4521 releaseFence, &err)); 4522 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) 4523 << "returned wrong error code"; 4524 })); 4525 } 4526 4527 /* TESTCASE: Tests that the HWC2 cannot set an output buffer for non virtual 4528 * display */ 4529 TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_unsupported) 4530 { 4531 for (auto display : mDisplays) { 4532 Hwc2TestVirtualDisplay testVirtualDisplay(Hwc2TestCoverage::Complete); 4533 4534 do { 4535 buffer_handle_t handle; 4536 android::base::unique_fd acquireFence; 4537 hwc2_error_t err = HWC2_ERROR_NONE; 4538 4539 if (testVirtualDisplay.getBuffer(&handle, &acquireFence) < 0) 4540 continue; 4541 4542 ASSERT_NO_FATAL_FAILURE(setOutputBuffer(display, handle, 4543 acquireFence, &err)); 4544 EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code"; 4545 4546 } while (testVirtualDisplay.advance()); 4547 } 4548 } 4549 4550 /* TESTCASE: Tests that the HWC2 can dump debug information. */ 4551 TEST_F(Hwc2Test, DUMP) 4552 { 4553 std::string buffer; 4554 4555 ASSERT_NO_FATAL_FAILURE(dump(&buffer)); 4556 } 4557
