| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <array> |
| #include <unordered_set> |
| #include <unordered_map> |
| #include <gtest/gtest.h> |
| #include <dlfcn.h> |
| #include <android-base/unique_fd.h> |
| #include <hardware/hardware.h> |
| #include <sync/sync.h> |
| #include <ui/GraphicTypes.h> |
| |
| #define HWC2_INCLUDE_STRINGIFICATION |
| #define HWC2_USE_CPP11 |
| #include <hardware/hwcomposer2.h> |
| #undef HWC2_INCLUDE_STRINGIFICATION |
| #undef HWC2_USE_CPP11 |
| |
| #include "Hwc2TestLayer.h" |
| #include "Hwc2TestLayers.h" |
| #include "Hwc2TestClientTarget.h" |
| #include "Hwc2TestVirtualDisplay.h" |
| |
| using android::ui::ColorMode; |
| using android::ui::Dataspace; |
| |
| void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, int32_t connected); |
| void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, int64_t timestamp); |
| |
| class Hwc2Test : public testing::Test { |
| public: |
| |
| virtual void SetUp() |
| { |
| hw_module_t const* hwc2Module; |
| |
| int err = hw_get_module(HWC_HARDWARE_MODULE_ID, &hwc2Module); |
| ASSERT_GE(err, 0) << "failed to get hwc hardware module: " |
| << strerror(-err); |
| |
| /* The following method will fail if you have not run |
| * "adb shell stop" */ |
| err = hwc2_open(hwc2Module, &mHwc2Device); |
| ASSERT_GE(err, 0) << "failed to open hwc hardware module: " |
| << strerror(-err); |
| |
| populateDisplays(); |
| } |
| |
| virtual void TearDown() |
| { |
| |
| for (auto itr = mLayers.begin(); itr != mLayers.end();) { |
| hwc2_display_t display = itr->first; |
| hwc2_layer_t layer = itr->second; |
| itr++; |
| /* Destroys and removes the layer from mLayers */ |
| destroyLayer(display, layer); |
| } |
| |
| for (auto itr = mActiveDisplays.begin(); itr != mActiveDisplays.end();) { |
| hwc2_display_t display = *itr; |
| itr++; |
| /* Sets power mode to off and removes the display from |
| * mActiveDisplays */ |
| setPowerMode(display, HWC2_POWER_MODE_OFF); |
| } |
| |
| for (auto itr = mVirtualDisplays.begin(); itr != mVirtualDisplays.end();) { |
| hwc2_display_t display = *itr; |
| itr++; |
| /* Destroys virtual displays */ |
| destroyVirtualDisplay(display); |
| } |
| |
| if (mHwc2Device) |
| hwc2_close(mHwc2Device); |
| } |
| |
| void registerCallback(hwc2_callback_descriptor_t descriptor, |
| hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_REGISTER_CALLBACK>( |
| getFunction(HWC2_FUNCTION_REGISTER_CALLBACK)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, descriptor, |
| callbackData, pointer)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to register callback"; |
| } |
| } |
| |
| void getDisplayType(hwc2_display_t display, hwc2_display_type_t* outType, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_TYPE>( |
| getFunction(HWC2_FUNCTION_GET_DISPLAY_TYPE)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| reinterpret_cast<int32_t*>(outType))); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display type"; |
| } |
| } |
| |
| /* If the populateDisplays function is still receiving displays and the |
| * display is connected, the display handle is stored in mDisplays. */ |
| void hotplugCallback(hwc2_display_t display, int32_t connected) |
| { |
| std::lock_guard<std::mutex> lock(mHotplugMutex); |
| |
| if (mHotplugStatus != Hwc2TestHotplugStatus::Receiving) |
| return; |
| |
| if (connected == HWC2_CONNECTION_CONNECTED) |
| mDisplays.insert(display); |
| |
| mHotplugCv.notify_all(); |
| } |
| |
| void createLayer(hwc2_display_t display, hwc2_layer_t* outLayer, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_CREATE_LAYER>( |
| getFunction(HWC2_FUNCTION_CREATE_LAYER)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| outLayer)); |
| |
| if (err == HWC2_ERROR_NONE) |
| mLayers.insert(std::make_pair(display, *outLayer)); |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create layer"; |
| } |
| } |
| |
| void destroyLayer(hwc2_display_t display, hwc2_layer_t layer, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_DESTROY_LAYER>( |
| getFunction(HWC2_FUNCTION_DESTROY_LAYER)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer)); |
| |
| if (err == HWC2_ERROR_NONE) |
| mLayers.erase(std::make_pair(display, layer)); |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to destroy layer " |
| << layer; |
| } |
| } |
| |
| void getDisplayAttribute(hwc2_display_t display, hwc2_config_t config, |
| hwc2_attribute_t attribute, int32_t* outValue, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>( |
| getFunction(HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, config, |
| attribute, outValue)); |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display attribute " |
| << getAttributeName(attribute) << " for config " << config; |
| } |
| } |
| |
| void getDisplayConfigs(hwc2_display_t display, |
| std::vector<hwc2_config_t>* outConfigs, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_CONFIGS>( |
| getFunction(HWC2_FUNCTION_GET_DISPLAY_CONFIGS)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| uint32_t numConfigs = 0; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| &numConfigs, nullptr)); |
| |
| if (err == HWC2_ERROR_NONE) { |
| outConfigs->resize(numConfigs); |
| |
| err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| &numConfigs, outConfigs->data())); |
| } |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get configs for" |
| " display " << display; |
| } |
| } |
| |
| void getActiveConfig(hwc2_display_t display, hwc2_config_t* outConfig, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_ACTIVE_CONFIG>( |
| getFunction(HWC2_FUNCTION_GET_ACTIVE_CONFIG)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| outConfig)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get active config on" |
| " display " << display; |
| } |
| } |
| |
| void setActiveConfig(hwc2_display_t display, hwc2_config_t config, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_ACTIVE_CONFIG>( |
| getFunction(HWC2_FUNCTION_SET_ACTIVE_CONFIG)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, config)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set active config " |
| << config; |
| } |
| } |
| |
| void getDozeSupport(hwc2_display_t display, int32_t* outSupport, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_DOZE_SUPPORT>( |
| getFunction(HWC2_FUNCTION_GET_DOZE_SUPPORT)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| outSupport)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get doze support on" |
| " display " << display; |
| } |
| } |
| |
| void setPowerMode(hwc2_display_t display, hwc2_power_mode_t mode, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_POWER_MODE>( |
| getFunction(HWC2_FUNCTION_SET_POWER_MODE)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| mode)); |
| if (outErr) { |
| *outErr = err; |
| if (err != HWC2_ERROR_NONE) |
| return; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set power mode " |
| << getPowerModeName(mode) << " on display " << display; |
| } |
| |
| if (mode == HWC2_POWER_MODE_OFF) { |
| mActiveDisplays.erase(display); |
| } else { |
| mActiveDisplays.insert(display); |
| } |
| } |
| |
| void setVsyncEnabled(hwc2_display_t display, hwc2_vsync_t enabled, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_VSYNC_ENABLED>( |
| getFunction(HWC2_FUNCTION_SET_VSYNC_ENABLED)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| enabled)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set vsync enabled " |
| << getVsyncName(enabled); |
| } |
| } |
| |
| void vsyncCallback(hwc2_display_t display, int64_t timestamp) |
| { |
| std::lock_guard<std::mutex> lock(mVsyncMutex); |
| mVsyncDisplay = display; |
| mVsyncTimestamp = timestamp; |
| mVsyncCv.notify_all(); |
| } |
| |
| void getDisplayName(hwc2_display_t display, std::string* outName, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_NAME>( |
| getFunction(HWC2_FUNCTION_GET_DISPLAY_NAME)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| uint32_t size = 0; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, &size, |
| nullptr)); |
| |
| if (err == HWC2_ERROR_NONE) { |
| std::vector<char> name(size); |
| |
| err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, &size, |
| name.data())); |
| |
| outName->assign(name.data()); |
| } |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display name for " |
| << display; |
| } |
| } |
| |
| void setLayerCompositionType(hwc2_display_t display, hwc2_layer_t layer, |
| hwc2_composition_t composition, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, |
| composition)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer composition" |
| " type " << getCompositionName(composition); |
| } |
| } |
| |
| void setCursorPosition(hwc2_display_t display, hwc2_layer_t layer, |
| int32_t x, int32_t y, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_CURSOR_POSITION>( |
| getFunction(HWC2_FUNCTION_SET_CURSOR_POSITION)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, x, |
| y)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_TRUE((err == HWC2_ERROR_NONE) || |
| (err == HWC2_ERROR_BAD_LAYER)) << |
| "failed to set cursor position"; |
| } |
| } |
| |
| void setLayerBlendMode(hwc2_display_t display, hwc2_layer_t layer, |
| hwc2_blend_mode_t mode, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_BLEND_MODE>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_BLEND_MODE)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, |
| mode)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer blend mode " |
| << getBlendModeName(mode); |
| } |
| } |
| |
| void setLayerBuffer(hwc2_display_t display, hwc2_layer_t layer, |
| buffer_handle_t buffer, int32_t acquireFence, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_BUFFER>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_BUFFER)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, |
| buffer, acquireFence)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer buffer"; |
| } |
| } |
| |
| void setLayerColor(hwc2_display_t display, hwc2_layer_t layer, |
| hwc_color_t color, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_COLOR>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_COLOR)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, |
| color)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer color"; |
| } |
| } |
| |
| void setLayerDataspace(hwc2_display_t display, hwc2_layer_t layer, |
| Dataspace dataspace, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_DATASPACE>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_DATASPACE)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| layer, static_cast<int>(dataspace))); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer dataspace"; |
| } |
| } |
| |
| void setLayerDisplayFrame(hwc2_display_t display, hwc2_layer_t layer, |
| const hwc_rect_t& displayFrame, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, |
| displayFrame)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer display" |
| " frame"; |
| } |
| } |
| |
| void setLayerPlaneAlpha(hwc2_display_t display, hwc2_layer_t layer, |
| float alpha, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_PLANE_ALPHA>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, |
| alpha)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer plane alpha " |
| << alpha; |
| } |
| } |
| |
| void setLayerSourceCrop(hwc2_display_t display, hwc2_layer_t layer, |
| const hwc_frect_t& sourceCrop, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_SOURCE_CROP>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_SOURCE_CROP)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, |
| sourceCrop)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer source crop"; |
| } |
| } |
| |
| void setLayerSurfaceDamage(hwc2_display_t display, hwc2_layer_t layer, |
| const hwc_region_t& surfaceDamage, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, |
| surfaceDamage)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer surface" |
| " damage"; |
| } |
| } |
| |
| void setLayerTransform(hwc2_display_t display, hwc2_layer_t layer, |
| hwc_transform_t transform, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_TRANSFORM>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_TRANSFORM)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, |
| transform)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer transform " |
| << getTransformName(transform); |
| } |
| } |
| |
| void setLayerVisibleRegion(hwc2_display_t display, hwc2_layer_t layer, |
| const hwc_region_t& visibleRegion, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_VISIBLE_REGION>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, |
| visibleRegion)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer visible" |
| " region"; |
| } |
| } |
| |
| void setLayerZOrder(hwc2_display_t display, hwc2_layer_t layer, |
| uint32_t zOrder, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_Z_ORDER>( |
| getFunction(HWC2_FUNCTION_SET_LAYER_Z_ORDER)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, |
| zOrder)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer z order " |
| << zOrder; |
| } |
| } |
| |
| void validateDisplay(hwc2_display_t display, uint32_t* outNumTypes, |
| uint32_t* outNumRequests, hwc2_error_t* outErr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_VALIDATE_DISPLAY>( |
| getFunction(HWC2_FUNCTION_VALIDATE_DISPLAY)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| *outErr = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| outNumTypes, outNumRequests)); |
| } |
| |
| void validateDisplay(hwc2_display_t display, uint32_t* outNumTypes, |
| uint32_t* outNumRequests, bool* outHasChanges) |
| { |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| EXPECT_NO_FATAL_FAILURE(validateDisplay(display, outNumTypes, |
| outNumRequests, &err)); |
| |
| if (err != HWC2_ERROR_HAS_CHANGES) { |
| *outHasChanges = false; |
| EXPECT_EQ(err, HWC2_ERROR_NONE) << "failed to validate display"; |
| } else { |
| *outHasChanges = true; |
| } |
| } |
| |
| void getDisplayRequests(hwc2_display_t display, |
| hwc2_display_request_t* outDisplayRequests, |
| std::vector<hwc2_layer_t>* outLayers, |
| std::vector<hwc2_layer_request_t>* outLayerRequests, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_REQUESTS>( |
| getFunction(HWC2_FUNCTION_GET_DISPLAY_REQUESTS)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| uint32_t numElements = 0; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| reinterpret_cast<int32_t*>(outDisplayRequests), &numElements, |
| nullptr, nullptr)); |
| |
| if (err == HWC2_ERROR_NONE && numElements > 0) { |
| outLayers->resize(numElements); |
| outLayerRequests->resize(numElements); |
| |
| err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| reinterpret_cast<int32_t*>(outDisplayRequests), &numElements, |
| reinterpret_cast<uint64_t*>(outLayers->data()), |
| reinterpret_cast<int32_t*>(outLayerRequests->data()))); |
| } |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display requests"; |
| } |
| } |
| |
| void handleRequests(hwc2_display_t display, |
| const std::vector<hwc2_layer_t>& layers, uint32_t numRequests, |
| std::set<hwc2_layer_t>* outClearLayers = nullptr, |
| bool* outFlipClientTarget = nullptr) |
| { |
| hwc2_display_request_t displayRequest = |
| static_cast<hwc2_display_request_t>(0); |
| std::vector<hwc2_layer_t> requestedLayers; |
| std::vector<hwc2_layer_request_t> requests; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayRequests(display, &displayRequest, |
| &requestedLayers, &requests)); |
| |
| EXPECT_EQ(numRequests, requests.size()) << "validate returned " |
| << numRequests << " requests and get display requests returned " |
| << requests.size() << " requests"; |
| |
| for (size_t i = 0; i < requests.size(); i++) { |
| hwc2_layer_t requestedLayer = requestedLayers.at(i); |
| hwc2_layer_request_t request = requests.at(i); |
| |
| EXPECT_EQ(std::count(layers.begin(), layers.end(), requestedLayer), |
| 1) << "get display requests returned an unknown layer"; |
| EXPECT_NE(request, 0) << "returned empty request for layer " |
| << requestedLayer; |
| |
| if (outClearLayers && request |
| == HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET) |
| outClearLayers->insert(requestedLayer); |
| } |
| |
| if (outFlipClientTarget) |
| *outFlipClientTarget = displayRequest |
| & HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET; |
| } |
| |
| void getChangedCompositionTypes(hwc2_display_t display, |
| std::vector<hwc2_layer_t>* outLayers, |
| std::vector<hwc2_composition_t>* outTypes, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>( |
| getFunction(HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| uint32_t numElements = 0; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| &numElements, nullptr, nullptr)); |
| |
| if (err == HWC2_ERROR_NONE && numElements > 0) { |
| outLayers->resize(numElements); |
| outTypes->resize(numElements); |
| |
| err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| &numElements, reinterpret_cast<uint64_t*>(outLayers->data()), |
| reinterpret_cast<int32_t*>(outTypes->data()))); |
| } |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get changed" |
| " composition types"; |
| } |
| } |
| |
| void handleCompositionChanges(hwc2_display_t display, |
| const Hwc2TestLayers& testLayers, |
| const std::vector<hwc2_layer_t>& layers, uint32_t numTypes, |
| std::set<hwc2_layer_t>* outClientLayers = nullptr) |
| { |
| std::vector<hwc2_layer_t> changedLayers; |
| std::vector<hwc2_composition_t> types; |
| |
| ASSERT_NO_FATAL_FAILURE(getChangedCompositionTypes(display, |
| &changedLayers, &types)); |
| |
| EXPECT_EQ(numTypes, types.size()) << "validate returned " |
| << numTypes << " types and get changed composition types" |
| " returned " << types.size() << " types"; |
| |
| for (size_t i = 0; i < types.size(); i++) { |
| |
| auto layer = std::find(layers.begin(), layers.end(), |
| changedLayers.at(i)); |
| |
| EXPECT_TRUE(layer != layers.end() || !testLayers.contains(*layer)) |
| << "get changed composition types returned an unknown layer"; |
| |
| hwc2_composition_t requestedType = testLayers.getComposition(*layer); |
| hwc2_composition_t returnedType = types.at(i); |
| |
| EXPECT_NE(returnedType, HWC2_COMPOSITION_INVALID) << "get changed" |
| " composition types returned invalid composition"; |
| |
| switch (requestedType) { |
| case HWC2_COMPOSITION_CLIENT: |
| EXPECT_TRUE(false) << getCompositionName(returnedType) |
| << " cannot be changed"; |
| break; |
| case HWC2_COMPOSITION_DEVICE: |
| case HWC2_COMPOSITION_SOLID_COLOR: |
| EXPECT_EQ(returnedType, HWC2_COMPOSITION_CLIENT) |
| << "composition of type " |
| << getCompositionName(requestedType) |
| << " can only be changed to " |
| << getCompositionName(HWC2_COMPOSITION_CLIENT); |
| break; |
| case HWC2_COMPOSITION_CURSOR: |
| case HWC2_COMPOSITION_SIDEBAND: |
| EXPECT_TRUE(returnedType == HWC2_COMPOSITION_CLIENT |
| || returnedType == HWC2_COMPOSITION_DEVICE) |
| << "composition of type " |
| << getCompositionName(requestedType) |
| << " can only be changed to " |
| << getCompositionName(HWC2_COMPOSITION_CLIENT) << " or " |
| << getCompositionName(HWC2_COMPOSITION_DEVICE); |
| break; |
| default: |
| EXPECT_TRUE(false) << "unknown type " |
| << getCompositionName(requestedType); |
| break; |
| } |
| |
| if (outClientLayers) |
| if (returnedType == HWC2_COMPOSITION_CLIENT) |
| outClientLayers->insert(*layer); |
| } |
| |
| if (outClientLayers) { |
| for (auto layer : layers) { |
| if (testLayers.getComposition(layer) == HWC2_COMPOSITION_CLIENT) |
| outClientLayers->insert(layer); |
| } |
| } |
| } |
| |
| void acceptDisplayChanges(hwc2_display_t display, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>( |
| getFunction(HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to accept display changes"; |
| } |
| } |
| |
| void getClientTargetSupport(hwc2_display_t display, int32_t width, |
| int32_t height, android_pixel_format_t format, |
| Dataspace dataspace, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>( |
| getFunction(HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, width, |
| height, format, static_cast<int>(dataspace))); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get client target" |
| " support"; |
| } |
| } |
| |
| void setClientTarget(hwc2_display_t display, buffer_handle_t handle, |
| int32_t acquireFence, Dataspace dataspace, |
| hwc_region_t damage, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_CLIENT_TARGET>( |
| getFunction(HWC2_FUNCTION_SET_CLIENT_TARGET)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, handle, |
| acquireFence, static_cast<int>(dataspace), damage)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set client target"; |
| } |
| } |
| |
| void presentDisplay(hwc2_display_t display, int32_t* outPresentFence, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_PRESENT_DISPLAY>( |
| getFunction(HWC2_FUNCTION_PRESENT_DISPLAY)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| outPresentFence)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to present display"; |
| } |
| } |
| |
| void getReleaseFences(hwc2_display_t display, |
| std::vector<hwc2_layer_t>* outLayers, |
| std::vector<int32_t>* outFences, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_RELEASE_FENCES>( |
| getFunction(HWC2_FUNCTION_GET_RELEASE_FENCES)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| uint32_t numElements = 0; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| &numElements, nullptr, nullptr)); |
| |
| if (err == HWC2_ERROR_NONE) { |
| outLayers->resize(numElements); |
| outFences->resize(numElements); |
| |
| err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| &numElements, outLayers->data(), outFences->data())); |
| } |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get release fences"; |
| } |
| } |
| |
| void getColorModes(hwc2_display_t display, |
| std::vector<ColorMode>* outColorModes, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_COLOR_MODES>( |
| getFunction(HWC2_FUNCTION_GET_COLOR_MODES)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| uint32_t numColorModes = 0; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| &numColorModes, nullptr)); |
| if (err == HWC2_ERROR_NONE) { |
| outColorModes->resize(numColorModes); |
| |
| err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| &numColorModes, |
| reinterpret_cast<int32_t*>(outColorModes->data()))); |
| } |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get color modes for" |
| " display " << display; |
| } |
| } |
| |
| void setColorMode(hwc2_display_t display, ColorMode colorMode, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_COLOR_MODE>( |
| getFunction(HWC2_FUNCTION_SET_COLOR_MODE)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| static_cast<int32_t>(colorMode))); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set color mode " |
| << static_cast<int>(colorMode); |
| } |
| } |
| |
| void getHdrCapabilities(hwc2_display_t display, |
| std::vector<android_hdr_t>* outTypes, float* outMaxLuminance, |
| float* outMaxAverageLuminance, float* outMinLuminance, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_HDR_CAPABILITIES>( |
| getFunction(HWC2_FUNCTION_GET_HDR_CAPABILITIES)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| uint32_t numTypes = 0; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| &numTypes, nullptr, outMaxLuminance, outMaxAverageLuminance, |
| outMinLuminance)); |
| |
| if (err == HWC2_ERROR_NONE) { |
| outTypes->resize(numTypes); |
| |
| err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, &numTypes, |
| reinterpret_cast<int32_t*>(outTypes->data()), outMaxLuminance, |
| outMaxAverageLuminance, outMinLuminance)); |
| } |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get hdr capabilities" |
| " for display " << display; |
| } |
| } |
| |
| void setColorTransform(hwc2_display_t display, |
| const std::array<float, 16>& matrix, android_color_transform_t hint, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_COLOR_TRANSFORM>( |
| getFunction(HWC2_FUNCTION_SET_COLOR_TRANSFORM)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, |
| matrix.data(), hint)); |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set color transform " |
| << hint; |
| } |
| } |
| |
| void createVirtualDisplay(uint32_t width, uint32_t height, |
| android_pixel_format_t* outFormat, hwc2_display_t* outDisplay, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>( |
| getFunction(HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, width, height, |
| reinterpret_cast<int32_t*>(outFormat), outDisplay)); |
| |
| if (err == HWC2_ERROR_NONE) |
| mVirtualDisplays.insert(*outDisplay); |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create virtual display"; |
| } |
| } |
| |
| void destroyVirtualDisplay(hwc2_display_t display, |
| hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>( |
| getFunction(HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display)); |
| |
| if (err == HWC2_ERROR_NONE) |
| mVirtualDisplays.erase(display); |
| |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to destroy virtual display"; |
| } |
| } |
| |
| void getMaxVirtualDisplayCount(uint32_t* outMaxCnt) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>( |
| getFunction(HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| *outMaxCnt = pfn(mHwc2Device); |
| } |
| |
| void setOutputBuffer(hwc2_display_t display, buffer_handle_t buffer, |
| int32_t releaseFence, hwc2_error_t* outErr = nullptr) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_SET_OUTPUT_BUFFER>( |
| getFunction(HWC2_FUNCTION_SET_OUTPUT_BUFFER)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, buffer, |
| releaseFence)); |
| if (outErr) { |
| *outErr = err; |
| } else { |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set output buffer"; |
| } |
| } |
| |
| void dump(std::string* outBuffer) |
| { |
| auto pfn = reinterpret_cast<HWC2_PFN_DUMP>( |
| getFunction(HWC2_FUNCTION_DUMP)); |
| ASSERT_TRUE(pfn) << "failed to get function"; |
| |
| uint32_t size = 0; |
| |
| pfn(mHwc2Device, &size, nullptr); |
| |
| std::vector<char> buffer(size); |
| |
| pfn(mHwc2Device, &size, buffer.data()); |
| |
| outBuffer->assign(buffer.data()); |
| } |
| |
| void getBadDisplay(hwc2_display_t* outDisplay) |
| { |
| for (hwc2_display_t display = 0; display < UINT64_MAX; display++) { |
| if (mDisplays.count(display) == 0) { |
| *outDisplay = display; |
| return; |
| } |
| } |
| ASSERT_TRUE(false) << "Unable to find bad display. UINT64_MAX displays" |
| " are registered. This should never happen."; |
| } |
| |
| void waitForVsync(hwc2_display_t* outDisplay = nullptr, |
| int64_t* outTimestamp = nullptr) |
| { |
| std::unique_lock<std::mutex> lock(mVsyncMutex); |
| ASSERT_EQ(mVsyncCv.wait_for(lock, std::chrono::seconds(3)), |
| std::cv_status::no_timeout) << "timed out attempting to get" |
| " vsync callback"; |
| if (outDisplay) |
| *outDisplay = mVsyncDisplay; |
| if (outTimestamp) |
| *outTimestamp = mVsyncTimestamp; |
| } |
| |
| void enableVsync(hwc2_display_t display) |
| { |
| ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, this, |
| reinterpret_cast<hwc2_function_pointer_t>( |
| hwc2TestVsyncCallback))); |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); |
| } |
| |
| void disableVsync(hwc2_display_t display) |
| { |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); |
| } |
| |
| protected: |
| hwc2_function_pointer_t getFunction(hwc2_function_descriptor_t descriptor) |
| { |
| return mHwc2Device->getFunction(mHwc2Device, descriptor); |
| } |
| |
| void getCapabilities(std::vector<hwc2_capability_t>* outCapabilities) |
| { |
| uint32_t num = 0; |
| |
| mHwc2Device->getCapabilities(mHwc2Device, &num, nullptr); |
| |
| outCapabilities->resize(num); |
| |
| mHwc2Device->getCapabilities(mHwc2Device, &num, |
| reinterpret_cast<int32_t*>(outCapabilities->data())); |
| } |
| |
| /* Registers a hotplug callback and waits for hotplug callbacks. This |
| * function will have no effect if called more than once. */ |
| void populateDisplays() |
| { |
| /* Sets the hotplug status to receiving */ |
| { |
| std::lock_guard<std::mutex> lock(mHotplugMutex); |
| |
| if (mHotplugStatus != Hwc2TestHotplugStatus::Init) |
| return; |
| mHotplugStatus = Hwc2TestHotplugStatus::Receiving; |
| } |
| |
| /* Registers the callback. This function call cannot be locked because |
| * a callback could happen on the same thread */ |
| ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_HOTPLUG, this, |
| reinterpret_cast<hwc2_function_pointer_t>( |
| hwc2TestHotplugCallback))); |
| |
| /* Waits for hotplug events. If a hotplug event has not come within 1 |
| * second, stop waiting. */ |
| std::unique_lock<std::mutex> lock(mHotplugMutex); |
| |
| while (mHotplugCv.wait_for(lock, std::chrono::seconds(1)) != |
| std::cv_status::timeout) { } |
| |
| /* Sets the hotplug status to done. Future calls will have no effect */ |
| mHotplugStatus = Hwc2TestHotplugStatus::Done; |
| } |
| |
| /* NOTE: will create min(newlayerCnt, max supported layers) layers */ |
| void createLayers(hwc2_display_t display, |
| std::vector<hwc2_layer_t>* outLayers, size_t newLayerCnt) |
| { |
| std::vector<hwc2_layer_t> newLayers; |
| hwc2_layer_t layer; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| for (size_t i = 0; i < newLayerCnt; i++) { |
| |
| EXPECT_NO_FATAL_FAILURE(createLayer(display, &layer, &err)); |
| if (err == HWC2_ERROR_NO_RESOURCES) |
| break; |
| if (err != HWC2_ERROR_NONE) { |
| newLayers.clear(); |
| ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create layer"; |
| } |
| newLayers.push_back(layer); |
| } |
| |
| *outLayers = std::move(newLayers); |
| } |
| |
| void destroyLayers(hwc2_display_t display, |
| std::vector<hwc2_layer_t>&& layers) |
| { |
| for (hwc2_layer_t layer : layers) { |
| EXPECT_NO_FATAL_FAILURE(destroyLayer(display, layer)); |
| } |
| } |
| |
| void getInvalidConfig(hwc2_display_t display, hwc2_config_t* outConfig) |
| { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| hwc2_config_t CONFIG_MAX = UINT32_MAX; |
| |
| ASSERT_LE(configs.size() - 1, CONFIG_MAX) << "every config value" |
| " (2^32 values) has been taken which shouldn't happen"; |
| |
| hwc2_config_t config; |
| for (config = 0; config < CONFIG_MAX; config++) { |
| if (std::count(configs.begin(), configs.end(), config) == 0) |
| break; |
| } |
| |
| *outConfig = config; |
| } |
| |
| /* Calls a set property function from Hwc2Test to set a property value from |
| * Hwc2TestLayer to hwc2_layer_t on hwc2_display_t */ |
| using TestLayerPropertyFunction = void (*)(Hwc2Test* test, |
| hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr); |
| |
| /* Calls a set property function from Hwc2Test to set property values from |
| * Hwc2TestLayers to hwc2_layer_t on hwc2_display_t */ |
| using TestLayerPropertiesFunction = void (*)(Hwc2Test* test, |
| hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayers* testLayers); |
| |
| /* Calls a set property function from Hwc2Test to set a bad property value |
| * on hwc2_layer_t on hwc2_display_t */ |
| using TestLayerPropertyBadLayerFunction = void (*)(Hwc2Test* test, |
| hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr); |
| |
| /* Calls a set property function from Hwc2Test to set a bad property value |
| * on hwc2_layer_t on hwc2_display_t */ |
| using TestLayerPropertyBadParameterFunction = void (*)(Hwc2Test* test, |
| hwc2_display_t display, hwc2_layer_t layer, hwc2_error_t* outErr); |
| |
| /* Is called after a display is powered on and all layer properties have |
| * been set. It should be used to test functions such as validate, accepting |
| * changes, present, etc. */ |
| using TestDisplayLayersFunction = void (*)(Hwc2Test* test, |
| hwc2_display_t display, const std::vector<hwc2_layer_t>& layers, |
| Hwc2TestLayers* testLayers); |
| |
| /* It is called on an non validated display */ |
| using TestDisplayNonValidatedLayersFunction = void (*)(Hwc2Test* test, |
| hwc2_display_t display, std::vector<hwc2_layer_t>* layers); |
| |
| /* Tests client target support on a particular display and config */ |
| using TestClientTargetSupportFunction = void (*)(Hwc2Test* test, |
| hwc2_display_t display, |
| const Hwc2TestClientTargetSupport& testClientTargetSupport); |
| |
| /* Tests a particular active display config */ |
| using TestActiveDisplayConfigFunction = void (*)(Hwc2Test* test, |
| hwc2_display_t display); |
| |
| /* Tests a newly created virtual display */ |
| using TestCreateVirtualDisplayFunction = void (*)(Hwc2Test* test, |
| hwc2_display_t display, Hwc2TestVirtualDisplay* testVirtualDisplay); |
| |
| /* Advances a property of Hwc2TestLayer */ |
| using AdvanceProperty = bool (*)(Hwc2TestLayer* testLayer); |
| |
| /* Advances properties of Hwc2TestLayers */ |
| using AdvanceProperties = bool (*)(Hwc2TestLayers* testLayer); |
| |
| /* Advances properties of Hwc2TestClientTargetSupport */ |
| using AdvanceClientTargetSupport = bool (*)( |
| Hwc2TestClientTargetSupport* testClientTargetSupport); |
| |
| /* For each active display it cycles through each display config and tests |
| * each property value. It creates a layer, sets the property and then |
| * destroys the layer */ |
| void setLayerProperty(Hwc2TestCoverage coverage, |
| TestLayerPropertyFunction function, AdvanceProperty advance) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| hwc2_layer_t layer; |
| Area displayArea; |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, |
| &displayArea)); |
| Hwc2TestLayer testLayer(coverage, displayArea); |
| |
| do { |
| ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); |
| |
| ASSERT_NO_FATAL_FAILURE(function(this, display, layer, |
| &testLayer, nullptr)); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); |
| } while (advance(&testLayer)); |
| } |
| } |
| } |
| |
| /* For each active display it cycles through each display config and tests |
| * each property value. It creates a layer, cycles through each property |
| * value and updates the layer property value and then destroys the layer */ |
| void setLayerPropertyUpdate(Hwc2TestCoverage coverage, |
| TestLayerPropertyFunction function, AdvanceProperty advance) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| hwc2_layer_t layer; |
| Area displayArea; |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, |
| &displayArea)); |
| Hwc2TestLayer testLayer(coverage, displayArea); |
| |
| ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); |
| |
| do { |
| ASSERT_NO_FATAL_FAILURE(function(this, display, layer, |
| &testLayer, nullptr)); |
| } while (advance(&testLayer)); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); |
| } |
| } |
| } |
| |
| /* For each active display it cycles through each display config and tests |
| * each property value. It creates multiple layers, calls the |
| * TestLayerPropertiesFunction to set property values and then |
| * destroys the layers */ |
| void setLayerProperties(Hwc2TestCoverage coverage, size_t layerCnt, |
| TestLayerPropertiesFunction function, AdvanceProperties advance) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| std::vector<hwc2_layer_t> layers; |
| Area displayArea; |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, |
| &displayArea)); |
| |
| ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); |
| Hwc2TestLayers testLayers(layers, coverage, displayArea); |
| |
| do { |
| for (auto layer : layers) { |
| EXPECT_NO_FATAL_FAILURE(function(this, display, layer, |
| &testLayers)); |
| } |
| } while (advance(&testLayers)); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers))); |
| } |
| } |
| } |
| |
| /* For each active display it cycles through each display config. |
| * 1) It attempts to set a valid property value to bad layer handle. |
| * 2) It creates a layer x and attempts to set a valid property value to |
| * layer x + 1 |
| * 3) It destroys the layer x and attempts to set a valid property value to |
| * the destroyed layer x. |
| */ |
| void setLayerPropertyBadLayer(Hwc2TestCoverage coverage, |
| TestLayerPropertyBadLayerFunction function) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| hwc2_layer_t layer = 0; |
| Area displayArea; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, |
| &displayArea)); |
| Hwc2TestLayer testLayer(coverage, displayArea); |
| |
| ASSERT_NO_FATAL_FAILURE(function(this, display, layer, |
| &testLayer, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); |
| |
| ASSERT_NO_FATAL_FAILURE(function(this, display, layer + 1, |
| &testLayer, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); |
| |
| ASSERT_NO_FATAL_FAILURE(function(this, display, layer, |
| &testLayer, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; |
| } |
| } |
| } |
| |
| /* For each active display it cycles through each display config and tests |
| * each property value. It creates a layer, sets a bad property value and |
| * then destroys the layer */ |
| void setLayerPropertyBadParameter(TestLayerPropertyBadParameterFunction function) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| hwc2_layer_t layer; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| |
| ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); |
| |
| ASSERT_NO_FATAL_FAILURE(function(this, display, layer, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong" |
| " error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); |
| } |
| } |
| } |
| |
| /* For each active display it powers on the display, cycles through each |
| * config and creates a set of layers with a certain amount of coverage. |
| * For each active display, for each config and for each set of layers, |
| * it calls the TestDisplayLayersFunction */ |
| void displayLayers(Hwc2TestCoverage coverage, size_t layerCnt, |
| TestDisplayLayersFunction function) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| Area displayArea; |
| std::vector<hwc2_layer_t> layers; |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, &displayArea)); |
| |
| ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); |
| Hwc2TestLayers testLayers(layers, coverage, displayArea); |
| |
| do { |
| bool skip; |
| |
| ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers, |
| &testLayers, &skip)); |
| if (!skip) |
| EXPECT_NO_FATAL_FAILURE(function(this, display, layers, |
| &testLayers)); |
| |
| } while (testLayers.advance()); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayers(display, |
| std::move(layers))); |
| } |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| } |
| } |
| |
| /* For each active display, it calls the |
| * TestDisplayNonValidatedLayersFunction on a variety on non-validated |
| * layer combinations */ |
| void displayNonValidatedLayers(size_t layerCnt, |
| TestDisplayNonValidatedLayersFunction function) |
| { |
| for (auto display : mDisplays) { |
| uint32_t numTypes, numRequests; |
| std::vector<hwc2_layer_t> layers; |
| bool hasChanges; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| |
| EXPECT_NO_FATAL_FAILURE(function(this, display, &layers)); |
| |
| ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); |
| |
| EXPECT_NO_FATAL_FAILURE(function(this, display, &layers)); |
| |
| for (auto layer : layers) { |
| ASSERT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer, |
| HWC2_COMPOSITION_CLIENT)); |
| } |
| |
| EXPECT_NO_FATAL_FAILURE(function(this, display, &layers)); |
| |
| ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes, |
| &numRequests, &hasChanges)); |
| |
| for (auto layer : layers) { |
| ASSERT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer, |
| HWC2_COMPOSITION_DEVICE)); |
| } |
| |
| EXPECT_NO_FATAL_FAILURE(function(this, display, &layers)); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers))); |
| |
| EXPECT_NO_FATAL_FAILURE(function(this, display, &layers)); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| } |
| } |
| |
| /* Test client target support on each config on each active display */ |
| void setClientTargetSupport(Hwc2TestCoverage coverage, |
| TestClientTargetSupportFunction function, |
| AdvanceClientTargetSupport advance) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| Area displayArea; |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, |
| &displayArea)); |
| Hwc2TestClientTargetSupport testClientTargetSupport(coverage, |
| displayArea); |
| |
| do { |
| EXPECT_NO_FATAL_FAILURE(function(this, display, |
| testClientTargetSupport)); |
| |
| } while (advance(&testClientTargetSupport)); |
| } |
| } |
| } |
| |
| /* Cycles through each config on each active display and calls |
| * a TestActiveDisplayConfigFunction */ |
| void setActiveDisplayConfig(TestActiveDisplayConfigFunction function) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| |
| EXPECT_NO_FATAL_FAILURE(function(this, display)); |
| } |
| } |
| } |
| |
| /* Creates a virtual display for testing */ |
| void createVirtualDisplay(Hwc2TestCoverage coverage, |
| TestCreateVirtualDisplayFunction function) |
| { |
| Hwc2TestVirtualDisplay testVirtualDisplay(coverage); |
| |
| do { |
| hwc2_display_t display; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| const UnsignedArea& dimension = |
| testVirtualDisplay.getDisplayDimension(); |
| android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888; |
| |
| ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(dimension.width, |
| dimension.height, &desiredFormat, &display, &err)); |
| |
| EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_NO_RESOURCES |
| || err == HWC2_ERROR_UNSUPPORTED) |
| << "returned wrong error code"; |
| EXPECT_GE(desiredFormat, 0) << "invalid format"; |
| |
| if (err != HWC2_ERROR_NONE) |
| continue; |
| |
| EXPECT_NO_FATAL_FAILURE(function(this, display, |
| &testVirtualDisplay)); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display)); |
| |
| } while (testVirtualDisplay.advance()); |
| } |
| |
| |
| void getActiveConfigAttribute(hwc2_display_t display, |
| hwc2_attribute_t attribute, int32_t* outValue) |
| { |
| hwc2_config_t config; |
| ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &config)); |
| ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, |
| attribute, outValue)); |
| ASSERT_GE(*outValue, 0) << "failed to get valid " |
| << getAttributeName(attribute); |
| } |
| |
| void getActiveDisplayArea(hwc2_display_t display, Area* displayArea) |
| { |
| ASSERT_NO_FATAL_FAILURE(getActiveConfigAttribute(display, |
| HWC2_ATTRIBUTE_WIDTH, &displayArea->width)); |
| ASSERT_NO_FATAL_FAILURE(getActiveConfigAttribute(display, |
| HWC2_ATTRIBUTE_HEIGHT, &displayArea->height)); |
| } |
| |
| void closeFences(hwc2_display_t display, int32_t presentFence) |
| { |
| std::vector<hwc2_layer_t> layers; |
| std::vector<int32_t> fences; |
| const int msWait = 3000; |
| |
| if (presentFence >= 0) { |
| ASSERT_GE(sync_wait(presentFence, msWait), 0); |
| close(presentFence); |
| } |
| |
| ASSERT_NO_FATAL_FAILURE(getReleaseFences(display, &layers, &fences)); |
| EXPECT_EQ(layers.size(), fences.size()); |
| |
| for (int32_t fence : fences) { |
| if (fence >= 0) { |
| EXPECT_GE(sync_wait(fence, msWait), 0); |
| close(fence); |
| } |
| } |
| } |
| |
| void setLayerProperties(hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayers* testLayers, bool* outSkip) |
| { |
| hwc2_composition_t composition; |
| buffer_handle_t handle = nullptr; |
| int32_t acquireFence; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| *outSkip = true; |
| |
| if (!testLayers->contains(layer)) |
| return; |
| |
| composition = testLayers->getComposition(layer); |
| |
| /* If the device cannot support a buffer format, then do not continue */ |
| if ((composition == HWC2_COMPOSITION_DEVICE |
| || composition == HWC2_COMPOSITION_CURSOR) |
| && testLayers->getBuffer(layer, &handle, &acquireFence) < 0) |
| return; |
| |
| EXPECT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer, |
| composition, &err)); |
| if (err == HWC2_ERROR_UNSUPPORTED) |
| EXPECT_TRUE(composition != HWC2_COMPOSITION_CLIENT |
| && composition != HWC2_COMPOSITION_DEVICE); |
| |
| const hwc_rect_t cursor = testLayers->getCursorPosition(layer); |
| |
| EXPECT_NO_FATAL_FAILURE(setLayerBuffer(display, layer, handle, |
| acquireFence)); |
| EXPECT_NO_FATAL_FAILURE(setLayerBlendMode(display, layer, |
| testLayers->getBlendMode(layer))); |
| EXPECT_NO_FATAL_FAILURE(setLayerColor(display, layer, |
| testLayers->getColor(layer))); |
| if (composition == HWC2_COMPOSITION_CURSOR) |
| EXPECT_NO_FATAL_FAILURE(setCursorPosition(display, layer, |
| cursor.left, cursor.top)); |
| EXPECT_NO_FATAL_FAILURE(setLayerDataspace(display, layer, |
| testLayers->getDataspace(layer))); |
| EXPECT_NO_FATAL_FAILURE(setLayerDisplayFrame(display, layer, |
| testLayers->getDisplayFrame(layer))); |
| EXPECT_NO_FATAL_FAILURE(setLayerPlaneAlpha(display, layer, |
| testLayers->getPlaneAlpha(layer))); |
| EXPECT_NO_FATAL_FAILURE(setLayerSourceCrop(display, layer, |
| testLayers->getSourceCrop(layer))); |
| EXPECT_NO_FATAL_FAILURE(setLayerSurfaceDamage(display, layer, |
| testLayers->getSurfaceDamage(layer))); |
| EXPECT_NO_FATAL_FAILURE(setLayerTransform(display, layer, |
| testLayers->getTransform(layer))); |
| EXPECT_NO_FATAL_FAILURE(setLayerVisibleRegion(display, layer, |
| testLayers->getVisibleRegion(layer))); |
| EXPECT_NO_FATAL_FAILURE(setLayerZOrder(display, layer, |
| testLayers->getZOrder(layer))); |
| |
| *outSkip = false; |
| } |
| |
| void setLayerProperties(hwc2_display_t display, |
| const std::vector<hwc2_layer_t>& layers, |
| Hwc2TestLayers* testLayers, bool* outSkip) |
| { |
| for (auto layer : layers) { |
| EXPECT_NO_FATAL_FAILURE(setLayerProperties(display, layer, |
| testLayers, outSkip)); |
| if (*outSkip) |
| return; |
| } |
| } |
| |
| void setClientTarget(hwc2_display_t display, |
| Hwc2TestClientTarget* testClientTarget, |
| const Hwc2TestLayers& testLayers, |
| const std::set<hwc2_layer_t>& clientLayers, |
| const std::set<hwc2_layer_t>& clearLayers, bool flipClientTarget, |
| const Area& displayArea) |
| { |
| Dataspace dataspace = Dataspace::UNKNOWN; |
| hwc_region_t damage = { }; |
| buffer_handle_t handle; |
| int32_t acquireFence; |
| |
| ASSERT_EQ(testClientTarget->getBuffer(testLayers, clientLayers, |
| clearLayers, flipClientTarget, displayArea, &handle, |
| &acquireFence), 0); |
| EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle, acquireFence, |
| dataspace, damage)); |
| } |
| |
| void presentDisplays(size_t layerCnt, Hwc2TestCoverage coverage, |
| const std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage>& |
| coverageExceptions, bool optimize) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| ASSERT_NO_FATAL_FAILURE(enableVsync(display)); |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| Area displayArea; |
| std::vector<hwc2_layer_t> layers; |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, |
| &displayArea)); |
| |
| ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); |
| Hwc2TestLayers testLayers(layers, coverage, displayArea, |
| coverageExceptions); |
| |
| if (optimize && !testLayers.optimizeLayouts()) |
| continue; |
| |
| std::set<hwc2_layer_t> clientLayers; |
| std::set<hwc2_layer_t> clearLayers; |
| Hwc2TestClientTarget testClientTarget; |
| |
| do { |
| uint32_t numTypes, numRequests; |
| bool hasChanges, skip; |
| bool flipClientTarget; |
| int32_t presentFence; |
| |
| ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers, |
| &testLayers, &skip)); |
| if (skip) |
| continue; |
| |
| ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes, |
| &numRequests, &hasChanges)); |
| if (hasChanges) |
| EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size())) |
| << "wrong number of requests"; |
| |
| ASSERT_NO_FATAL_FAILURE(handleCompositionChanges(display, |
| testLayers, layers, numTypes, &clientLayers)); |
| ASSERT_NO_FATAL_FAILURE(handleRequests(display, layers, |
| numRequests, &clearLayers, &flipClientTarget)); |
| ASSERT_NO_FATAL_FAILURE(setClientTarget(display, |
| &testClientTarget, testLayers, clientLayers, |
| clearLayers, flipClientTarget, displayArea)); |
| ASSERT_NO_FATAL_FAILURE(acceptDisplayChanges(display)); |
| |
| ASSERT_NO_FATAL_FAILURE(waitForVsync()); |
| |
| EXPECT_NO_FATAL_FAILURE(presentDisplay(display, |
| &presentFence)); |
| |
| ASSERT_NO_FATAL_FAILURE(closeFences(display, presentFence)); |
| |
| } while (testLayers.advance()); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayers(display, |
| std::move(layers))); |
| } |
| |
| ASSERT_NO_FATAL_FAILURE(disableVsync(display)); |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| } |
| } |
| |
| void createAndPresentVirtualDisplay(size_t layerCnt, |
| Hwc2TestCoverage coverage, |
| const std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage>& |
| coverageExceptions) |
| { |
| Hwc2TestVirtualDisplay testVirtualDisplay(coverage); |
| hwc2_display_t display; |
| android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888; |
| |
| do { |
| // Items dependent on the display dimensions |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| const UnsignedArea& dimension = |
| testVirtualDisplay.getDisplayDimension(); |
| ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(dimension.width, |
| dimension.height, &desiredFormat, &display, &err)); |
| ASSERT_TRUE(err == HWC2_ERROR_NONE) |
| << "Cannot allocate virtual display"; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| ASSERT_NO_FATAL_FAILURE(enableVsync(display)); |
| |
| std::vector<hwc2_config_t> configs; |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| |
| Area displayArea; |
| ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, |
| &displayArea)); |
| |
| std::vector<hwc2_layer_t> layers; |
| ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, |
| layerCnt)); |
| Hwc2TestLayers testLayers(layers, coverage, displayArea, |
| coverageExceptions); |
| |
| /* |
| * Layouts that do not cover an entire virtual display will |
| * cause undefined behavior. |
| * Enable optimizeLayouts to avoid this. |
| */ |
| testLayers.optimizeLayouts(); |
| do { |
| // Items dependent on the testLayers properties |
| std::set<hwc2_layer_t> clientLayers; |
| std::set<hwc2_layer_t> clearLayers; |
| uint32_t numTypes, numRequests; |
| bool hasChanges, skip; |
| bool flipClientTarget; |
| int32_t presentFence; |
| Hwc2TestClientTarget testClientTarget; |
| buffer_handle_t outputBufferHandle; |
| android::base::unique_fd outputBufferReleaseFence; |
| |
| ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers, |
| &testLayers, &skip)); |
| |
| if (skip) |
| continue; |
| |
| ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes, |
| &numRequests, &hasChanges)); |
| |
| if (hasChanges) |
| EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size())) |
| << "wrong number of requests"; |
| |
| ASSERT_NO_FATAL_FAILURE(handleCompositionChanges(display, |
| testLayers, layers, numTypes, &clientLayers)); |
| |
| ASSERT_NO_FATAL_FAILURE(handleRequests(display, layers, |
| numRequests, &clearLayers, &flipClientTarget)); |
| ASSERT_NO_FATAL_FAILURE(setClientTarget(display, |
| &testClientTarget, testLayers, clientLayers, |
| clearLayers, flipClientTarget, displayArea)); |
| ASSERT_NO_FATAL_FAILURE(acceptDisplayChanges(display)); |
| |
| ASSERT_EQ(testVirtualDisplay.getOutputBuffer( |
| &outputBufferHandle, &outputBufferReleaseFence), 0); |
| ASSERT_NO_FATAL_FAILURE(setOutputBuffer(display, |
| outputBufferHandle, outputBufferReleaseFence)); |
| |
| EXPECT_NO_FATAL_FAILURE(presentDisplay(display, |
| &presentFence)); |
| ASSERT_NO_FATAL_FAILURE(closeFences(display, presentFence)); |
| |
| ASSERT_EQ(testVirtualDisplay.verifyOutputBuffer(&testLayers, |
| &layers, &clearLayers), 0); |
| |
| /* |
| * Upscaling the image causes minor pixel differences. |
| * Work around this by using some threshold. |
| * |
| * Fail test if we are off by more than 1% of our |
| * pixels. |
| */ |
| ComparatorResult& comparatorResult = ComparatorResult::get(); |
| int threshold = (dimension.width * dimension.height) / 100; |
| double diffPercent = (comparatorResult.getDifferentPixelCount() * 100.0) / |
| (dimension.width * dimension.height); |
| |
| if (comparatorResult.getDifferentPixelCount() != 0) |
| EXPECT_TRUE(false) |
| << comparatorResult.getDifferentPixelCount() << " pixels (" |
| << diffPercent << "%) are different."; |
| |
| if (comparatorResult.getDifferentPixelCount() > threshold) { |
| EXPECT_TRUE(false) |
| << "Mismatched pixel count exceeds threshold. " |
| << "Writing buffers to file."; |
| |
| const ::testing::TestInfo* const test_info = |
| ::testing::UnitTest::GetInstance() |
| ->current_test_info(); |
| |
| EXPECT_EQ(testVirtualDisplay.writeBuffersToFile( |
| test_info->name()), 0) |
| << "Failed to write buffers."; |
| } |
| |
| ASSERT_LE(comparatorResult.getDifferentPixelCount(), threshold) |
| << comparatorResult.getDifferentPixelCount() << " pixels (" |
| << diffPercent << "%) are different. " |
| << "Exceeds 1% threshold, terminating test. " |
| << "Test case: " << testLayers.dump(); |
| |
| } while (testLayers.advance()); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayers(display, |
| std::move(layers))); |
| } |
| ASSERT_NO_FATAL_FAILURE(disableVsync(display)); |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display)); |
| } while (testVirtualDisplay.advance()); |
| } |
| |
| hwc2_device_t* mHwc2Device = nullptr; |
| |
| enum class Hwc2TestHotplugStatus { |
| Init = 1, |
| Receiving, |
| Done, |
| }; |
| |
| std::mutex mHotplugMutex; |
| std::condition_variable mHotplugCv; |
| Hwc2TestHotplugStatus mHotplugStatus = Hwc2TestHotplugStatus::Init; |
| std::unordered_set<hwc2_display_t> mDisplays; |
| |
| /* Store all created layers that have not been destroyed. If an ASSERT_* |
| * fails, then destroy the layers on exit */ |
| std::set<std::pair<hwc2_display_t, hwc2_layer_t>> mLayers; |
| |
| /* Store the power mode state. If it is not HWC2_POWER_MODE_OFF when |
| * tearing down the test cases, change it to HWC2_POWER_MODE_OFF */ |
| std::set<hwc2_display_t> mActiveDisplays; |
| |
| /* Store all created virtual displays that have not been destroyed. If an |
| * ASSERT_* fails, then destroy the virtual displays on exit */ |
| std::set<hwc2_display_t> mVirtualDisplays; |
| |
| std::mutex mVsyncMutex; |
| std::condition_variable mVsyncCv; |
| hwc2_display_t mVsyncDisplay; |
| int64_t mVsyncTimestamp = -1; |
| }; |
| |
| void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, int32_t connection) |
| { |
| if (callbackData) |
| static_cast<Hwc2Test*>(callbackData)->hotplugCallback(display, |
| connection); |
| } |
| |
| void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, int64_t timestamp) |
| { |
| if (callbackData) |
| static_cast<Hwc2Test*>(callbackData)->vsyncCallback(display, |
| timestamp); |
| } |
| |
| void setBlendMode(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| EXPECT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer, |
| testLayer->getBlendMode(), outErr)); |
| } |
| |
| void setBuffer(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| buffer_handle_t handle; |
| android::base::unique_fd acquireFence; |
| hwc2_composition_t composition = testLayer->getComposition(); |
| |
| if (composition == HWC2_COMPOSITION_CLIENT |
| || composition == HWC2_COMPOSITION_SOLID_COLOR |
| || composition == HWC2_COMPOSITION_SIDEBAND) |
| return; |
| |
| if (testLayer->getBuffer(&handle, &acquireFence) < 0) |
| return; |
| |
| ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, layer, |
| composition)); |
| EXPECT_NO_FATAL_FAILURE(test->setLayerBuffer(display, layer, |
| handle, acquireFence, outErr)); |
| } |
| |
| void setColor(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, |
| layer, HWC2_COMPOSITION_SOLID_COLOR)); |
| ASSERT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display, |
| layer, testLayer->getPlaneAlpha())); |
| ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, |
| layer, testLayer->getBlendMode())); |
| EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer, |
| testLayer->getColor(), outErr)); |
| } |
| |
| void setComposition(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| hwc2_composition_t composition = testLayer->getComposition(); |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, layer, |
| composition, &err)); |
| if (outErr) { |
| *outErr = err; |
| return; |
| } |
| |
| if (composition != HWC2_COMPOSITION_SIDEBAND) { |
| EXPECT_EQ(err, HWC2_ERROR_NONE) << "returned wrong error code"; |
| } else { |
| EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_UNSUPPORTED) |
| << "returned wrong error code"; |
| } |
| } |
| |
| void setCursorPosition(Hwc2Test* test, hwc2_display_t display, |
| hwc2_layer_t layer, Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, |
| layer, HWC2_COMPOSITION_CURSOR)); |
| |
| const hwc_rect_t cursorPosition = testLayer->getCursorPosition(); |
| EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, layer, |
| cursorPosition.left, cursorPosition.top, outErr)); |
| } |
| |
| void setDataspace(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| EXPECT_NO_FATAL_FAILURE(test->setLayerDataspace(display, layer, |
| testLayer->getDataspace(), outErr)); |
| } |
| |
| void setDisplayFrame(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| EXPECT_NO_FATAL_FAILURE(test->setLayerDisplayFrame(display, layer, |
| testLayer->getDisplayFrame(), outErr)); |
| } |
| |
| void setPlaneAlpha(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t *outErr) |
| { |
| ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer, |
| testLayer->getBlendMode())); |
| EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display, layer, |
| testLayer->getPlaneAlpha(), outErr)); |
| } |
| |
| void setSourceCrop(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| EXPECT_NO_FATAL_FAILURE(test->setLayerSourceCrop(display, layer, |
| testLayer->getSourceCrop(), outErr)); |
| } |
| |
| void setSurfaceDamage(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| EXPECT_NO_FATAL_FAILURE(test->setLayerSurfaceDamage(display, layer, |
| testLayer->getSurfaceDamage(), outErr)); |
| } |
| |
| void setTransform(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| EXPECT_NO_FATAL_FAILURE(test->setLayerTransform(display, layer, |
| testLayer->getTransform(), outErr)); |
| } |
| |
| void setVisibleRegion(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| EXPECT_NO_FATAL_FAILURE(test->setLayerVisibleRegion(display, layer, |
| testLayer->getVisibleRegion(), outErr)); |
| } |
| |
| void setZOrder(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) |
| { |
| EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer, |
| testLayer->getZOrder(), outErr)); |
| } |
| |
| bool advanceBlendMode(Hwc2TestLayer* testLayer) |
| { |
| return testLayer->advanceBlendMode(); |
| } |
| |
| bool advanceBuffer(Hwc2TestLayer* testLayer) |
| { |
| if (testLayer->advanceComposition()) |
| return true; |
| return testLayer->advanceBufferArea(); |
| } |
| |
| bool advanceColor(Hwc2TestLayer* testLayer) |
| { |
| /* Color depends on blend mode so advance blend mode last so color is not |
| * force to update as often */ |
| if (testLayer->advancePlaneAlpha()) |
| return true; |
| if (testLayer->advanceColor()) |
| return true; |
| return testLayer->advanceBlendMode(); |
| } |
| |
| bool advanceComposition(Hwc2TestLayer* testLayer) |
| { |
| return testLayer->advanceComposition(); |
| } |
| |
| bool advanceCursorPosition(Hwc2TestLayer* testLayer) |
| { |
| return testLayer->advanceCursorPosition(); |
| } |
| |
| bool advanceDataspace(Hwc2TestLayer* testLayer) |
| { |
| return testLayer->advanceDataspace(); |
| } |
| |
| bool advanceDisplayFrame(Hwc2TestLayer* testLayer) |
| { |
| return testLayer->advanceDisplayFrame(); |
| } |
| |
| bool advancePlaneAlpha(Hwc2TestLayer* testLayer) |
| { |
| return testLayer->advancePlaneAlpha(); |
| } |
| |
| bool advanceSourceCrop(Hwc2TestLayer* testLayer) |
| { |
| if (testLayer->advanceSourceCrop()) |
| return true; |
| return testLayer->advanceBufferArea(); |
| } |
| |
| bool advanceSurfaceDamage(Hwc2TestLayer* testLayer) |
| { |
| if (testLayer->advanceSurfaceDamage()) |
| return true; |
| return testLayer->advanceBufferArea(); |
| } |
| |
| bool advanceTransform(Hwc2TestLayer* testLayer) |
| { |
| return testLayer->advanceTransform(); |
| } |
| |
| bool advanceVisibleRegions(Hwc2TestLayers* testLayers) |
| { |
| return testLayers->advanceVisibleRegions(); |
| } |
| |
| bool advanceClientTargetSupport( |
| Hwc2TestClientTargetSupport* testClientTargetSupport) |
| { |
| return testClientTargetSupport->advance(); |
| } |
| |
| static const std::array<hwc2_function_descriptor_t, 42> requiredFunctions = {{ |
| HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES, |
| HWC2_FUNCTION_CREATE_LAYER, |
| HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY, |
| HWC2_FUNCTION_DESTROY_LAYER, |
| HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY, |
| HWC2_FUNCTION_DUMP, |
| HWC2_FUNCTION_GET_ACTIVE_CONFIG, |
| HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES, |
| HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT, |
| HWC2_FUNCTION_GET_COLOR_MODES, |
| HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE, |
| HWC2_FUNCTION_GET_DISPLAY_CONFIGS, |
| HWC2_FUNCTION_GET_DISPLAY_NAME, |
| HWC2_FUNCTION_GET_DISPLAY_REQUESTS, |
| HWC2_FUNCTION_GET_DISPLAY_TYPE, |
| HWC2_FUNCTION_GET_DOZE_SUPPORT, |
| HWC2_FUNCTION_GET_HDR_CAPABILITIES, |
| HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT, |
| HWC2_FUNCTION_GET_RELEASE_FENCES, |
| HWC2_FUNCTION_PRESENT_DISPLAY, |
| HWC2_FUNCTION_REGISTER_CALLBACK, |
| HWC2_FUNCTION_SET_ACTIVE_CONFIG, |
| HWC2_FUNCTION_SET_CLIENT_TARGET, |
| HWC2_FUNCTION_SET_COLOR_MODE, |
| HWC2_FUNCTION_SET_COLOR_TRANSFORM, |
| HWC2_FUNCTION_SET_CURSOR_POSITION, |
| HWC2_FUNCTION_SET_LAYER_BLEND_MODE, |
| HWC2_FUNCTION_SET_LAYER_BUFFER, |
| HWC2_FUNCTION_SET_LAYER_COLOR, |
| HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE, |
| HWC2_FUNCTION_SET_LAYER_DATASPACE, |
| HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME, |
| HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA, |
| HWC2_FUNCTION_SET_LAYER_SOURCE_CROP, |
| HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE, |
| HWC2_FUNCTION_SET_LAYER_TRANSFORM, |
| HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION, |
| HWC2_FUNCTION_SET_LAYER_Z_ORDER, |
| HWC2_FUNCTION_SET_OUTPUT_BUFFER, |
| HWC2_FUNCTION_SET_POWER_MODE, |
| HWC2_FUNCTION_SET_VSYNC_ENABLED, |
| HWC2_FUNCTION_VALIDATE_DISPLAY, |
| }}; |
| |
| /* TESTCASE: Tests that the HWC2 supports all required functions. */ |
| TEST_F(Hwc2Test, GET_FUNCTION) |
| { |
| for (hwc2_function_descriptor_t descriptor : requiredFunctions) { |
| hwc2_function_pointer_t pfn = getFunction(descriptor); |
| EXPECT_TRUE(pfn) << "failed to get function " |
| << getFunctionDescriptorName(descriptor); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 fails to retrieve and invalid function. */ |
| TEST_F(Hwc2Test, GET_FUNCTION_invalid_function) |
| { |
| hwc2_function_pointer_t pfn = getFunction(HWC2_FUNCTION_INVALID); |
| EXPECT_FALSE(pfn) << "failed to get invalid function"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 does not return an invalid capability. */ |
| TEST_F(Hwc2Test, GET_CAPABILITIES) |
| { |
| std::vector<hwc2_capability_t> capabilities; |
| |
| getCapabilities(&capabilities); |
| |
| EXPECT_EQ(std::count(capabilities.begin(), capabilities.end(), |
| HWC2_CAPABILITY_INVALID), 0); |
| } |
| |
| static const std::array<hwc2_callback_descriptor_t, 3> callbackDescriptors = {{ |
| HWC2_CALLBACK_HOTPLUG, |
| HWC2_CALLBACK_REFRESH, |
| HWC2_CALLBACK_VSYNC, |
| }}; |
| |
| /* TESTCASE: Tests that the HWC2 can successfully register all required |
| * callback functions. */ |
| TEST_F(Hwc2Test, REGISTER_CALLBACK) |
| { |
| hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( |
| const_cast<char*>("data")); |
| |
| for (auto descriptor : callbackDescriptors) { |
| ASSERT_NO_FATAL_FAILURE(registerCallback(descriptor, data, |
| []() { return; })); |
| } |
| } |
| |
| /* TESTCASE: Test that the HWC2 fails to register invalid callbacks. */ |
| TEST_F(Hwc2Test, REGISTER_CALLBACK_bad_parameter) |
| { |
| hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( |
| const_cast<char*>("data")); |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_INVALID, data, |
| []() { return; }, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can register a callback with null data. */ |
| TEST_F(Hwc2Test, REGISTER_CALLBACK_null_data) |
| { |
| hwc2_callback_data_t data = nullptr; |
| |
| for (auto descriptor : callbackDescriptors) { |
| ASSERT_NO_FATAL_FAILURE(registerCallback(descriptor, data, |
| []() { return; })); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 returns the correct display type for each |
| * physical display. */ |
| TEST_F(Hwc2Test, GET_DISPLAY_TYPE) |
| { |
| for (auto display : mDisplays) { |
| hwc2_display_type_t type; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayType(display, &type)); |
| EXPECT_EQ(type, HWC2_DISPLAY_TYPE_PHYSICAL) << "failed to return" |
| " correct display type"; |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 returns an error when the display type of a bad |
| * display is requested. */ |
| TEST_F(Hwc2Test, GET_DISPLAY_TYPE_bad_display) |
| { |
| hwc2_display_t display; |
| hwc2_display_type_t type; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayType(display, &type, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can create and destroy layers. */ |
| TEST_F(Hwc2Test, CREATE_DESTROY_LAYER) |
| { |
| for (auto display : mDisplays) { |
| hwc2_layer_t layer; |
| |
| ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot create a layer for a bad display */ |
| TEST_F(Hwc2Test, CREATE_LAYER_bad_display) |
| { |
| hwc2_display_t display; |
| hwc2_layer_t layer; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 will either support a large number of resources |
| * or will return no resources. */ |
| TEST_F(Hwc2Test, CREATE_LAYER_no_resources) |
| { |
| const size_t layerCnt = 1000; |
| |
| for (auto display : mDisplays) { |
| std::vector<hwc2_layer_t> layers; |
| |
| ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers))); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot destroy a layer for a bad display */ |
| TEST_F(Hwc2Test, DESTROY_LAYER_bad_display) |
| { |
| hwc2_display_t badDisplay; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&badDisplay)); |
| |
| for (auto display : mDisplays) { |
| hwc2_layer_t layer = 0; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(badDisplay, layer, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(badDisplay, layer, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot destory a bad layer */ |
| TEST_F(Hwc2Test, DESTROY_LAYER_bad_layer) |
| { |
| for (auto display : mDisplays) { |
| hwc2_layer_t layer; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX / 2, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, 0, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX - 1, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, 1, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer + 1, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code"; |
| } |
| } |
| |
| static const std::array<hwc2_attribute_t, 2> requiredAttributes = {{ |
| HWC2_ATTRIBUTE_WIDTH, |
| HWC2_ATTRIBUTE_HEIGHT, |
| }}; |
| |
| static const std::array<hwc2_attribute_t, 3> optionalAttributes = {{ |
| HWC2_ATTRIBUTE_VSYNC_PERIOD, |
| HWC2_ATTRIBUTE_DPI_X, |
| HWC2_ATTRIBUTE_DPI_Y, |
| }}; |
| |
| /* TESTCASE: Tests that the HWC2 can return display attributes for a valid |
| * config. */ |
| TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| int32_t value; |
| |
| for (auto attribute : requiredAttributes) { |
| ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, |
| attribute, &value)); |
| EXPECT_GE(value, 0) << "missing required attribute " |
| << getAttributeName(attribute) << " for config " |
| << config; |
| } |
| for (auto attribute : optionalAttributes) { |
| ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, |
| attribute, &value)); |
| } |
| } |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 will return a value of -1 for an invalid |
| * attribute */ |
| TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_invalid_attribute) |
| { |
| const hwc2_attribute_t attribute = HWC2_ATTRIBUTE_INVALID; |
| |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| int32_t value; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, |
| attribute, &value, &err)); |
| EXPECT_EQ(value, -1) << "failed to return -1 for an invalid" |
| " attribute for config " << config; |
| } |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 will fail to get attributes for a bad display */ |
| TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_bad_display) |
| { |
| hwc2_display_t display; |
| const hwc2_config_t config = 0; |
| int32_t value; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| for (auto attribute : requiredAttributes) { |
| ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, attribute, |
| &value, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| for (auto attribute : optionalAttributes) { |
| ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, attribute, |
| &value, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 will fail to get attributes for a bad config */ |
| TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_bad_config) |
| { |
| for (auto display : mDisplays) { |
| hwc2_config_t config; |
| int32_t value; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getInvalidConfig(display, &config)); |
| |
| for (auto attribute : requiredAttributes) { |
| ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, |
| attribute, &value, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code"; |
| } |
| |
| for (auto attribute : optionalAttributes) { |
| ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, |
| attribute, &value, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code"; |
| } |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 will get display configs for active displays */ |
| TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 will not get display configs for bad displays */ |
| TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_bad_display) |
| { |
| hwc2_display_t display; |
| std::vector<hwc2_config_t> configs; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs, &err)); |
| |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| EXPECT_TRUE(configs.empty()) << "returned configs for bad display"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 will return the same config list multiple |
| * times in a row. */ |
| TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_same) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs1, configs2; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs1)); |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs2)); |
| |
| EXPECT_TRUE(std::is_permutation(configs1.begin(), configs1.end(), |
| configs2.begin())) << "returned two different config sets"; |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 does not return duplicate display configs */ |
| TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_duplicate) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| std::unordered_set<hwc2_config_t> configsSet(configs.begin(), |
| configs.end()); |
| EXPECT_EQ(configs.size(), configsSet.size()) << "returned duplicate" |
| " configs"; |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 returns the active config for a display */ |
| TEST_F(Hwc2Test, GET_ACTIVE_CONFIG) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| hwc2_config_t activeConfig; |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig)); |
| |
| EXPECT_EQ(activeConfig, config) << "failed to get active config"; |
| } |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 does not return an active config for a bad |
| * display. */ |
| TEST_F(Hwc2Test, GET_ACTIVE_CONFIG_bad_display) |
| { |
| hwc2_display_t display; |
| hwc2_config_t activeConfig; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig, &err)); |
| |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 either begins with a valid active config |
| * or returns an error when getActiveConfig is called. */ |
| TEST_F(Hwc2Test, GET_ACTIVE_CONFIG_bad_config) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| hwc2_config_t activeConfig; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| if (configs.empty()) |
| return; |
| |
| ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig, &err)); |
| if (err == HWC2_ERROR_NONE) { |
| EXPECT_NE(std::count(configs.begin(), configs.end(), |
| activeConfig), 0) << "active config is not found in " |
| " configs for display"; |
| } else { |
| EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code"; |
| } |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set every display config as an active |
| * config */ |
| TEST_F(Hwc2Test, SET_ACTIVE_CONFIG) |
| { |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| EXPECT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| } |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set an active config for a bad display */ |
| TEST_F(Hwc2Test, SET_ACTIVE_CONFIG_bad_display) |
| { |
| hwc2_display_t display; |
| const hwc2_config_t config = 0; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set an invalid active config */ |
| TEST_F(Hwc2Test, SET_ACTIVE_CONFIG_bad_config) |
| { |
| for (auto display : mDisplays) { |
| hwc2_config_t config; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getInvalidConfig(display, &config)); |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code"; |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 returns a valid value for getDozeSupport. */ |
| TEST_F(Hwc2Test, GET_DOZE_SUPPORT) |
| { |
| for (auto display : mDisplays) { |
| int32_t support = -1; |
| |
| ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support)); |
| |
| EXPECT_TRUE(support == 0 || support == 1) << "invalid doze support value"; |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot get doze support for a bad display. */ |
| TEST_F(Hwc2Test, GET_DOZE_SUPPORT_bad_display) |
| { |
| hwc2_display_t display; |
| int32_t support = -1; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err)); |
| |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set all supported power modes */ |
| TEST_F(Hwc2Test, SET_POWER_MODE) |
| { |
| for (auto display : mDisplays) { |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| |
| int32_t support = -1; |
| ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support)); |
| if (support != 1) |
| return; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE)); |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, |
| HWC2_POWER_MODE_DOZE_SUSPEND)); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set a power mode for a bad display. */ |
| TEST_F(Hwc2Test, SET_POWER_MODE_bad_display) |
| { |
| hwc2_display_t display; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| |
| int32_t support = -1; |
| ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err)); |
| if (support != 1) |
| return; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE_SUSPEND, |
| &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set an invalid power mode value. */ |
| TEST_F(Hwc2Test, SET_POWER_MODE_bad_parameter) |
| { |
| for (auto display : mDisplays) { |
| hwc2_power_mode_t mode = static_cast<hwc2_power_mode_t>( |
| HWC2_POWER_MODE_DOZE_SUSPEND + 1); |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, mode, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code " |
| << mode; |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 will return unsupported if it does not support |
| * an optional power mode. */ |
| TEST_F(Hwc2Test, SET_POWER_MODE_unsupported) |
| { |
| for (auto display : mDisplays) { |
| int32_t support = -1; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err)); |
| if (support == 1) |
| return; |
| |
| ASSERT_EQ(support, 0) << "invalid doze support value"; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE, |
| &err)); |
| EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, |
| HWC2_POWER_MODE_DOZE_SUSPEND, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code"; |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the same power mode multiple times. */ |
| TEST_F(Hwc2Test, SET_POWER_MODE_stress) |
| { |
| for (auto display : mDisplays) { |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| |
| int32_t support = -1; |
| ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support)); |
| if (support != 1) |
| return; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE)); |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE)); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, |
| HWC2_POWER_MODE_DOZE_SUSPEND)); |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, |
| HWC2_POWER_MODE_DOZE_SUSPEND)); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can enable and disable vsync on active |
| * displays */ |
| TEST_F(Hwc2Test, SET_VSYNC_ENABLED) |
| { |
| for (auto display : mDisplays) { |
| hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( |
| const_cast<char*>("data")); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| |
| ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data, |
| []() { return; })); |
| |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); |
| |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 issues a valid vsync callback. */ |
| TEST_F(Hwc2Test, SET_VSYNC_ENABLED_callback) |
| { |
| for (auto display : mDisplays) { |
| hwc2_display_t receivedDisplay; |
| int64_t receivedTimestamp; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| |
| ASSERT_NO_FATAL_FAILURE(enableVsync(display)); |
| |
| ASSERT_NO_FATAL_FAILURE(waitForVsync(&receivedDisplay, |
| &receivedTimestamp)); |
| |
| EXPECT_EQ(receivedDisplay, display) << "failed to get correct display"; |
| EXPECT_GE(receivedTimestamp, 0) << "failed to get valid timestamp"; |
| |
| ASSERT_NO_FATAL_FAILURE(disableVsync(display)); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot enable a vsync for a bad display */ |
| TEST_F(Hwc2Test, SET_VSYNC_ENABLED_bad_display) |
| { |
| hwc2_display_t display; |
| hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( |
| const_cast<char*>("data")); |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data, |
| []() { return; })); |
| |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot enable an invalid vsync value */ |
| TEST_F(Hwc2Test, SET_VSYNC_ENABLED_bad_parameter) |
| { |
| for (auto display : mDisplays) { |
| hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( |
| const_cast<char*>("data")); |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| |
| ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data, |
| []() { return; })); |
| |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_INVALID, |
| &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can enable and disable a vsync value multiple |
| * times. */ |
| TEST_F(Hwc2Test, SET_VSYNC_ENABLED_stress) |
| { |
| for (auto display : mDisplays) { |
| hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>( |
| const_cast<char*>("data")); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| |
| ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data, |
| []() { return; })); |
| |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); |
| |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); |
| |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set a vsync enable value when the display |
| * is off and no callback is registered. */ |
| TEST_F(Hwc2Test, SET_VSYNC_ENABLED_no_callback_no_power) |
| { |
| const uint secs = 1; |
| |
| for (auto display : mDisplays) { |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); |
| |
| sleep(secs); |
| |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set a vsync enable value when no callback |
| * is registered. */ |
| TEST_F(Hwc2Test, SET_VSYNC_ENABLED_no_callback) |
| { |
| const uint secs = 1; |
| |
| for (auto display : mDisplays) { |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE)); |
| |
| sleep(secs); |
| |
| ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE)); |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 returns a display name for each display */ |
| TEST_F(Hwc2Test, GET_DISPLAY_NAME) |
| { |
| for (auto display : mDisplays) { |
| std::string name; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayName(display, &name)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 does not return a display name for a bad |
| * display */ |
| TEST_F(Hwc2Test, GET_DISPLAY_NAME_bad_display) |
| { |
| hwc2_display_t display; |
| std::string name; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayName(display, &name, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set basic composition types. */ |
| TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| setComposition, advanceComposition)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update a basic composition type on a |
| * layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_update) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, |
| setComposition, advanceComposition)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set a composition type for a bad layer */ |
| TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| setComposition)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set a bad composition type */ |
| TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_bad_parameter) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter( |
| [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| hwc2_error_t* outErr) { |
| |
| ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, |
| layer, HWC2_COMPOSITION_INVALID, outErr)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the cursor position of a layer. */ |
| TEST_F(Hwc2Test, SET_CURSOR_POSITION) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| ::setCursorPosition, advanceCursorPosition)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update the cursor position of a layer. */ |
| TEST_F(Hwc2Test, SET_CURSOR_POSITION_update) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, |
| ::setCursorPosition, advanceCursorPosition)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the cursor position of a layer when the |
| * composition type has not been set to HWC2_COMPOSITION_CURSOR. */ |
| TEST_F(Hwc2Test, SET_CURSOR_POSITION_composition_type_unset) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) { |
| const hwc_rect_t cursorPosition = testLayer->getCursorPosition(); |
| EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, layer, |
| cursorPosition.left, cursorPosition.top, outErr)); |
| }, |
| |
| advanceCursorPosition)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set the cursor position of a bad |
| * display. */ |
| TEST_F(Hwc2Test, SET_CURSOR_POSITION_bad_display) |
| { |
| hwc2_display_t display; |
| hwc2_layer_t layer = 0; |
| int32_t x = 0, y = 0; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(setCursorPosition(display, layer, x, y, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set the cursor position of a bad layer. */ |
| TEST_F(Hwc2Test, SET_CURSOR_POSITION_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) { |
| |
| const hwc_rect_t cursorPosition = testLayer->getCursorPosition(); |
| EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, |
| badLayer, cursorPosition.left, cursorPosition.top, |
| outErr)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set a blend mode value of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| setBlendMode, advanceBlendMode)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update a blend mode value of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_update) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, |
| setBlendMode, advanceBlendMode)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set a blend mode for a bad layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| setBlendMode)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set an invalid blend mode. */ |
| TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_parameter) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter( |
| [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| hwc2_error_t* outErr) { |
| |
| ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, |
| layer, HWC2_BLEND_MODE_INVALID, outErr)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the buffer of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_BUFFER) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| setBuffer, advanceBuffer)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update the buffer of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_BUFFER_update) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, |
| setBuffer, advanceBuffer)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set the buffer of a bad layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_BUFFER_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) { |
| |
| buffer_handle_t handle = nullptr; |
| android::base::unique_fd acquireFence; |
| |
| /* If there is not available buffer for the given buffer |
| * properties, it should not fail this test case */ |
| if (testLayer->getBuffer(&handle, &acquireFence) == 0) { |
| *outErr = HWC2_ERROR_BAD_LAYER; |
| return; |
| } |
| |
| ASSERT_NO_FATAL_FAILURE(test->setLayerBuffer(display, badLayer, |
| handle, acquireFence, outErr)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set an invalid buffer for a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_BUFFER_bad_parameter) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter( |
| [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| hwc2_error_t* outErr) { |
| |
| buffer_handle_t handle = nullptr; |
| int32_t acquireFence = -1; |
| |
| ASSERT_NO_FATAL_FAILURE(test->setLayerBuffer(display, layer, |
| handle, acquireFence, outErr)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the color of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_COLOR) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| setColor, advanceColor)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update the color of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_COLOR_update) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, |
| setColor, advanceColor)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the color of a layer when the |
| * composition type has not been set to HWC2_COMPOSITION_SOLID_COLOR. */ |
| TEST_F(Hwc2Test, SET_LAYER_COLOR_composition_type_unset) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Basic, |
| [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) { |
| |
| EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer, |
| testLayer->getColor(), outErr)); |
| }, |
| |
| advanceColor)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set the color of a bad layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_COLOR_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer, |
| Hwc2TestLayer* testLayer, hwc2_error_t* outErr) { |
| |
| EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, badLayer, |
| testLayer->getColor(), outErr)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the dataspace of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_DATASPACE) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| setDataspace, advanceDataspace)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update the dataspace of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_DATASPACE_update) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, |
| setDataspace, advanceDataspace)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set a dataspace for a bad layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_DATASPACE_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| setDataspace)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the display frame of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| setDisplayFrame, advanceDisplayFrame)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update the display frame of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME_update) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, |
| setDisplayFrame, advanceDisplayFrame)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set the display frame of a bad layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| setDisplayFrame)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the plane alpha of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| setPlaneAlpha, advancePlaneAlpha)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update the plane alpha of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA_update) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, |
| setPlaneAlpha, advancePlaneAlpha)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set a plane alpha for a bad layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer, |
| Hwc2TestLayer* testLayer, hwc2_error_t *outErr) { |
| |
| EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display, |
| badLayer, testLayer->getPlaneAlpha(), outErr)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the source crop of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| setSourceCrop, advanceSourceCrop)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update the source crop of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP_update) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, |
| setSourceCrop, advanceSourceCrop)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set the source crop of a bad layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| setSourceCrop)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the surface damage of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| setSurfaceDamage, advanceSurfaceDamage)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update the surface damage of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE_update) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, |
| setSurfaceDamage, advanceSurfaceDamage)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set the surface damage of a bad layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| setSurfaceDamage)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the transform value of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_TRANSFORM) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete, |
| setTransform, advanceTransform)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update the transform value of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_TRANSFORM_update) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete, |
| setTransform, advanceTransform)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set the transform for a bad layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_TRANSFORM_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| setTransform)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the visible region of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_VISIBLE_REGION) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperties(Hwc2TestCoverage::Basic, 5, |
| [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayers* testLayers) { |
| |
| EXPECT_NO_FATAL_FAILURE(test->setLayerVisibleRegion(display, |
| layer, testLayers->getVisibleRegion(layer))); |
| }, |
| |
| advanceVisibleRegions)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set the visible region of a bad layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_VISIBLE_REGION_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| setVisibleRegion)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the z order of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_Z_ORDER) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerProperties(Hwc2TestCoverage::Complete, 10, |
| [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, |
| Hwc2TestLayers* testLayers) { |
| |
| EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer, |
| testLayers->getZOrder(layer))); |
| }, |
| |
| /* TestLayer z orders are set during the construction of TestLayers |
| * and cannot be updated. There is no need (or ability) to cycle |
| * through additional z order configurations. */ |
| [] (Hwc2TestLayers* /*testLayers*/) { |
| return false; |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can update the z order of a layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_Z_ORDER_update) |
| { |
| const std::vector<uint32_t> zOrders = { static_cast<uint32_t>(0), |
| static_cast<uint32_t>(1), static_cast<uint32_t>(UINT32_MAX / 4), |
| static_cast<uint32_t>(UINT32_MAX / 2), |
| static_cast<uint32_t>(UINT32_MAX) }; |
| |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| hwc2_layer_t layer; |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| |
| ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer)); |
| |
| for (uint32_t zOrder : zOrders) { |
| EXPECT_NO_FATAL_FAILURE(setLayerZOrder(display, layer, zOrder)); |
| } |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer)); |
| } |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set the z order of a bad layer. */ |
| TEST_F(Hwc2Test, SET_LAYER_Z_ORDER_bad_layer) |
| { |
| ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default, |
| setZOrder)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can display a layer with basic property |
| * coverage */ |
| TEST_F(Hwc2Test, VALIDATE_DISPLAY_basic) |
| { |
| ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| const std::vector<hwc2_layer_t>& layers, |
| Hwc2TestLayers* /*testLayers*/) { |
| |
| uint32_t numTypes, numRequests; |
| bool hasChanges = false; |
| |
| EXPECT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes, |
| &numRequests, &hasChanges)); |
| if (hasChanges) |
| EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size())) |
| << "wrong number of requests"; |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can display 5 layers with default coverage. */ |
| TEST_F(Hwc2Test, VALIDATE_DISPLAY_default_5) |
| { |
| ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Default, 5, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| const std::vector<hwc2_layer_t>& layers, |
| Hwc2TestLayers* /*testLayers*/) { |
| |
| uint32_t numTypes, numRequests; |
| bool hasChanges = false; |
| |
| EXPECT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes, |
| &numRequests, &hasChanges)); |
| if (hasChanges) |
| EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size())) |
| << "wrong number of requests"; |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot validate a bad display */ |
| TEST_F(Hwc2Test, VALIDATE_DISPLAY_bad_display) |
| { |
| hwc2_display_t display; |
| uint32_t numTypes, numRequests; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes, &numRequests, |
| &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can get display requests after validating a |
| * basic layer. */ |
| TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_basic) |
| { |
| ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| const std::vector<hwc2_layer_t>& layers, |
| Hwc2TestLayers* /*testLayers*/) { |
| |
| uint32_t numTypes, numRequests; |
| bool hasChanges = false; |
| |
| ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes, |
| &numRequests, &hasChanges)); |
| if (hasChanges) |
| EXPECT_LE(numTypes, layers.size()) |
| << "wrong number of requests"; |
| |
| EXPECT_NO_FATAL_FAILURE(test->handleRequests(display, layers, |
| numRequests)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot get display requests from a bad display */ |
| TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_bad_display) |
| { |
| hwc2_display_t display; |
| hwc2_display_request_t displayRequests; |
| std::vector<hwc2_layer_t> layers; |
| std::vector<hwc2_layer_request_t> layerRequests; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| EXPECT_NO_FATAL_FAILURE(getDisplayRequests(display, &displayRequests, |
| &layers, &layerRequests, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot get display requests from an non |
| * validated display. */ |
| TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_not_validated) |
| { |
| ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| std::vector<hwc2_layer_t>* layers) { |
| |
| hwc2_display_request_t displayRequests; |
| std::vector<hwc2_layer_request_t> layerRequests; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->getDisplayRequests(display, |
| &displayRequests, layers, &layerRequests, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED) |
| << "returned wrong error code"; |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can get changed composition types after |
| * validating a basic layer. */ |
| TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_basic) |
| { |
| ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| const std::vector<hwc2_layer_t>& layers, |
| Hwc2TestLayers* testLayers) { |
| |
| uint32_t numTypes, numRequests; |
| bool hasChanges = false; |
| |
| ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes, |
| &numRequests, &hasChanges)); |
| if (hasChanges) |
| EXPECT_LE(numTypes, layers.size()) |
| << "wrong number of requests"; |
| |
| EXPECT_NO_FATAL_FAILURE(test->handleCompositionChanges(display, |
| *testLayers, layers, numTypes)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot get changed composition types from a bad |
| * display */ |
| TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_bad_display) |
| { |
| hwc2_display_t display; |
| std::vector<hwc2_layer_t> layers; |
| std::vector<hwc2_composition_t> types; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| EXPECT_NO_FATAL_FAILURE(getChangedCompositionTypes(display, &layers, |
| &types, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot get changed composition types from an non |
| * validated display. */ |
| TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_not_validated) |
| { |
| ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| std::vector<hwc2_layer_t>* layers) { |
| |
| std::vector<hwc2_composition_t> types; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->getChangedCompositionTypes( |
| display, layers, &types, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED) |
| << "returned wrong error code"; |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can accept display changes after validating a |
| * basic layer. */ |
| TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_basic) |
| { |
| ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| const std::vector<hwc2_layer_t>& layers, |
| Hwc2TestLayers* testLayers) { |
| |
| uint32_t numTypes, numRequests; |
| bool hasChanges = false; |
| |
| ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes, |
| &numRequests, &hasChanges)); |
| if (hasChanges) |
| EXPECT_LE(numTypes, layers.size()) |
| << "wrong number of requests"; |
| |
| ASSERT_NO_FATAL_FAILURE(test->handleCompositionChanges(display, |
| *testLayers, layers, numTypes)); |
| |
| EXPECT_NO_FATAL_FAILURE(test->acceptDisplayChanges(display)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot accept display changes from a bad |
| * display */ |
| TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_bad_display) |
| { |
| hwc2_display_t display; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| EXPECT_NO_FATAL_FAILURE(acceptDisplayChanges(display, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot accept display changes from an non |
| * validated display. */ |
| TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_not_validated) |
| { |
| ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| std::vector<hwc2_layer_t>* /*layers*/) { |
| |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->acceptDisplayChanges(display, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED) |
| << "returned wrong error code"; |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 supports client target with required values */ |
| TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT) |
| { |
| ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Default, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| const Hwc2TestClientTargetSupport& testClientTargetSupport) { |
| |
| const Area bufferArea = testClientTargetSupport.getBufferArea(); |
| const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888; |
| |
| ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(display, |
| bufferArea.width, bufferArea.height, format, |
| testClientTargetSupport.getDataspace())); |
| }, |
| |
| advanceClientTargetSupport)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot get client target support for a bad |
| * display. */ |
| TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT_bad_display) |
| { |
| ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Default, |
| [] (Hwc2Test* test, hwc2_display_t /*display*/, |
| const Hwc2TestClientTargetSupport& testClientTargetSupport) { |
| |
| const Area bufferArea = testClientTargetSupport.getBufferArea(); |
| const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888; |
| hwc2_display_t badDisplay; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->getBadDisplay(&badDisplay)); |
| |
| ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(badDisplay, |
| bufferArea.width, bufferArea.height, format, |
| testClientTargetSupport.getDataspace(), &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| }, |
| |
| advanceClientTargetSupport)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 either supports or returns error unsupported |
| * for a variety of client target values. */ |
| TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT_unsupported) |
| { |
| ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Complete, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| const Hwc2TestClientTargetSupport& testClientTargetSupport) { |
| |
| const Area bufferArea = testClientTargetSupport.getBufferArea(); |
| const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(display, |
| bufferArea.width, bufferArea.height, format, |
| testClientTargetSupport.getDataspace(), &err)); |
| EXPECT_TRUE(err == HWC2_ERROR_NONE |
| || err == HWC2_ERROR_UNSUPPORTED) |
| << "returned wrong error code"; |
| }, |
| |
| advanceClientTargetSupport)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set a client target buffer for a basic |
| * layer. */ |
| TEST_F(Hwc2Test, SET_CLIENT_TARGET_basic) |
| { |
| const Dataspace dataspace = Dataspace::UNKNOWN; |
| const hwc_region_t damage = { }; |
| const size_t layerCnt = 1; |
| |
| for (auto display : mDisplays) { |
| std::vector<hwc2_config_t> configs; |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON)); |
| |
| ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs)); |
| |
| for (auto config : configs) { |
| Area displayArea; |
| std::vector<hwc2_layer_t> layers; |
| |
| ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config)); |
| ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, &displayArea)); |
| |
| ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt)); |
| Hwc2TestLayers testLayers(layers, Hwc2TestCoverage::Basic, |
| displayArea); |
| |
| if (!testLayers.optimizeLayouts()) |
| continue; |
| |
| Hwc2TestClientTarget testClientTarget; |
| |
| do { |
| std::set<hwc2_layer_t> clientLayers; |
| std::set<hwc2_layer_t> clearLayers; |
| uint32_t numTypes, numRequests; |
| bool hasChanges, skip; |
| bool flipClientTarget; |
| buffer_handle_t handle; |
| int32_t acquireFence; |
| |
| ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers, |
| &testLayers, &skip)); |
| if (skip) |
| continue; |
| |
| ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes, |
| &numRequests, &hasChanges)); |
| if (hasChanges) |
| EXPECT_LE(numTypes, layers.size()) |
| << "wrong number of requests"; |
| |
| ASSERT_NO_FATAL_FAILURE(handleCompositionChanges(display, |
| testLayers, layers, numTypes, &clientLayers)); |
| ASSERT_NO_FATAL_FAILURE(handleRequests(display, layers, |
| numRequests, &clearLayers, &flipClientTarget)); |
| ASSERT_EQ(testClientTarget.getBuffer(testLayers, clientLayers, |
| clearLayers, flipClientTarget, displayArea, &handle, |
| &acquireFence), 0); |
| EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle, |
| acquireFence, dataspace, damage)); |
| |
| if (acquireFence >= 0) |
| close(acquireFence); |
| |
| } while (testLayers.advance()); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers))); |
| } |
| |
| ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set a client target for a bad display. */ |
| TEST_F(Hwc2Test, SET_CLIENT_TARGET_bad_display) |
| { |
| hwc2_display_t display; |
| std::vector<hwc2_layer_t> layers; |
| const Area displayArea = {0, 0}; |
| Hwc2TestLayers testLayers(layers, Hwc2TestCoverage::Default, displayArea); |
| std::set<hwc2_layer_t> clientLayers; |
| std::set<hwc2_layer_t> flipClientTargetLayers; |
| bool flipClientTarget = true; |
| const Dataspace dataspace = Dataspace::UNKNOWN; |
| const hwc_region_t damage = { }; |
| buffer_handle_t handle; |
| int32_t acquireFence; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| Hwc2TestClientTarget testClientTarget; |
| |
| ASSERT_EQ(testClientTarget.getBuffer(testLayers, clientLayers, |
| flipClientTargetLayers, flipClientTarget, displayArea, &handle, |
| &acquireFence), 0); |
| |
| EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle, acquireFence, |
| dataspace, damage, &err)); |
| |
| if (acquireFence >= 0) |
| close(acquireFence); |
| |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 default layer. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_default_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; |
| bool optimize = false; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 2 default layers. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_default_2) |
| { |
| const size_t layerCnt = 2; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; |
| bool optimize = false; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 3 default layers. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_default_3) |
| { |
| const size_t layerCnt = 3; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; |
| bool optimize = false; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 4 default layers. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_default_4) |
| { |
| const size_t layerCnt = 4; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; |
| bool optimize = false; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 5 default layers. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_default_5) |
| { |
| const size_t layerCnt = 5; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; |
| bool optimize = false; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 6 default layers. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_default_6) |
| { |
| const size_t layerCnt = 6; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; |
| bool optimize = false; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * blend mode. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_blend_mode_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Complete}, |
| {Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Basic}, |
| {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic}}; |
| bool optimize = false; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of |
| * blend mode. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_blend_mode_2) |
| { |
| const size_t layerCnt = 2; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Complete}, |
| {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic}}; |
| bool optimize = false; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * buffer. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_buffer_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::BufferArea, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * color. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_color_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}, |
| {Hwc2TestPropertyName::Color, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of |
| * color. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_color_2) |
| { |
| const size_t layerCnt = 2; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}, |
| {Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic}, |
| {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic}, |
| {Hwc2TestPropertyName::Color, Hwc2TestCoverage::Basic}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * composition. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_composition_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * cursor. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_cursor_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}, |
| {Hwc2TestPropertyName::CursorPosition, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of |
| * cursor. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_cursor_2) |
| { |
| const size_t layerCnt = 2; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}, |
| {Hwc2TestPropertyName::CursorPosition, Hwc2TestCoverage::Complete}, |
| {Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Basic}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * dataspace. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_dataspace_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::Dataspace, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * display frame. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of |
| * display frame. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_2) |
| { |
| const size_t layerCnt = 2; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 3 layers with complete coverage of |
| * display frame. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_3) |
| { |
| const size_t layerCnt = 3; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 4 layers with complete coverage of |
| * display frame. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_4) |
| { |
| const size_t layerCnt = 4; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * plane alpha. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_plane_alpha_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic}, |
| {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Complete}}; |
| bool optimize = false; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of |
| * plane alpha. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_plane_alpha_2) |
| { |
| const size_t layerCnt = 2; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic}, |
| {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Complete}}; |
| bool optimize = false; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * source crop. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_source_crop_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}, |
| {Hwc2TestPropertyName::SourceCrop, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of |
| * source crop. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_source_crop_2) |
| { |
| const size_t layerCnt = 2; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}, |
| {Hwc2TestPropertyName::SourceCrop, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * surface damage. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_surface_damage_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::SurfaceDamage, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * transform. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_transform_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Complete}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of |
| * transform. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_transform_2) |
| { |
| const size_t layerCnt = 2; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions = |
| {{Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Complete}, |
| {Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Basic}}; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of |
| * basic. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_basic_1) |
| { |
| const size_t layerCnt = 1; |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Basic; |
| std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions; |
| bool optimize = true; |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions, |
| optimize)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot present a bad display. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_bad_display) |
| { |
| hwc2_display_t display; |
| int32_t presentFence; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(presentDisplay(display, &presentFence, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot present an unvalidated display. */ |
| TEST_F(Hwc2Test, PRESENT_DISPLAY_not_validated) |
| { |
| ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Default, 1, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| const std::vector<hwc2_layer_t>& /*layers*/, |
| Hwc2TestLayers* /*testLayers*/) { |
| |
| int32_t presentFence; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->setPowerMode(display, |
| HWC2_POWER_MODE_ON)); |
| ASSERT_NO_FATAL_FAILURE(test->enableVsync(display)); |
| |
| ASSERT_NO_FATAL_FAILURE(test->waitForVsync()); |
| |
| ASSERT_NO_FATAL_FAILURE(test->presentDisplay(display, |
| &presentFence, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED) |
| << "returned wrong error code"; |
| |
| ASSERT_NO_FATAL_FAILURE(test->disableVsync(display)); |
| ASSERT_NO_FATAL_FAILURE(test->setPowerMode(display, |
| HWC2_POWER_MODE_OFF)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot get release fences from a bad display. */ |
| TEST_F(Hwc2Test, GET_RELEASE_FENCES_bad_display) |
| { |
| hwc2_display_t display; |
| std::vector<hwc2_layer_t> layers; |
| std::vector<int32_t> fences; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(getReleaseFences(display, &layers, &fences, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| static const std::array<ColorMode, 9> androidColorModes = {{ |
| ColorMode::NATIVE, |
| ColorMode::STANDARD_BT601_625, |
| ColorMode::STANDARD_BT601_625_UNADJUSTED, |
| ColorMode::STANDARD_BT601_525, |
| ColorMode::STANDARD_BT601_525_UNADJUSTED, |
| ColorMode::STANDARD_BT709, |
| ColorMode::DCI_P3, |
| ColorMode::SRGB, |
| ColorMode::ADOBE_RGB, |
| }}; |
| |
| /* TESTCASE: Tests that the HWC2 can get the color modes for a display. The |
| * display must support ColorMode::NATIVE */ |
| TEST_F(Hwc2Test, GET_COLOR_MODES) |
| { |
| ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( |
| [] (Hwc2Test* test, hwc2_display_t display) { |
| |
| std::vector<ColorMode> colorModes; |
| |
| ASSERT_NO_FATAL_FAILURE(test->getColorModes(display, |
| &colorModes)); |
| |
| EXPECT_NE(std::count(colorModes.begin(), colorModes.end(), |
| ColorMode::NATIVE), 0) << "all displays" |
| " must support ColorMode::NATIVE"; |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot get color modes from a bad display. */ |
| TEST_F(Hwc2Test, GET_COLOR_MODES_bad_display) |
| { |
| hwc2_display_t display; |
| std::vector<ColorMode> colorModes; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(getColorModes(display, &colorModes, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set the required color mode on a display. */ |
| TEST_F(Hwc2Test, SET_COLOR_MODES) |
| { |
| ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( |
| [] (Hwc2Test* test, hwc2_display_t display) { |
| |
| const ColorMode colorMode = ColorMode::NATIVE; |
| |
| EXPECT_NO_FATAL_FAILURE(test->setColorMode(display, colorMode)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set a color mode on a bad display. */ |
| TEST_F(Hwc2Test, SET_COLOR_MODES_bad_display) |
| { |
| hwc2_display_t display; |
| const ColorMode colorMode = ColorMode::NATIVE; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(setColorMode(display, colorMode, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set an invalid color mode. */ |
| TEST_F(Hwc2Test, SET_COLOR_MODES_bad_parameter) |
| { |
| ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( |
| [] (Hwc2Test* test, hwc2_display_t display) { |
| |
| const ColorMode colorMode = static_cast<ColorMode>(-1); |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->setColorMode(display, colorMode, |
| &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) |
| << "returned wrong error code"; |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 either supports or returns error unsupported |
| * for all valid color modes. */ |
| TEST_F(Hwc2Test, SET_COLOR_MODES_unsupported) |
| { |
| ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( |
| [] (Hwc2Test* test, hwc2_display_t display) { |
| |
| for (auto colorMode : androidColorModes) { |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->setColorMode(display, |
| colorMode, &err)); |
| |
| EXPECT_TRUE(err == HWC2_ERROR_NONE |
| || err == HWC2_ERROR_UNSUPPORTED) |
| << "returned wrong error code"; |
| } |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 gets the HDR capabilities for a display and |
| * test if they are valid. */ |
| TEST_F(Hwc2Test, GET_HDR_CAPABILITIES) |
| { |
| ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( |
| [] (Hwc2Test* test, hwc2_display_t display) { |
| |
| std::vector<android_hdr_t> hdrCapabilities; |
| float maxLuminance, maxAverageLuminance, minLuminance; |
| |
| EXPECT_NO_FATAL_FAILURE(test->getHdrCapabilities(display, |
| &hdrCapabilities, &maxLuminance, &maxAverageLuminance, |
| &minLuminance)); |
| |
| if (hdrCapabilities.empty()) |
| return; |
| |
| EXPECT_GE(maxLuminance, maxAverageLuminance); |
| EXPECT_GE(maxAverageLuminance, minLuminance); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot get hdr capabilities from a bad display */ |
| TEST_F(Hwc2Test, GET_HDR_CAPABILITIES_bad_display) |
| { |
| hwc2_display_t display; |
| std::vector<android_hdr_t> hdrCapabilities; |
| float maxLuminance, maxAverageLuminance, minLuminance; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(getHdrCapabilities(display, &hdrCapabilities, |
| &maxLuminance, &maxAverageLuminance, &minLuminance, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| static const std::array<float, 16> identityMatrix = {{ |
| 1.0, 0.0, 0.0, 0.0, |
| 0.0, 1.0, 0.0, 0.0, |
| 0.0, 0.0, 1.0, 0.0, |
| 0.0, 0.0, 0.0, 1.0, |
| }}; |
| |
| /* Values for the color transform matrices were precomputed using the source code |
| * in surfaceflinger/Effects/Daltonizer.cpp. */ |
| |
| static const std::array<const std::array<float, 16>, 5> exampleMatrices = {{ |
| identityMatrix, |
| /* Converts RGB color to the XYZ space */ |
| {{ 0.4124, 0.2126, 0.0193, 0, |
| 0.3576, 0.7152, 0.1192, 0, |
| 0.1805, 0.0722, 0.9505, 0, |
| 0 , 0 , 0 , 1 }}, |
| /* Protanomaly */ |
| {{ 0.068493, 0.931506, 0, 0, |
| 0.068493, 0.931507, 0, 0, |
| 0.013626, -0.013626, 1, 0, |
| 0, 0, 0, 1 }}, |
| /* Deuteranomaly */ |
| {{ 0.288299, 0.711701, 0, 0, |
| 0.052709, 0.947291, 0, 0, |
| -0.257912, 0.257912, 1, 0, |
| 0, 0, 0, 1 }}, |
| /* Tritanomaly */ |
| {{ 1, -0.805712, 0.805712, 0, |
| 0, 0.378838, 0.621162, 0, |
| 0, 0.104823, 0.895177, 0, |
| 0, 0, 0, 1 }}, |
| }}; |
| |
| /* TESTCASE: Tests that the HWC2 can set the identity color transform */ |
| TEST_F(Hwc2Test, SET_COLOR_TRANSFORM) |
| { |
| ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( |
| [] (Hwc2Test* test, hwc2_display_t display) { |
| |
| EXPECT_NO_FATAL_FAILURE(test->setColorTransform(display, |
| identityMatrix, HAL_COLOR_TRANSFORM_IDENTITY)); |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set the color transform for a bad |
| * display. */ |
| TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_bad_display) |
| { |
| hwc2_display_t display; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(setColorTransform(display, identityMatrix, |
| HAL_COLOR_TRANSFORM_IDENTITY, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set an invalid color transform. */ |
| TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_bad_parameter) |
| { |
| ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( |
| [] (Hwc2Test* test, hwc2_display_t display) { |
| |
| const android_color_transform_t hint = |
| static_cast<android_color_transform_t>(-1); |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->setColorTransform(display, |
| identityMatrix, hint, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) |
| << "returned wrong error code"; |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set an arbitrary color matrix. */ |
| TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_arbitrary_matrix) |
| { |
| ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig( |
| [] (Hwc2Test* test, hwc2_display_t display) { |
| |
| const android_color_transform_t hint = |
| HAL_COLOR_TRANSFORM_ARBITRARY_MATRIX; |
| |
| for (const std::array<float, 16>& matrix : exampleMatrices) { |
| EXPECT_NO_FATAL_FAILURE(test->setColorTransform(display, |
| matrix, hint)); |
| } |
| } |
| )); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 create an destory virtual displays. */ |
| TEST_F(Hwc2Test, CREATE_DESTROY_VIRTUAL_DISPLAY) |
| { |
| ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Complete, |
| [] (Hwc2Test* /*test*/, hwc2_display_t /*display*/, |
| Hwc2TestVirtualDisplay* /*testVirtualDisplay*/) { })); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can create and destroy multiple virtual |
| * displays. */ |
| TEST_F(Hwc2Test, CREATE_DESTROY_VIRTUAL_DISPLAY_multiple) |
| { |
| Hwc2TestVirtualDisplay testVirtualDisplay(Hwc2TestCoverage::Complete); |
| std::vector<hwc2_display_t> displays; |
| |
| do { |
| const UnsignedArea& dimension = |
| testVirtualDisplay.getDisplayDimension(); |
| android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888; |
| hwc2_display_t display; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(dimension.width, |
| dimension.height, &desiredFormat, &display, &err)); |
| |
| EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_NO_RESOURCES |
| || err == HWC2_ERROR_UNSUPPORTED) << "returned wrong error code"; |
| EXPECT_GE(desiredFormat, 0) << "invalid format"; |
| |
| if (err == HWC2_ERROR_NONE) |
| displays.push_back(display); |
| |
| } while (testVirtualDisplay.advance()); |
| |
| for (hwc2_display_t display : displays) { |
| EXPECT_NO_FATAL_FAILURE(destroyVirtualDisplay(display)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot destroy a bad virtual displays. */ |
| TEST_F(Hwc2Test, DESTROY_VIRTUAL_DISPLAY_bad_display) |
| { |
| hwc2_display_t display; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display)); |
| |
| ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot destroy a physical display. */ |
| TEST_F(Hwc2Test, DESTROY_VIRTUAL_DISPLAY_bad_parameter) |
| { |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| for (auto display : mDisplays) { |
| ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code"; |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can get the max virtual display count. */ |
| TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT) |
| { |
| uint32_t maxCnt; |
| |
| ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 returns the same max virtual display count for |
| * each call. */ |
| TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT_duplicate) |
| { |
| uint32_t maxCnt1, maxCnt2; |
| |
| ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt1)); |
| ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt2)); |
| |
| EXPECT_EQ(maxCnt1, maxCnt2) << "returned two different max virtual display" |
| " counts"; |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can create the max number of virtual displays |
| * that it reports. */ |
| TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT_create_max) |
| { |
| std::vector<hwc2_display_t> displays; |
| uint32_t maxCnt; |
| |
| ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt)); |
| |
| while (displays.size() < maxCnt) { |
| uint32_t width = 1920, height = 1080; |
| android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888; |
| hwc2_display_t display; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(width, height, |
| &desiredFormat, &display, &err)); |
| |
| EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_UNSUPPORTED) |
| << "returned wrong error code"; |
| if (err != HWC2_ERROR_NONE) |
| break; |
| |
| displays.push_back(display); |
| } |
| |
| for (hwc2_display_t display : displays) { |
| EXPECT_NO_FATAL_FAILURE(destroyVirtualDisplay(display)); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can set an output buffer for a virtual |
| * display. */ |
| TEST_F(Hwc2Test, SET_OUTPUT_BUFFER) |
| { |
| ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Complete, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| Hwc2TestVirtualDisplay* testVirtualDisplay) { |
| |
| buffer_handle_t handle; |
| android::base::unique_fd acquireFence; |
| |
| if (testVirtualDisplay->getOutputBuffer(&handle, &acquireFence) >= 0) |
| EXPECT_NO_FATAL_FAILURE(test->setOutputBuffer(display, |
| handle, acquireFence)); |
| })); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set an output buffer for a bad display */ |
| TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_bad_display) |
| { |
| ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Default, |
| [] (Hwc2Test* test, hwc2_display_t /*display*/, |
| Hwc2TestVirtualDisplay* testVirtualDisplay) { |
| |
| hwc2_display_t badDisplay; |
| buffer_handle_t handle; |
| android::base::unique_fd acquireFence; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->getBadDisplay(&badDisplay)); |
| |
| if (testVirtualDisplay->getOutputBuffer(&handle, &acquireFence) < 0) |
| return; |
| |
| ASSERT_NO_FATAL_FAILURE(test->setOutputBuffer(badDisplay, |
| handle, acquireFence, &err)); |
| EXPECT_TRUE(err == HWC2_ERROR_BAD_DISPLAY) |
| << "returned wrong error code"; |
| })); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set an invalid output buffer. */ |
| TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_bad_parameter) |
| { |
| ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Default, |
| [] (Hwc2Test* test, hwc2_display_t display, |
| Hwc2TestVirtualDisplay* /*testVirtualDisplay*/) { |
| |
| const buffer_handle_t handle = nullptr; |
| uint32_t releaseFence = -1; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| ASSERT_NO_FATAL_FAILURE(test->setOutputBuffer(display, handle, |
| releaseFence, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) |
| << "returned wrong error code"; |
| })); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 cannot set an output buffer for non virtual |
| * display */ |
| TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_unsupported) |
| { |
| for (auto display : mDisplays) { |
| Hwc2TestVirtualDisplay testVirtualDisplay(Hwc2TestCoverage::Complete); |
| |
| do { |
| buffer_handle_t handle; |
| android::base::unique_fd acquireFence; |
| hwc2_error_t err = HWC2_ERROR_NONE; |
| |
| if (testVirtualDisplay.getOutputBuffer(&handle, &acquireFence) < 0) |
| continue; |
| |
| ASSERT_NO_FATAL_FAILURE(setOutputBuffer(display, handle, |
| acquireFence, &err)); |
| EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code"; |
| |
| } while (testVirtualDisplay.advance()); |
| } |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can dump debug information. */ |
| TEST_F(Hwc2Test, DUMP) |
| { |
| std::string buffer; |
| |
| ASSERT_NO_FATAL_FAILURE(dump(&buffer)); |
| } |
| |
| /* |
| * TODO(b/64724708): Hwc2TestPropertyName::BufferArea MUST be default for all |
| * virtual display tests as we don't handle this case correctly. |
| * |
| * Only default dataspace is supported in our drawing code. |
| */ |
| const std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> |
| virtualDisplayExceptions = |
| {{Hwc2TestPropertyName::BufferArea, Hwc2TestCoverage::Default}, |
| {Hwc2TestPropertyName::Dataspace, Hwc2TestCoverage::Default}}; |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with default coverage on a |
| * virtual display. */ |
| TEST_F(Hwc2Test, PRESENT_VIRTUAL_DISPLAY_default_1) |
| { |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| const size_t layerCnt = 1; |
| ASSERT_NO_FATAL_FAILURE(createAndPresentVirtualDisplay(layerCnt, coverage, |
| virtualDisplayExceptions)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 1 layer with basic coverage on a |
| * virtual display. */ |
| TEST_F(Hwc2Test, PRESENT_VIRTUAL_DISPLAY_basic_1) |
| { |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Basic; |
| const size_t layerCnt = 1; |
| ASSERT_NO_FATAL_FAILURE(createAndPresentVirtualDisplay(layerCnt, coverage, |
| virtualDisplayExceptions)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 2 layers with default coverage on a |
| * virtual display. */ |
| TEST_F(Hwc2Test, PRESENT_VIRTUAL_DISPLAY_default_2) |
| { |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| const size_t layerCnt = 2; |
| ASSERT_NO_FATAL_FAILURE(createAndPresentVirtualDisplay(layerCnt, coverage, |
| virtualDisplayExceptions)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 3 layers with default coverage on a |
| * virtual display. */ |
| TEST_F(Hwc2Test, PRESENT_VIRTUAL_DISPLAY_default_3) |
| { |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| const size_t layerCnt = 3; |
| ASSERT_NO_FATAL_FAILURE(createAndPresentVirtualDisplay(layerCnt, coverage, |
| virtualDisplayExceptions)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 4 layers with default coverage on a |
| * virtual display. */ |
| TEST_F(Hwc2Test, PRESENT_VIRTUAL_DISPLAY_default_4) |
| { |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| const size_t layerCnt = 4; |
| ASSERT_NO_FATAL_FAILURE(createAndPresentVirtualDisplay(layerCnt, coverage, |
| virtualDisplayExceptions)); |
| } |
| |
| /* TESTCASE: Tests that the HWC2 can present 5 layers with default coverage on a |
| * virtual display. */ |
| TEST_F(Hwc2Test, PRESENT_VIRTUAL_DISPLAY_default_5) |
| { |
| Hwc2TestCoverage coverage = Hwc2TestCoverage::Default; |
| const size_t layerCnt = 5; |
| ASSERT_NO_FATAL_FAILURE(createAndPresentVirtualDisplay(layerCnt, coverage, |
| virtualDisplayExceptions)); |
| } |