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
24 namespace android {
25 namespace hardware {
26 namespace graphics {
27 namespace mapper {
28 namespace V2_1 {
29 namespace vts {
30 namespace {
31
32 using android::hardware::graphics::allocator::V2_0::IAllocator;
33 using android::hardware::graphics::common::V1_1::BufferUsage;
34 using android::hardware::graphics::common::V1_1::PixelFormat;
35 using V2_0::Error;
36
37 // Test environment for graphics.mapper.
38 class GraphicsMapperHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
39 public:
40 // get the test environment singleton
Instance()41 static GraphicsMapperHidlEnvironment* Instance() {
42 static GraphicsMapperHidlEnvironment* instance = new GraphicsMapperHidlEnvironment;
43 return instance;
44 }
45
registerTestServices()46 virtual void registerTestServices() override {
47 registerTestService<IAllocator>();
48 registerTestService<IMapper>();
49 }
50 };
51
52 class GraphicsMapperHidlTest : public ::testing::VtsHalHidlTargetTestBase {
53 protected:
SetUp()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
TearDown()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 */
TEST_F(GraphicsMapperHidlTest,ValidateBufferSizeBasic)77 TEST_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 */
TEST_F(GraphicsMapperHidlTest,ValidateBufferSizeBadBuffer)90 TEST_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 */
TEST_F(GraphicsMapperHidlTest,ValidateBufferSizeBadValue)117 TEST_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 */
TEST_F(GraphicsMapperHidlTest,GetTransportSizeBasic)164 TEST_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 */
TEST_F(GraphicsMapperHidlTest,GetTransportSizeBadBuffer)176 TEST_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 */
TEST_F(GraphicsMapperHidlTest,CreateDescriptor_2_1Basic)206 TEST_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 */
TEST_F(GraphicsMapperHidlTest,CreateDescriptor_2_1Negative)213 TEST_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
main(int argc,char ** argv)229 int 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