/* * Copyright (C) 2018 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. */ #define LOG_TAG "graphics_composer_hidl_hal_test@2.3" #include <algorithm> #include <VtsHalHidlTargetTestBase.h> #include <android-base/logging.h> #include <android/hardware/graphics/mapper/2.0/IMapper.h> #include <composer-command-buffer/2.3/ComposerCommandBuffer.h> #include <composer-vts/2.1/GraphicsComposerCallback.h> #include <composer-vts/2.1/TestCommandReader.h> #include <composer-vts/2.3/ComposerVts.h> #include <mapper-vts/2.0/MapperVts.h> namespace android { namespace hardware { namespace graphics { namespace composer { namespace V2_3 { namespace vts { namespace { using common::V1_0::BufferUsage; using common::V1_1::RenderIntent; using common::V1_2::ColorMode; using common::V1_2::Dataspace; using common::V1_2::PixelFormat; using mapper::V2_0::IMapper; using V2_2::vts::Gralloc; // Test environment for graphics.composer class GraphicsComposerHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase { public: // get the test environment singleton static GraphicsComposerHidlEnvironment* Instance() { static GraphicsComposerHidlEnvironment* instance = new GraphicsComposerHidlEnvironment; return instance; } virtual void registerTestServices() override { registerTestService<IComposer>(); } private: GraphicsComposerHidlEnvironment() {} GTEST_DISALLOW_COPY_AND_ASSIGN_(GraphicsComposerHidlEnvironment); }; class GraphicsComposerHidlTest : public ::testing::VtsHalHidlTargetTestBase { protected: void SetUp() override { ASSERT_NO_FATAL_FAILURE( mComposer = std::make_unique<Composer>( GraphicsComposerHidlEnvironment::Instance()->getServiceName<IComposer>())); ASSERT_NO_FATAL_FAILURE(mComposerClient = mComposer->createClient()); mComposerCallback = new V2_1::vts::GraphicsComposerCallback; mComposerClient->registerCallback(mComposerCallback); // assume the first display is primary and is never removed mPrimaryDisplay = waitForFirstDisplay(); mInvalidDisplayId = GetInvalidDisplayId(); // explicitly disable vsync mComposerClient->setVsyncEnabled(mPrimaryDisplay, false); mComposerCallback->setVsyncAllowed(false); mWriter = std::make_unique<CommandWriterBase>(1024); mReader = std::make_unique<V2_1::vts::TestCommandReader>(); } void TearDown() override { ASSERT_EQ(0, mReader->mErrors.size()); ASSERT_EQ(0, mReader->mCompositionChanges.size()); if (mComposerCallback != nullptr) { EXPECT_EQ(0, mComposerCallback->getInvalidHotplugCount()); EXPECT_EQ(0, mComposerCallback->getInvalidRefreshCount()); EXPECT_EQ(0, mComposerCallback->getInvalidVsyncCount()); } } // returns an invalid display id (one that has not been registered to a // display. Currently assuming that a device will never have close to // std::numeric_limit<uint64_t>::max() displays registered while running tests Display GetInvalidDisplayId() { std::vector<Display> validDisplays = mComposerCallback->getDisplays(); uint64_t id = std::numeric_limits<uint64_t>::max(); while (id > 0) { if (std::find(validDisplays.begin(), validDisplays.end(), id) == validDisplays.end()) { return id; } id--; } return 0; } void execute() { mComposerClient->execute(mReader.get(), mWriter.get()); } // use the slot count usually set by SF static constexpr uint32_t kBufferSlotCount = 64; std::unique_ptr<Composer> mComposer; std::unique_ptr<ComposerClient> mComposerClient; sp<V2_1::vts::GraphicsComposerCallback> mComposerCallback; // the first display and is assumed never to be removed Display mPrimaryDisplay; Display mInvalidDisplayId; std::unique_ptr<CommandWriterBase> mWriter; std::unique_ptr<V2_1::vts::TestCommandReader> mReader; private: Display waitForFirstDisplay() { while (true) { std::vector<Display> displays = mComposerCallback->getDisplays(); if (displays.empty()) { usleep(5 * 1000); continue; } return displays[0]; } } }; // Tests for IComposerClient::Command. class GraphicsComposerHidlCommandTest : public GraphicsComposerHidlTest { protected: void SetUp() override { ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::SetUp()); ASSERT_NO_FATAL_FAILURE(mGralloc = std::make_unique<Gralloc>()); mWriter = std::make_unique<CommandWriterBase>(1024); mReader = std::make_unique<V2_1::vts::TestCommandReader>(); } void TearDown() override { ASSERT_EQ(0, mReader->mErrors.size()); ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::TearDown()); } const native_handle_t* allocate() { return mGralloc->allocate( 64, 64, 1, static_cast<common::V1_1::PixelFormat>(PixelFormat::RGBA_8888), static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN)); } void execute() { mComposerClient->execute(mReader.get(), mWriter.get()); } std::unique_ptr<CommandWriterBase> mWriter; std::unique_ptr<V2_1::vts::TestCommandReader> mReader; private: std::unique_ptr<Gralloc> mGralloc; }; /** * Test IComposerClient::getDisplayIdentificationData. * * TODO: Check that ports are unique for multiple displays. */ TEST_F(GraphicsComposerHidlTest, GetDisplayIdentificationData) { uint8_t port0; std::vector<uint8_t> data0; if (mComposerClient->getDisplayIdentificationData(mPrimaryDisplay, &port0, &data0)) { uint8_t port1; std::vector<uint8_t> data1; ASSERT_TRUE(mComposerClient->getDisplayIdentificationData(mPrimaryDisplay, &port1, &data1)); ASSERT_EQ(port0, port1) << "ports are not stable"; ASSERT_TRUE(data0.size() == data1.size() && std::equal(data0.begin(), data0.end(), data1.begin())) << "data is not stable"; } } /** * Test IComposerClient::Command::SET_LAYER_PER_FRAME_METADATA. */ TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_PER_FRAME_METADATA) { Layer layer; ASSERT_NO_FATAL_FAILURE(layer = mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount)); mWriter->selectDisplay(mPrimaryDisplay); mWriter->selectLayer(layer); /** * DISPLAY_P3 is a color space that uses the DCI_P3 primaries, * the D65 white point and the SRGB transfer functions. * Rendering Intent: Colorimetric * Primaries: * x y * green 0.265 0.690 * blue 0.150 0.060 * red 0.680 0.320 * white (D65) 0.3127 0.3290 */ std::vector<IComposerClient::PerFrameMetadata> hidlMetadata; hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680}); hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320}); hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265}); hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690}); hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150}); hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060}); hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::WHITE_POINT_X, 0.3127}); hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::WHITE_POINT_Y, 0.3290}); hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MAX_LUMINANCE, 100.0}); hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MIN_LUMINANCE, 0.1}); hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0}); hidlMetadata.push_back( {IComposerClient::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0}); mWriter->setLayerPerFrameMetadata(hidlMetadata); execute(); if (mReader->mErrors.size() == 1 && static_cast<Error>(mReader->mErrors[0].second) == Error::UNSUPPORTED) { mReader->mErrors.clear(); GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported"; ASSERT_NO_FATAL_FAILURE(mComposerClient->destroyLayer(mPrimaryDisplay, layer)); return; } ASSERT_NO_FATAL_FAILURE(mComposerClient->destroyLayer(mPrimaryDisplay, layer)); } /** * Test IComposerClient::getHdrCapabilities_2_3 */ TEST_F(GraphicsComposerHidlTest, GetHdrCapabilities_2_3) { float maxLuminance; float maxAverageLuminance; float minLuminance; ASSERT_NO_FATAL_FAILURE(mComposerClient->getHdrCapabilities_2_3( mPrimaryDisplay, &maxLuminance, &maxAverageLuminance, &minLuminance)); ASSERT_TRUE(maxLuminance >= minLuminance); } /** * Test IComposerClient::getPerFrameMetadataKeys_2_3 */ TEST_F(GraphicsComposerHidlTest, GetPerFrameMetadataKeys_2_3) { std::vector<IComposerClient::PerFrameMetadataKey> keys; mComposerClient->getRaw()->getPerFrameMetadataKeys_2_3( mPrimaryDisplay, [&](const auto tmpError, const auto outKeys) { if (tmpError != Error::UNSUPPORTED) { ASSERT_EQ(Error::NONE, tmpError); keys = outKeys; } }); } /** * TestIComposerClient::getReadbackBufferAttributes_2_3 */ TEST_F(GraphicsComposerHidlTest, GetReadbackBufferAttributes_2_3) { Dataspace dataspace; PixelFormat pixelFormat; mComposerClient->getRaw()->getReadbackBufferAttributes_2_3( mPrimaryDisplay, [&](const auto tmpError, const auto outPixelFormat, const auto outDataspace) { if (tmpError != Error::UNSUPPORTED) { ASSERT_EQ(Error::NONE, tmpError); dataspace = outDataspace; pixelFormat = outPixelFormat; } }); } /** * Test IComposerClient::getClientTargetSupport_2_3 */ TEST_F(GraphicsComposerHidlTest, GetClientTargetSupport_2_3) { std::vector<V2_1::Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay); for (auto config : configs) { int32_t width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config, IComposerClient::Attribute::WIDTH); int32_t height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config, IComposerClient::Attribute::HEIGHT); ASSERT_LT(0, width); ASSERT_LT(0, height); mComposerClient->setActiveConfig(mPrimaryDisplay, config); ASSERT_TRUE(mComposerClient->getClientTargetSupport_2_3( mPrimaryDisplay, width, height, PixelFormat::RGBA_8888, Dataspace::UNKNOWN)); } } /** * Test IComposerClient::getClientTargetSupport_2_3 * * Test that IComposerClient::getClientTargetSupport_2_3 returns * Error::BAD_DISPLAY when passed in an invalid display handle */ TEST_F(GraphicsComposerHidlTest, GetClientTargetSupport_2_3BadDisplay) { std::vector<V2_1::Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay); for (auto config : configs) { int32_t width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config, IComposerClient::Attribute::WIDTH); int32_t height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config, IComposerClient::Attribute::HEIGHT); ASSERT_LT(0, width); ASSERT_LT(0, height); mComposerClient->setActiveConfig(mPrimaryDisplay, config); Error error = mComposerClient->getRaw()->getClientTargetSupport_2_3( mInvalidDisplayId, width, height, PixelFormat::RGBA_8888, Dataspace::UNKNOWN); EXPECT_EQ(Error::BAD_DISPLAY, error); } } /** * Test IComposerClient::getRenderIntents_2_3 */ TEST_F(GraphicsComposerHidlTest, GetRenderIntents_2_3) { std::vector<ColorMode> modes = mComposerClient->getColorModes_2_3(mPrimaryDisplay); for (auto mode : modes) { std::vector<RenderIntent> intents = mComposerClient->getRenderIntents_2_3(mPrimaryDisplay, mode); bool isHdr; switch (mode) { case ColorMode::BT2100_PQ: case ColorMode::BT2100_HLG: isHdr = true; break; default: isHdr = false; break; } RenderIntent requiredIntent = isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC; auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent); EXPECT_NE(intents.cend(), iter); } } /* * Test IComposerClient::getRenderIntents_2_3 * * Test that IComposerClient::getRenderIntents_2_3 returns Error::BAD_DISPLAY when * passed an invalid display handle */ TEST_F(GraphicsComposerHidlTest, GetRenderIntents_2_3BadDisplay) { std::vector<ColorMode> modes = mComposerClient->getColorModes_2_3(mPrimaryDisplay); for (auto mode : modes) { mComposerClient->getRaw()->getRenderIntents_2_3( mInvalidDisplayId, mode, [&](const auto& tmpError, const auto&) { EXPECT_EQ(Error::BAD_DISPLAY, tmpError); }); } } /* * Test IComposerClient::getRenderIntents_2_3 * * Test that IComposerClient::getRenderIntents_2_3 returns Error::BAD_PARAMETER when * pased either an invalid Color mode or an invalid Render Intent */ TEST_F(GraphicsComposerHidlTest, GetRenderIntents_2_3BadParameter) { mComposerClient->getRaw()->getRenderIntents_2_3( mPrimaryDisplay, static_cast<ColorMode>(-1), [&](const auto& tmpError, const auto&) { EXPECT_EQ(Error::BAD_PARAMETER, tmpError); }); } /** * IComposerClient::getColorModes_2_3 */ TEST_F(GraphicsComposerHidlTest, GetColorModes_2_3) { std::vector<ColorMode> colorModes = mComposerClient->getColorModes_2_3(mPrimaryDisplay); auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE); ASSERT_NE(colorModes.cend(), native); } /* * Test IComposerClient::getColorModes_2_3 * * Test that IComposerClient::getColorModes_2_3 returns Error::BAD_DISPLAY when * passed an invalid display handle */ TEST_F(GraphicsComposerHidlTest, GetColorMode_2_3BadDisplay) { mComposerClient->getRaw()->getColorModes_2_3( mInvalidDisplayId, [&](const auto& tmpError, const auto&) { ASSERT_EQ(Error::BAD_DISPLAY, tmpError); }); } /** * IComposerClient::setColorMode_2_3 */ TEST_F(GraphicsComposerHidlTest, SetColorMode_2_3) { std::vector<ColorMode> colorModes = mComposerClient->getColorModes_2_3(mPrimaryDisplay); for (auto mode : colorModes) { std::vector<RenderIntent> intents = mComposerClient->getRenderIntents_2_3(mPrimaryDisplay, mode); for (auto intent : intents) { ASSERT_NO_FATAL_FAILURE( mComposerClient->setColorMode_2_3(mPrimaryDisplay, mode, intent)); } } ASSERT_NO_FATAL_FAILURE(mComposerClient->setColorMode_2_3(mPrimaryDisplay, ColorMode::NATIVE, RenderIntent::COLORIMETRIC)); } /* * Test IComposerClient::setColorMode_2_3 * * Test that IComposerClient::setColorMode_2_3 returns an Error::BAD_DISPLAY * when passed an invalid display handle */ TEST_F(GraphicsComposerHidlTest, SetColorMode_2_3BadDisplay) { Error error = mComposerClient->getRaw()->setColorMode_2_3(mInvalidDisplayId, ColorMode::NATIVE, RenderIntent::COLORIMETRIC); ASSERT_EQ(Error::BAD_DISPLAY, error); } /* * Test IComposerClient::setColorMode_2_3 * * Test that IComposerClient::setColorMode_2_3 returns Error::BAD_PARAMETER when * passed an invalid Color mode or an invalid render intent */ TEST_F(GraphicsComposerHidlTest, SetColorMode_2_3BadParameter) { Error colorModeError = mComposerClient->getRaw()->setColorMode_2_3( mPrimaryDisplay, static_cast<ColorMode>(-1), RenderIntent::COLORIMETRIC); EXPECT_EQ(Error::BAD_PARAMETER, colorModeError); Error renderIntentError = mComposerClient->getRaw()->setColorMode_2_3( mPrimaryDisplay, ColorMode::NATIVE, static_cast<RenderIntent>(-1)); EXPECT_EQ(Error::BAD_PARAMETER, renderIntentError); } /** * Test IComposerClient::Command::SET_LAYER_COLOR_TRANSFORM. * TODO Add color to the layer, use matrix to keep only red component, * and check. */ TEST_F(GraphicsComposerHidlTest, SetLayerColorTransform) { Layer layer; ASSERT_NO_FATAL_FAILURE(layer = mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount)); mWriter->selectDisplay(mPrimaryDisplay); mWriter->selectLayer(layer); // clang-format off const std::array<float, 16> matrix = {{ 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, }}; // clang-format on mWriter->setLayerColorTransform(matrix.data()); execute(); if (mReader->mErrors.size() == 1 && static_cast<Error>(mReader->mErrors[0].second) == Error::UNSUPPORTED) { mReader->mErrors.clear(); GTEST_SUCCEED() << "setLayerColorTransform is not supported"; return; } } TEST_F(GraphicsComposerHidlTest, GetDisplayedContentSamplingAttributes) { int constexpr invalid = -1; auto format = static_cast<PixelFormat>(invalid); auto dataspace = static_cast<Dataspace>(invalid); auto componentMask = static_cast<hidl_bitfield<IComposerClient::FormatColorComponent>>(invalid); auto error = mComposerClient->getDisplayedContentSamplingAttributes(mPrimaryDisplay, format, dataspace, componentMask); if (error == Error::UNSUPPORTED) { SUCCEED() << "Device does not support optional extension. Test skipped"; return; } EXPECT_EQ(error, Error::NONE); EXPECT_NE(format, static_cast<PixelFormat>(invalid)); EXPECT_NE(dataspace, static_cast<Dataspace>(invalid)); EXPECT_NE(componentMask, static_cast<hidl_bitfield<IComposerClient::FormatColorComponent>>(invalid)); }; TEST_F(GraphicsComposerHidlTest, SetDisplayedContentSamplingEnabled) { auto const maxFrames = 10; auto const enableAllComponents = 0; auto error = mComposerClient->setDisplayedContentSamplingEnabled( mPrimaryDisplay, IComposerClient::DisplayedContentSampling::ENABLE, enableAllComponents, maxFrames); if (error == Error::UNSUPPORTED) { SUCCEED() << "Device does not support optional extension. Test skipped"; return; } EXPECT_EQ(error, Error::NONE); error = mComposerClient->setDisplayedContentSamplingEnabled( mPrimaryDisplay, IComposerClient::DisplayedContentSampling::DISABLE, enableAllComponents, maxFrames); EXPECT_EQ(error, Error::NONE); } TEST_F(GraphicsComposerHidlTest, GetDisplayedContentSample) { int constexpr invalid = -1; auto format = static_cast<PixelFormat>(invalid); auto dataspace = static_cast<Dataspace>(invalid); auto componentMask = static_cast<hidl_bitfield<IComposerClient::FormatColorComponent>>(invalid); auto error = mComposerClient->getDisplayedContentSamplingAttributes(mPrimaryDisplay, format, dataspace, componentMask); uint64_t maxFrames = 10; uint64_t timestamp = 0; uint64_t frameCount = 0; hidl_array<hidl_vec<uint64_t>, 4> histogram; error = mComposerClient->getDisplayedContentSample(mPrimaryDisplay, maxFrames, timestamp, frameCount, histogram[0], histogram[1], histogram[2], histogram[3]); if (error == Error::UNSUPPORTED) { SUCCEED() << "Device does not support optional extension. Test skipped"; return; } EXPECT_EQ(error, Error::NONE); EXPECT_LE(frameCount, maxFrames); for (auto i = 0; i < histogram.size(); i++) { if (componentMask & (1 << i)) { EXPECT_NE(histogram[i].size(), 0); } else { EXPECT_EQ(histogram[i].size(), 0); } } } /* * getDisplayCapabilities is required in composer 2.3 * Test some constraints. */ TEST_F(GraphicsComposerHidlTest, getDisplayCapabilitiesBasic) { std::vector<IComposerClient::DisplayCapability> capabilities; const auto error = mComposerClient->getDisplayCapabilities(mPrimaryDisplay, &capabilities); ASSERT_EQ(Error::NONE, error); const bool hasDozeSupport = std::find(capabilities.begin(), capabilities.end(), IComposerClient::DisplayCapability::DOZE) != capabilities.end(); EXPECT_EQ(mComposerClient->getDozeSupport(mPrimaryDisplay), hasDozeSupport); bool hasBrightnessSupport = std::find(capabilities.begin(), capabilities.end(), IComposerClient::DisplayCapability::BRIGHTNESS) != capabilities.end(); EXPECT_EQ(mComposerClient->getDisplayBrightnessSupport(mPrimaryDisplay), hasBrightnessSupport); } TEST_F(GraphicsComposerHidlTest, getDisplayCapabilitiesBadDisplay) { std::vector<IComposerClient::DisplayCapability> capabilities; const auto error = mComposerClient->getDisplayCapabilities(mInvalidDisplayId, &capabilities); EXPECT_EQ(Error::BAD_DISPLAY, error); } TEST_F(GraphicsComposerHidlTest, SetLayerPerFrameMetadataBlobs) { Layer layer; ASSERT_NO_FATAL_FAILURE(layer = mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount)); mWriter->selectDisplay(mPrimaryDisplay); mWriter->selectLayer(layer); std::vector<IComposerClient::PerFrameMetadataBlob> metadata; metadata.push_back( {IComposerClient::PerFrameMetadataKey::HDR10_PLUS_SEI, std::vector<uint8_t>(1, 0xff)}); mWriter->setLayerPerFrameMetadataBlobs(metadata); execute(); if (mReader->mErrors.size() == 1 && static_cast<Error>(mReader->mErrors[0].second) == Error::UNSUPPORTED) { mReader->mErrors.clear(); GTEST_SUCCEED() << "setLayerDynamicPerFrameMetadata is not supported"; return; } } /* * Test that if brightness operations are supported, setDisplayBrightness works as expected. */ TEST_F(GraphicsComposerHidlTest, setDisplayBrightness) { std::vector<IComposerClient::DisplayCapability> capabilities; const auto error = mComposerClient->getDisplayCapabilities(mPrimaryDisplay, &capabilities); ASSERT_EQ(Error::NONE, error); bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(), IComposerClient::DisplayCapability::BRIGHTNESS) != capabilities.end(); if (!brightnessSupport) { EXPECT_EQ(mComposerClient->getRaw()->setDisplayBrightness(mPrimaryDisplay, 0.5f), Error::UNSUPPORTED); GTEST_SUCCEED() << "Brightness operations are not supported"; return; } EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, 0.0f), Error::NONE); EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, 0.5f), Error::NONE); EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, 1.0f), Error::NONE); EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, -1.0f), Error::NONE); EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, +2.0f), Error::BAD_PARAMETER); EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, -2.0f), Error::BAD_PARAMETER); } } // namespace } // namespace vts } // namespace V2_3 } // namespace composer } // namespace graphics } // namespace hardware } // namespace android int main(int argc, char** argv) { using android::hardware::graphics::composer::V2_3::vts::GraphicsComposerHidlEnvironment; ::testing::AddGlobalTestEnvironment(GraphicsComposerHidlEnvironment::Instance()); ::testing::InitGoogleTest(&argc, argv); GraphicsComposerHidlEnvironment::Instance()->init(&argc, argv); int status = RUN_ALL_TESTS(); return status; }