Adds non reader/writer based HAL 2.4 tests for AIDL composer3
If service exists then we can proceed with test otherwise tests will be skipped.
Test: atest VtsHalGraphicsComposer3_TargetTest but tests don't just work yet. as we don't have service implementation.
BUG: 202053621
NOTE: Efforts to migrate reader/writer based tests will be done under b/202446967
CHECK: https://googleplex-android-review.git.corp.google.com/c/platform/hardware/interfaces/+/15987347/7..14
Change-Id: Ie7a81bbec463a471d9c88edf32cde6d86197991a
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp
index 2dc80fc..3fbb105 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp
@@ -8,15 +8,18 @@
#include <binder/ProcessState.h>
#include <composer-vts/include/GraphicsComposerCallback.h>
#include <gtest/gtest.h>
+#include <algorithm>
+#include <regex>
#include <string>
#include <thread>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
#pragma push_macro("LOG_TAG")
#undef LOG_TAG
#define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
-typedef int32_t Config;
-
namespace aidl::android::hardware::graphics::composer3::vts {
namespace {
@@ -61,8 +64,8 @@
// 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
- uint64_t GetInvalidDisplayId() {
- uint64_t id = std::numeric_limits<uint64_t>::max();
+ int64_t GetInvalidDisplayId() {
+ int64_t id = std::numeric_limits<int64_t>::max();
while (id > 0) {
if (std::none_of(mDisplays.begin(), mDisplays.end(),
[&](const VtsDisplay& display) { return id == display.get(); })) {
@@ -87,7 +90,7 @@
std::vector<VtsDisplay> vtsDisplays;
vtsDisplays.reserve(displays.size());
for (int64_t display : displays) {
- Config activeConfig;
+ int32_t activeConfig;
EXPECT_TRUE(mComposerClient->getActiveConfig(display, &activeConfig).isOk());
int32_t displayWidth;
EXPECT_TRUE(mComposerClient
@@ -106,6 +109,61 @@
}
}
+ // returns an invalid config id which is std::numeric_limit<int32_t>::max()
+ int32_t GetInvalidConfigId() { return IComposerClient::INVALID_CONFIGURATION; }
+
+ ndk::ScopedAStatus setActiveConfigWithConstraints(
+ VtsDisplay& display, int32_t config, const VsyncPeriodChangeConstraints& constraints,
+ VsyncPeriodChangeTimeline* timeline) {
+ auto error = mComposerClient->setActiveConfigWithConstraints(display.get(), config,
+ constraints, timeline);
+ if (error.isOk()) {
+ int32_t displayWidth;
+ EXPECT_TRUE(mComposerClient
+ ->getDisplayAttribute(display.get(), config,
+ DisplayAttribute::WIDTH, &displayWidth)
+ .isOk());
+ int32_t displayHeight;
+ EXPECT_TRUE(mComposerClient
+ ->getDisplayAttribute(display.get(), config,
+ DisplayAttribute::HEIGHT, &displayHeight)
+ .isOk());
+ display.setDimensions(displayWidth, displayHeight);
+ }
+ return error;
+ }
+
+ void Test_setContentTypeForDisplay(const int64_t& display,
+ const std::vector<ContentType>& capabilities,
+ const ContentType& contentType, const char* contentTypeStr) {
+ const bool contentTypeSupport = std::find(capabilities.begin(), capabilities.end(),
+ contentType) != capabilities.end();
+
+ if (!contentTypeSupport) {
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED,
+ mComposerClient->setContentType(display, contentType)
+ .getServiceSpecificError());
+ GTEST_SUCCEED() << contentTypeStr << " content type is not supported on display "
+ << std::to_string(display) << ", skipping test";
+ return;
+ }
+
+ EXPECT_TRUE(mComposerClient->setContentType(display, contentType).isOk());
+ EXPECT_TRUE(mComposerClient->setContentType(display, ContentType::NONE).isOk());
+ }
+
+ void Test_setContentType(const ContentType& contentType, const char* contentTypeStr) {
+ for (const auto& display : mDisplays) {
+ std::vector<ContentType> supportedContentTypes;
+ const auto error = mComposerClient->getSupportedContentTypes(display.get(),
+ &supportedContentTypes);
+ EXPECT_TRUE(error.isOk());
+
+ Test_setContentTypeForDisplay(display.get(), supportedContentTypes, contentType,
+ contentTypeStr);
+ }
+ }
+
std::shared_ptr<IComposer> mComposer;
std::shared_ptr<IComposerClient> mComposerClient;
int64_t mInvalidDisplayId;
@@ -129,6 +187,270 @@
}
}
+TEST_P(GraphicsComposerAidlTest, getDisplayConnectionType) {
+ DisplayConnectionType type;
+ EXPECT_FALSE(mComposerClient->getDisplayConnectionType(mInvalidDisplayId, &type).isOk());
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(mComposerClient->getDisplayConnectionType(display.get(), &type).isOk());
+ }
+}
+
+TEST_P(GraphicsComposerAidlTest, getDisplayAttribute) {
+ for (const auto& display : mDisplays) {
+ std::vector<int32_t> configs;
+ mComposerClient->getDisplayConfigs(display.get(), &configs);
+ for (const auto& config : configs) {
+ const std::array<DisplayAttribute, 4> requiredAttributes = {{
+ DisplayAttribute::WIDTH,
+ DisplayAttribute::HEIGHT,
+ DisplayAttribute::VSYNC_PERIOD,
+ DisplayAttribute::CONFIG_GROUP,
+ }};
+ int32_t value;
+ for (const auto& attribute : requiredAttributes) {
+ EXPECT_TRUE(mComposerClient
+ ->getDisplayAttribute(display.get(), config, attribute, &value)
+ .isOk());
+ EXPECT_NE(-1, value);
+ }
+
+ const std::array<DisplayAttribute, 2> optionalAttributes = {{
+ DisplayAttribute::DPI_X,
+ DisplayAttribute::DPI_Y,
+ }};
+ for (const auto& attribute : optionalAttributes) {
+ const auto error = mComposerClient->getDisplayAttribute(display.get(), config,
+ attribute, &value);
+ if (error.isOk()) {
+ EXPECT_EQ(EX_NONE, error.getServiceSpecificError());
+ } else {
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, error.getServiceSpecificError());
+ }
+ }
+ }
+ }
+}
+
+TEST_P(GraphicsComposerAidlTest, checkConfigsAreValid) {
+ for (const auto& display : mDisplays) {
+ std::vector<int32_t> configs;
+ mComposerClient->getDisplayConfigs(display.get(), &configs);
+
+ EXPECT_FALSE(std::any_of(configs.begin(), configs.end(), [](auto config) {
+ return config == IComposerClient::INVALID_CONFIGURATION;
+ }));
+ }
+}
+
+TEST_P(GraphicsComposerAidlTest, getDisplayAttributeConfigsInAGroupDifferOnlyByVsyncPeriod) {
+ struct Resolution {
+ int32_t width;
+ int32_t height;
+ };
+ struct Dpi {
+ int32_t x;
+ int32_t y;
+ };
+ for (const auto& display : mDisplays) {
+ std::vector<int32_t> configs;
+ EXPECT_TRUE(mComposerClient->getDisplayConfigs(display.get(), &configs).isOk());
+ std::unordered_map<int32_t, Resolution> configGroupToResolutionMap;
+ std::unordered_map<int32_t, Dpi> configGroupToDpiMap;
+ for (const auto& config : configs) {
+ int32_t configGroup = -1;
+ EXPECT_TRUE(mComposerClient
+ ->getDisplayAttribute(display.get(), config,
+ DisplayAttribute::CONFIG_GROUP, &configGroup)
+ .isOk());
+ int32_t width = -1;
+ EXPECT_TRUE(mComposerClient
+ ->getDisplayAttribute(display.get(), config,
+ DisplayAttribute::WIDTH, &width)
+ .isOk());
+ int32_t height = -1;
+ EXPECT_TRUE(mComposerClient
+ ->getDisplayAttribute(display.get(), config,
+ DisplayAttribute::HEIGHT, &height)
+ .isOk());
+ if (configGroupToResolutionMap.find(configGroup) == configGroupToResolutionMap.end()) {
+ configGroupToResolutionMap[configGroup] = {width, height};
+ }
+ EXPECT_EQ(configGroupToResolutionMap[configGroup].width, width);
+ EXPECT_EQ(configGroupToResolutionMap[configGroup].height, height);
+
+ int32_t dpiX = -1;
+ mComposerClient->getDisplayAttribute(display.get(), config, DisplayAttribute::DPI_X,
+ &dpiX);
+
+ int32_t dpiY = -1;
+ mComposerClient->getDisplayAttribute(display.get(), config, DisplayAttribute::DPI_Y,
+ &dpiY);
+ if (dpiX == -1 && dpiY == -1) {
+ continue;
+ }
+
+ if (configGroupToDpiMap.find(configGroup) == configGroupToDpiMap.end()) {
+ configGroupToDpiMap[configGroup] = {dpiX, dpiY};
+ }
+ EXPECT_EQ(configGroupToDpiMap[configGroup].x, dpiX);
+ EXPECT_EQ(configGroupToDpiMap[configGroup].y, dpiY);
+ }
+ }
+}
+
+TEST_P(GraphicsComposerAidlTest, getDisplayVsyncPeriod_BadDisplay) {
+ int32_t vsyncPeriodNanos;
+ const auto error = mComposerClient->getDisplayVsyncPeriod(mInvalidDisplayId, &vsyncPeriodNanos);
+ EXPECT_FALSE(error.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+}
+
+TEST_P(GraphicsComposerAidlTest, setActiveConfigWithConstraints_BadDisplay) {
+ VsyncPeriodChangeTimeline timeline;
+ VsyncPeriodChangeConstraints constraints;
+
+ constraints.seamlessRequired = false;
+ constraints.desiredTimeNanos = systemTime();
+ int32_t config = 0;
+ auto const error = mComposerClient->setActiveConfigWithConstraints(mInvalidDisplayId, config,
+ constraints, &timeline);
+
+ EXPECT_FALSE(error.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+}
+
+TEST_P(GraphicsComposerAidlTest, setActiveConfigWithConstraints_BadConfig) {
+ VsyncPeriodChangeTimeline timeline;
+ VsyncPeriodChangeConstraints constraints;
+
+ constraints.seamlessRequired = false;
+ constraints.desiredTimeNanos = systemTime();
+
+ for (VtsDisplay& display : mDisplays) {
+ int32_t invalidConfigId = GetInvalidConfigId();
+ const auto error =
+ setActiveConfigWithConstraints(display, invalidConfigId, constraints, &timeline);
+ EXPECT_FALSE(error.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_CONFIG, error.getServiceSpecificError());
+ }
+}
+
+TEST_P(GraphicsComposerAidlTest, setAutoLowLatencyModeBadDisplay) {
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY,
+ mComposerClient->setAutoLowLatencyMode(mInvalidDisplayId, true)
+ .getServiceSpecificError());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY,
+ mComposerClient->setAutoLowLatencyMode(mInvalidDisplayId, false)
+ .getServiceSpecificError());
+}
+
+TEST_P(GraphicsComposerAidlTest, setAutoLowLatencyMode) {
+ for (const auto& display : mDisplays) {
+ std::vector<DisplayCapability> capabilities;
+ const auto error = mComposerClient->getDisplayCapabilities(display.get(), &capabilities);
+ EXPECT_TRUE(error.isOk());
+
+ const bool allmSupport =
+ std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::AUTO_LOW_LATENCY_MODE) != capabilities.end();
+
+ if (!allmSupport) {
+ const auto errorIsOn = mComposerClient->setAutoLowLatencyMode(display.get(), true);
+ EXPECT_FALSE(errorIsOn.isOk());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errorIsOn.getServiceSpecificError());
+ const auto errorIsOff = mComposerClient->setAutoLowLatencyMode(display.get(), false);
+ EXPECT_FALSE(errorIsOff.isOk());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errorIsOff.getServiceSpecificError());
+ GTEST_SUCCEED() << "Auto Low Latency Mode is not supported on display "
+ << std::to_string(display.get()) << ", skipping test";
+ return;
+ }
+
+ EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.get(), true).isOk());
+ EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.get(), false).isOk());
+ }
+}
+
+TEST_P(GraphicsComposerAidlTest, getSupportedContentTypesBadDisplay) {
+ std::vector<ContentType> supportedContentTypes;
+ const auto error =
+ mComposerClient->getSupportedContentTypes(mInvalidDisplayId, &supportedContentTypes);
+ EXPECT_FALSE(error.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+}
+
+TEST_P(GraphicsComposerAidlTest, getSupportedContentTypes) {
+ std::vector<ContentType> supportedContentTypes;
+ for (const auto& display : mDisplays) {
+ supportedContentTypes.clear();
+ const auto error =
+ mComposerClient->getSupportedContentTypes(display.get(), &supportedContentTypes);
+
+ ASSERT_TRUE(error.isOk());
+
+ const bool noneSupported =
+ std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
+ ContentType::NONE) != supportedContentTypes.end();
+ EXPECT_FALSE(noneSupported);
+ }
+}
+
+TEST_P(GraphicsComposerAidlTest, setContentTypeNoneAlwaysAccepted) {
+ for (const auto& display : mDisplays) {
+ const auto error = mComposerClient->setContentType(display.get(), ContentType::NONE);
+ EXPECT_TRUE(error.isOk());
+ }
+}
+
+TEST_P(GraphicsComposerAidlTest, setContentTypeBadDisplay) {
+ constexpr ContentType types[] = {ContentType::NONE, ContentType::GRAPHICS, ContentType::PHOTO,
+ ContentType::CINEMA, ContentType::GAME};
+ for (const auto& type : types) {
+ auto const error = mComposerClient->setContentType(mInvalidDisplayId, type);
+
+ EXPECT_FALSE(error.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ }
+}
+
+TEST_P(GraphicsComposerAidlTest, setGraphicsContentType) {
+ Test_setContentType(ContentType::GRAPHICS, "GRAPHICS");
+}
+
+TEST_P(GraphicsComposerAidlTest, setPhotoContentType) {
+ Test_setContentType(ContentType::PHOTO, "PHOTO");
+}
+
+TEST_P(GraphicsComposerAidlTest, setCinemaContentType) {
+ Test_setContentType(ContentType::CINEMA, "CINEMA");
+}
+
+TEST_P(GraphicsComposerAidlTest, setGameContentType) {
+ Test_setContentType(ContentType::GAME, "GAME");
+}
+
+TEST_P(GraphicsComposerAidlTest, getLayerGenericMetadataKeys) {
+ std::vector<LayerGenericMetadataKey> keys;
+ EXPECT_TRUE(mComposerClient->getLayerGenericMetadataKeys(&keys).isOk());
+
+ std::regex reverseDomainName("^[a-zA-Z-]{2,}(\\.[a-zA-Z0-9-]+)+$");
+ std::unordered_set<std::string> uniqueNames;
+ for (const auto& key : keys) {
+ std::string name(key.name.c_str());
+
+ // Keys must not start with 'android' or 'com.android'
+ EXPECT_FALSE(name.find("android") == 0);
+ EXPECT_FALSE(name.find("com.android") == 0);
+
+ // Keys must be in reverse domain name format
+ EXPECT_TRUE(std::regex_match(name, reverseDomainName));
+
+ // Keys must be unique within this list
+ const auto& [iter, inserted] = uniqueNames.insert(name);
+ EXPECT_TRUE(inserted);
+ }
+}
+
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
INSTANTIATE_TEST_SUITE_P(
PerInstance, GraphicsComposerAidlTest,