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