1/* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define LOG_TAG "VtsHalGraphicsMapperV2_1TargetTest" 18 19#include <VtsHalHidlTargetTestBase.h> 20#include <android-base/logging.h> 21#include <android/hardware/graphics/mapper/2.1/IMapper.h> 22#include <mapper-vts/2.1/MapperVts.h> 23 24namespace android { 25namespace hardware { 26namespace graphics { 27namespace mapper { 28namespace V2_1 { 29namespace vts { 30namespace { 31 32using android::hardware::graphics::allocator::V2_0::IAllocator; 33using android::hardware::graphics::common::V1_1::BufferUsage; 34using android::hardware::graphics::common::V1_1::PixelFormat; 35using V2_0::Error; 36 37// Test environment for graphics.mapper. 38class GraphicsMapperHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase { 39 public: 40 // get the test environment singleton 41 static GraphicsMapperHidlEnvironment* Instance() { 42 static GraphicsMapperHidlEnvironment* instance = new GraphicsMapperHidlEnvironment; 43 return instance; 44 } 45 46 virtual void registerTestServices() override { 47 registerTestService<IAllocator>(); 48 registerTestService<IMapper>(); 49 } 50}; 51 52class GraphicsMapperHidlTest : public ::testing::VtsHalHidlTargetTestBase { 53 protected: 54 void SetUp() override { 55 ASSERT_NO_FATAL_FAILURE( 56 mGralloc = std::make_unique<Gralloc>( 57 GraphicsMapperHidlEnvironment::Instance()->getServiceName<IAllocator>(), 58 GraphicsMapperHidlEnvironment::Instance()->getServiceName<IMapper>())); 59 60 mDummyDescriptorInfo.width = 64; 61 mDummyDescriptorInfo.height = 64; 62 mDummyDescriptorInfo.layerCount = 1; 63 mDummyDescriptorInfo.format = PixelFormat::RGBA_8888; 64 mDummyDescriptorInfo.usage = 65 static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN); 66 } 67 68 void TearDown() override {} 69 70 std::unique_ptr<Gralloc> mGralloc; 71 IMapper::BufferDescriptorInfo mDummyDescriptorInfo{}; 72}; 73 74/** 75 * Test that IMapper::validateBufferSize works. 76 */ 77TEST_F(GraphicsMapperHidlTest, ValidateBufferSizeBasic) { 78 const native_handle_t* bufferHandle; 79 uint32_t stride; 80 ASSERT_NO_FATAL_FAILURE(bufferHandle = mGralloc->allocate(mDummyDescriptorInfo, true, &stride)); 81 82 ASSERT_TRUE(mGralloc->validateBufferSize(bufferHandle, mDummyDescriptorInfo, stride)); 83 84 ASSERT_NO_FATAL_FAILURE(mGralloc->freeBuffer(bufferHandle)); 85} 86 87/** 88 * Test IMapper::validateBufferSize with invalid buffers. 89 */ 90TEST_F(GraphicsMapperHidlTest, ValidateBufferSizeBadBuffer) { 91 native_handle_t* invalidHandle = nullptr; 92 Error ret = mGralloc->getMapper()->validateBufferSize(invalidHandle, mDummyDescriptorInfo, 93 mDummyDescriptorInfo.width); 94 ASSERT_EQ(Error::BAD_BUFFER, ret) 95 << "validateBufferSize with nullptr did not fail with BAD_BUFFER"; 96 97 invalidHandle = native_handle_create(0, 0); 98 ret = mGralloc->getMapper()->validateBufferSize(invalidHandle, mDummyDescriptorInfo, 99 mDummyDescriptorInfo.width); 100 ASSERT_EQ(Error::BAD_BUFFER, ret) 101 << "validateBufferSize with invalid handle did not fail with BAD_BUFFER"; 102 native_handle_delete(invalidHandle); 103 104 native_handle_t* rawBufferHandle; 105 ASSERT_NO_FATAL_FAILURE(rawBufferHandle = const_cast<native_handle_t*>( 106 mGralloc->allocate(mDummyDescriptorInfo, false))); 107 ret = mGralloc->getMapper()->validateBufferSize(rawBufferHandle, mDummyDescriptorInfo, 108 mDummyDescriptorInfo.width); 109 ASSERT_EQ(Error::BAD_BUFFER, ret) 110 << "validateBufferSize with raw buffer handle did not fail with BAD_BUFFER"; 111 native_handle_delete(rawBufferHandle); 112} 113 114/** 115 * Test IMapper::validateBufferSize with invalid descriptor and/or stride. 116 */ 117TEST_F(GraphicsMapperHidlTest, ValidateBufferSizeBadValue) { 118 auto info = mDummyDescriptorInfo; 119 info.width = 1024; 120 info.height = 1024; 121 info.layerCount = 1; 122 info.format = PixelFormat::RGBA_8888; 123 124 native_handle_t* bufferHandle; 125 uint32_t stride; 126 ASSERT_NO_FATAL_FAILURE( 127 bufferHandle = const_cast<native_handle_t*>(mGralloc->allocate(info, true, &stride))); 128 129 // All checks below test if a 8MB buffer can fit in a 4MB buffer. 130 info.width *= 2; 131 Error ret = mGralloc->getMapper()->validateBufferSize(bufferHandle, info, stride); 132 ASSERT_EQ(Error::BAD_VALUE, ret) 133 << "validateBufferSize with bad width did not fail with BAD_VALUE"; 134 info.width /= 2; 135 136 info.height *= 2; 137 ret = mGralloc->getMapper()->validateBufferSize(bufferHandle, info, stride); 138 ASSERT_EQ(Error::BAD_VALUE, ret) 139 << "validateBufferSize with bad height did not fail with BAD_VALUE"; 140 info.height /= 2; 141 142 info.layerCount *= 2; 143 ret = mGralloc->getMapper()->validateBufferSize(bufferHandle, info, stride); 144 ASSERT_EQ(Error::BAD_VALUE, ret) 145 << "validateBufferSize with bad layer count did not fail with BAD_VALUE"; 146 info.layerCount /= 2; 147 148 info.format = PixelFormat::RGBA_FP16; 149 ret = mGralloc->getMapper()->validateBufferSize(bufferHandle, info, stride); 150 ASSERT_EQ(Error::BAD_VALUE, ret) 151 << "validateBufferSize with bad format did not fail with BAD_VALUE"; 152 info.format = PixelFormat::RGBA_8888; 153 154 ret = mGralloc->getMapper()->validateBufferSize(bufferHandle, mDummyDescriptorInfo, stride * 2); 155 ASSERT_EQ(Error::BAD_VALUE, ret) 156 << "validateBufferSize with bad stride did not fail with BAD_VALUE"; 157 158 ASSERT_NO_FATAL_FAILURE(mGralloc->freeBuffer(bufferHandle)); 159} 160 161/** 162 * Test IMapper::getTransportSize. 163 */ 164TEST_F(GraphicsMapperHidlTest, GetTransportSizeBasic) { 165 const native_handle_t* bufferHandle; 166 uint32_t numFds; 167 uint32_t numInts; 168 ASSERT_NO_FATAL_FAILURE(bufferHandle = mGralloc->allocate(mDummyDescriptorInfo, true)); 169 ASSERT_NO_FATAL_FAILURE(mGralloc->getTransportSize(bufferHandle, &numFds, &numInts)); 170 ASSERT_NO_FATAL_FAILURE(mGralloc->freeBuffer(bufferHandle)); 171} 172 173/** 174 * Test IMapper::getTransportSize with invalid buffers. 175 */ 176TEST_F(GraphicsMapperHidlTest, GetTransportSizeBadBuffer) { 177 native_handle_t* invalidHandle = nullptr; 178 mGralloc->getMapper()->getTransportSize( 179 invalidHandle, [&](const auto& tmpError, const auto&, const auto&) { 180 ASSERT_EQ(Error::BAD_BUFFER, tmpError) 181 << "getTransportSize with nullptr did not fail with BAD_BUFFER"; 182 }); 183 184 invalidHandle = native_handle_create(0, 0); 185 mGralloc->getMapper()->getTransportSize( 186 invalidHandle, [&](const auto& tmpError, const auto&, const auto&) { 187 ASSERT_EQ(Error::BAD_BUFFER, tmpError) 188 << "getTransportSize with invalid handle did not fail with BAD_BUFFER"; 189 }); 190 native_handle_delete(invalidHandle); 191 192 native_handle_t* rawBufferHandle; 193 ASSERT_NO_FATAL_FAILURE(rawBufferHandle = const_cast<native_handle_t*>( 194 mGralloc->allocate(mDummyDescriptorInfo, false))); 195 mGralloc->getMapper()->getTransportSize( 196 invalidHandle, [&](const auto& tmpError, const auto&, const auto&) { 197 ASSERT_EQ(Error::BAD_BUFFER, tmpError) 198 << "getTransportSize with raw buffer handle did not fail with BAD_BUFFER"; 199 }); 200 native_handle_delete(rawBufferHandle); 201} 202 203/** 204 * Test IMapper::createDescriptor with valid descriptor info. 205 */ 206TEST_F(GraphicsMapperHidlTest, CreateDescriptor_2_1Basic) { 207 ASSERT_NO_FATAL_FAILURE(mGralloc->createDescriptor(mDummyDescriptorInfo)); 208} 209 210/** 211 * Test IMapper::createDescriptor with invalid descriptor info. 212 */ 213TEST_F(GraphicsMapperHidlTest, CreateDescriptor_2_1Negative) { 214 auto info = mDummyDescriptorInfo; 215 info.width = 0; 216 mGralloc->getMapper()->createDescriptor_2_1(info, [&](const auto& tmpError, const auto&) { 217 EXPECT_EQ(Error::BAD_VALUE, tmpError) << "createDescriptor did not fail with BAD_VALUE"; 218 }); 219} 220 221} // namespace 222} // namespace vts 223} // namespace V2_1 224} // namespace mapper 225} // namespace graphics 226} // namespace hardware 227} // namespace android 228 229int main(int argc, char** argv) { 230 using android::hardware::graphics::mapper::V2_1::vts::GraphicsMapperHidlEnvironment; 231 ::testing::AddGlobalTestEnvironment(GraphicsMapperHidlEnvironment::Instance()); 232 ::testing::InitGoogleTest(&argc, argv); 233 GraphicsMapperHidlEnvironment::Instance()->init(&argc, argv); 234 235 int status = RUN_ALL_TESTS(); 236 LOG(INFO) << "Test result = " << status; 237 238 return status; 239} 240