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 37void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData, 38 hwc2_display_t display, int32_t connected); 39void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData, 40 hwc2_display_t display, int64_t timestamp); 41 42class Hwc2Test : public testing::Test { 43public: 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 1080protected: 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 1805void 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 1813void 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 1821void 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 1828void 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 1849void 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 1862void 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 1883void 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 1894void 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 1901void 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 1908void 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 1917void 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 1924void 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 1931void 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 1938void 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 1945void 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 1952bool advanceBlendMode(Hwc2TestLayer* testLayer) 1953{ 1954 return testLayer->advanceBlendMode(); 1955} 1956 1957bool advanceBuffer(Hwc2TestLayer* testLayer) 1958{ 1959 if (testLayer->advanceComposition()) 1960 return true; 1961 return testLayer->advanceBufferArea(); 1962} 1963 1964bool 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 1975bool advanceComposition(Hwc2TestLayer* testLayer) 1976{ 1977 return testLayer->advanceComposition(); 1978} 1979 1980bool advanceCursorPosition(Hwc2TestLayer* testLayer) 1981{ 1982 return testLayer->advanceCursorPosition(); 1983} 1984 1985bool advanceDataspace(Hwc2TestLayer* testLayer) 1986{ 1987 return testLayer->advanceDataspace(); 1988} 1989 1990bool advanceDisplayFrame(Hwc2TestLayer* testLayer) 1991{ 1992 return testLayer->advanceDisplayFrame(); 1993} 1994 1995bool advancePlaneAlpha(Hwc2TestLayer* testLayer) 1996{ 1997 return testLayer->advancePlaneAlpha(); 1998} 1999 2000bool advanceSourceCrop(Hwc2TestLayer* testLayer) 2001{ 2002 if (testLayer->advanceSourceCrop()) 2003 return true; 2004 return testLayer->advanceBufferArea(); 2005} 2006 2007bool advanceSurfaceDamage(Hwc2TestLayer* testLayer) 2008{ 2009 if (testLayer->advanceSurfaceDamage()) 2010 return true; 2011 return testLayer->advanceBufferArea(); 2012} 2013 2014bool advanceTransform(Hwc2TestLayer* testLayer) 2015{ 2016 return testLayer->advanceTransform(); 2017} 2018 2019bool advanceVisibleRegions(Hwc2TestLayers* testLayers) 2020{ 2021 return testLayers->advanceVisibleRegions(); 2022} 2023 2024bool advanceClientTargetSupport( 2025 Hwc2TestClientTargetSupport* testClientTargetSupport) 2026{ 2027 return testClientTargetSupport->advance(); 2028} 2029 2030static 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. */ 2076TEST_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. */ 2086TEST_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. */ 2093TEST_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 2103static 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. */ 2111TEST_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. */ 2123TEST_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. */ 2135TEST_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. */ 2147TEST_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. */ 2160TEST_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. */ 2173TEST_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 */ 2185TEST_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. */ 2199TEST_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 */ 2213TEST_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 */ 2236TEST_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 2269static const std::array<hwc2_attribute_t, 2> requiredAttributes = {{ 2270 HWC2_ATTRIBUTE_WIDTH, 2271 HWC2_ATTRIBUTE_HEIGHT, 2272}}; 2273 2274static 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. */ 2282TEST_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 */ 2309TEST_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 */ 2331TEST_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 */ 2354TEST_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 */ 2378TEST_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 */ 2388TEST_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. */ 2404TEST_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 */ 2418TEST_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 */ 2433TEST_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. */ 2453TEST_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. */ 2468TEST_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 */ 2493TEST_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 */ 2507TEST_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 */ 2520TEST_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. */ 2534TEST_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. */ 2546TEST_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 */ 2560TEST_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. */ 2580TEST_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. */ 2607TEST_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. */ 2622TEST_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. */ 2645TEST_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 */ 2676TEST_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. */ 2696TEST_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 */ 2719TEST_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 */ 2739TEST_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. */ 2761TEST_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. */ 2786TEST_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. */ 2801TEST_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 */ 2819TEST_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 */ 2830TEST_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. */ 2843TEST_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. */ 2851TEST_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 */ 2858TEST_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 */ 2865TEST_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. */ 2878TEST_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. */ 2885TEST_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. */ 2893TEST_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. */ 2909TEST_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. */ 2923TEST_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. */ 2938TEST_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. */ 2945TEST_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. */ 2952TEST_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. */ 2959TEST_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. */ 2972TEST_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. */ 2979TEST_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. */ 2986TEST_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. */ 3009TEST_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. */ 3025TEST_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. */ 3032TEST_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. */ 3040TEST_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. */ 3054TEST_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. */ 3067TEST_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. */ 3074TEST_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. */ 3081TEST_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. */ 3088TEST_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. */ 3095TEST_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. */ 3102TEST_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. */ 3109TEST_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. */ 3116TEST_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. */ 3123TEST_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. */ 3136TEST_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. */ 3143TEST_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. */ 3150TEST_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. */ 3157TEST_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. */ 3164TEST_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. */ 3171TEST_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. */ 3178TEST_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. */ 3185TEST_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. */ 3192TEST_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. */ 3199TEST_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. */ 3213TEST_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. */ 3220TEST_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. */ 3240TEST_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. */ 3269TEST_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 */ 3277TEST_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. */ 3297TEST_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 */ 3317TEST_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. */ 3332TEST_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 */ 3355TEST_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. */ 3372TEST_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. */ 3392TEST_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 */ 3416TEST_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. */ 3432TEST_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. */ 3451TEST_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 */ 3477TEST_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. */ 3490TEST_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 */ 3506TEST_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. */ 3525TEST_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. */ 3549TEST_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. */ 3572TEST_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. */ 3644TEST_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. */ 3677TEST_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. */ 3689TEST_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. */ 3701TEST_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. */ 3713TEST_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. */ 3725TEST_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. */ 3737TEST_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. */ 3750TEST_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. */ 3766TEST_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. */ 3781TEST_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. */ 3795TEST_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. */ 3810TEST_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. */ 3827TEST_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. */ 3841TEST_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. */ 3856TEST_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. */ 3872TEST_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. */ 3886TEST_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. */ 3900TEST_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. */ 3914TEST_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. */ 3928TEST_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. */ 3942TEST_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. */ 3957TEST_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. */ 3972TEST_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. */ 3987TEST_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. */ 4003TEST_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. */ 4017TEST_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. */ 4031TEST_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. */ 4046TEST_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. */ 4058TEST_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. */ 4071TEST_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. */ 4100TEST_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 4113static 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 */ 4127TEST_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. */ 4145TEST_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. */ 4158TEST_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. */ 4171TEST_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. */ 4184TEST_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. */ 4203TEST_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. */ 4224TEST_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 */ 4246TEST_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 4260static 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 4270static 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 */ 4295TEST_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. */ 4308TEST_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. */ 4321TEST_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. */ 4339TEST_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. */ 4356TEST_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. */ 4365TEST_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. */ 4395TEST_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. */ 4407TEST_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. */ 4417TEST_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. */ 4426TEST_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. */ 4439TEST_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. */ 4470TEST_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 */ 4486TEST_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. */ 4510TEST_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 */ 4529TEST_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. */ 4551TEST_F(Hwc2Test, DUMP) 4552{ 4553 std::string buffer; 4554 4555 ASSERT_NO_FATAL_FAILURE(dump(&buffer)); 4556} 4557