Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5255c35a authored by Chia-I Wu's avatar Chia-I Wu
Browse files

graphics: move libVtsHalGraphicsMapperTestUtils 

Move libVtsHalGraphicsMapperTestUtils from 2.0/vts/functional/ to
2.0/utils/vts/.  Run clang-format.

Test: VTS
Change-Id: I1e87129cbdc12167160f7e2f1cd76478e88bbf41
parent 821c4c4a

graphics/mapper/2.0/utils/vts/Android.bp

0 → 100644
+38 −0
Original line number Diff line number Diff line 
//

// Copyright (C) 2016 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.

//



cc_library_static {

    name: "libVtsHalGraphicsMapperTestUtils",

    defaults: ["hidl_defaults"],

    srcs: ["VtsHalGraphicsMapperTestUtils.cpp"],

    cflags: [

        "-O0",

        "-g",

    ],

    shared_libs: [

        "libutils",

    ],

    static_libs: [

        "VtsHalHidlTargetTestBase",

        "android.hardware.graphics.allocator@2.0",

        "android.hardware.graphics.mapper@2.0",

    ],

    export_static_lib_headers: [

        "android.hardware.graphics.allocator@2.0",

        "android.hardware.graphics.mapper@2.0",

    ],

    export_include_dirs: ["."],

}

graphics/mapper/2.0/vts/functional/VtsHalGraphicsMapperTestUtils.cpp→graphics/mapper/2.0/utils/vts/VtsHalGraphicsMapperTestUtils.cpp

+38 −54
Original line number Diff line number Diff line
@@ -50,8 +50,7 @@ Gralloc::~Gralloc() { 


    for (auto bufferHandle : mImportedBuffers) {

        auto buffer = const_cast<native_handle_t*>(bufferHandle);

        EXPECT_EQ(Error::NONE, mMapper->freeBuffer(buffer))

            << "failed to free buffer " << buffer;

        EXPECT_EQ(Error::NONE, mMapper->freeBuffer(buffer)) << "failed to free buffer " << buffer;

    }

    mImportedBuffers.clear();

}
@@ -62,15 +61,13 @@ sp<IAllocator> Gralloc::getAllocator() const { 


std::string Gralloc::dumpDebugInfo() {

    std::string debugInfo;

    mAllocator->dumpDebugInfo(

        [&](const auto& tmpDebugInfo) { debugInfo = tmpDebugInfo.c_str(); });

    mAllocator->dumpDebugInfo([&](const auto& tmpDebugInfo) { debugInfo = tmpDebugInfo.c_str(); });



    return debugInfo;

}



const native_handle_t* Gralloc::cloneBuffer(const hidl_handle& rawHandle) {

    const native_handle_t* bufferHandle =

        native_handle_clone(rawHandle.getNativeHandle());

    const native_handle_t* bufferHandle = native_handle_clone(rawHandle.getNativeHandle());

    EXPECT_NE(nullptr, bufferHandle);



    if (bufferHandle) {
@@ -80,24 +77,22 @@ const native_handle_t* Gralloc::cloneBuffer(const hidl_handle& rawHandle) { 
    return bufferHandle;

}



std::vector<const native_handle_t*> Gralloc::allocate(

    const BufferDescriptor& descriptor, uint32_t count, bool import,

std::vector<const native_handle_t*> Gralloc::allocate(const BufferDescriptor& descriptor,

                                                      uint32_t count, bool import,

                                                      uint32_t* outStride) {

    std::vector<const native_handle_t*> bufferHandles;

    bufferHandles.reserve(count);

    mAllocator->allocate(

        descriptor, count, [&](const auto& tmpError, const auto& tmpStride,

                               const auto& tmpBuffers) {

        descriptor, count,

        [&](const auto& tmpError, const auto& tmpStride, const auto& tmpBuffers) {

            ASSERT_EQ(Error::NONE, tmpError) << "failed to allocate buffers";

            ASSERT_EQ(count, tmpBuffers.size()) << "invalid buffer array";



            for (uint32_t i = 0; i < count; i++) {

                if (import) {

                    ASSERT_NO_FATAL_FAILURE(

                        bufferHandles.push_back(importBuffer(tmpBuffers[i])));

                    ASSERT_NO_FATAL_FAILURE(bufferHandles.push_back(importBuffer(tmpBuffers[i])));

                } else {

                    ASSERT_NO_FATAL_FAILURE(

                        bufferHandles.push_back(cloneBuffer(tmpBuffers[i])));

                    ASSERT_NO_FATAL_FAILURE(bufferHandles.push_back(cloneBuffer(tmpBuffers[i])));

                }

            }
@@ -113,9 +108,8 @@ std::vector<const native_handle_t*> Gralloc::allocate( 
    return bufferHandles;

}



const native_handle_t* Gralloc::allocate(

    const IMapper::BufferDescriptorInfo& descriptorInfo, bool import,

    uint32_t* outStride) {

const native_handle_t* Gralloc::allocate(const IMapper::BufferDescriptorInfo& descriptorInfo,

                                         bool import, uint32_t* outStride) {

    BufferDescriptor descriptor = createDescriptor(descriptorInfo);

    if (::testing::Test::HasFatalFailure()) {

        return nullptr;
@@ -133,11 +127,9 @@ sp<IMapper> Gralloc::getMapper() const { 
    return mMapper;

}



BufferDescriptor Gralloc::createDescriptor(

    const IMapper::BufferDescriptorInfo& descriptorInfo) {

BufferDescriptor Gralloc::createDescriptor(const IMapper::BufferDescriptorInfo& descriptorInfo) {

    BufferDescriptor descriptor;

    mMapper->createDescriptor(

        descriptorInfo, [&](const auto& tmpError, const auto& tmpDescriptor) {

    mMapper->createDescriptor(descriptorInfo, [&](const auto& tmpError, const auto& tmpDescriptor) {

        ASSERT_EQ(Error::NONE, tmpError) << "failed to create descriptor";

        descriptor = tmpDescriptor;

    });
@@ -147,10 +139,9 @@ BufferDescriptor Gralloc::createDescriptor( 


const native_handle_t* Gralloc::importBuffer(const hidl_handle& rawHandle) {

    const native_handle_t* bufferHandle = nullptr;

    mMapper->importBuffer(

        rawHandle, [&](const auto& tmpError, const auto& tmpBuffer) {

            ASSERT_EQ(Error::NONE, tmpError) << "failed to import buffer %p"

                                             << rawHandle.getNativeHandle();

    mMapper->importBuffer(rawHandle, [&](const auto& tmpError, const auto& tmpBuffer) {

        ASSERT_EQ(Error::NONE, tmpError)

            << "failed to import buffer %p" << rawHandle.getNativeHandle();

        bufferHandle = static_cast<const native_handle_t*>(tmpBuffer);

    });
@@ -189,8 +180,7 @@ void* Gralloc::lock(const native_handle_t* bufferHandle, uint64_t cpuUsage, 
    void* data = nullptr;

    mMapper->lock(buffer, cpuUsage, accessRegion, acquireFenceHandle,

                  [&](const auto& tmpError, const auto& tmpData) {

                      ASSERT_EQ(Error::NONE, tmpError)

                          << "failed to lock buffer " << buffer;

                      ASSERT_EQ(Error::NONE, tmpError) << "failed to lock buffer " << buffer;

                      data = tmpData;

                  });
@@ -201,10 +191,8 @@ void* Gralloc::lock(const native_handle_t* bufferHandle, uint64_t cpuUsage, 
    return data;

}



YCbCrLayout Gralloc::lockYCbCr(const native_handle_t* bufferHandle,

                               uint64_t cpuUsage,

                               const IMapper::Rect& accessRegion,

                               int acquireFence) {

YCbCrLayout Gralloc::lockYCbCr(const native_handle_t* bufferHandle, uint64_t cpuUsage,

                               const IMapper::Rect& accessRegion, int acquireFence) {

    auto buffer = const_cast<native_handle_t*>(bufferHandle);



    NATIVE_HANDLE_DECLARE_STORAGE(acquireFenceStorage, 1, 0);
@@ -234,21 +222,17 @@ int Gralloc::unlock(const native_handle_t* bufferHandle) { 
    auto buffer = const_cast<native_handle_t*>(bufferHandle);



    int releaseFence = -1;

    mMapper->unlock(

        buffer, [&](const auto& tmpError, const auto& tmpReleaseFence) {

            ASSERT_EQ(Error::NONE, tmpError) << "failed to unlock buffer "

                                             << buffer;

    mMapper->unlock(buffer, [&](const auto& tmpError, const auto& tmpReleaseFence) {

        ASSERT_EQ(Error::NONE, tmpError) << "failed to unlock buffer " << buffer;



        auto fenceHandle = tmpReleaseFence.getNativeHandle();

        if (fenceHandle) {

                ASSERT_EQ(0, fenceHandle->numInts) << "invalid fence handle "

                                                   << fenceHandle;

            ASSERT_EQ(0, fenceHandle->numInts) << "invalid fence handle " << fenceHandle;

            if (fenceHandle->numFds == 1) {

                releaseFence = dup(fenceHandle->data[0]);

                ASSERT_LT(0, releaseFence) << "failed to dup fence fd";

            } else {

                    ASSERT_EQ(0, fenceHandle->numFds)

                        << " invalid fence handle " << fenceHandle;

                ASSERT_EQ(0, fenceHandle->numFds) << " invalid fence handle " << fenceHandle;

            }

        }

    });

graphics/mapper/2.0/vts/functional/VtsHalGraphicsMapperTestUtils.h→graphics/mapper/2.0/utils/vts/VtsHalGraphicsMapperTestUtils.h

+7 −11
Original line number Diff line number Diff line
@@ -49,19 +49,16 @@ class Gralloc { 
    // is true, the returned buffers are also imported into the mapper.

    //

    // Either case, the returned buffers must be freed with freeBuffer.

    std::vector<const native_handle_t*> allocate(

        const BufferDescriptor& descriptor, uint32_t count, bool import = true,

        uint32_t* outStride = nullptr);

    const native_handle_t* allocate(

        const IMapper::BufferDescriptorInfo& descriptorInfo, bool import = true,

        uint32_t* outStride = nullptr);

    std::vector<const native_handle_t*> allocate(const BufferDescriptor& descriptor, uint32_t count,

                                                 bool import = true, uint32_t* outStride = nullptr);

    const native_handle_t* allocate(const IMapper::BufferDescriptorInfo& descriptorInfo,

                                    bool import = true, uint32_t* outStride = nullptr);



    // IMapper methods



    sp<IMapper> getMapper() const;



    BufferDescriptor createDescriptor(

        const IMapper::BufferDescriptorInfo& descriptorInfo);

    BufferDescriptor createDescriptor(const IMapper::BufferDescriptorInfo& descriptorInfo);



    const native_handle_t* importBuffer(const hidl_handle& rawHandle);

    void freeBuffer(const native_handle_t* bufferHandle);
@@ -71,9 +68,8 @@ class Gralloc { 
    // with each of these functions.

    void* lock(const native_handle_t* bufferHandle, uint64_t cpuUsage,

               const IMapper::Rect& accessRegion, int acquireFence);

    YCbCrLayout lockYCbCr(const native_handle_t* bufferHandle,

                          uint64_t cpuUsage, const IMapper::Rect& accessRegion,

                          int acquireFence);

    YCbCrLayout lockYCbCr(const native_handle_t* bufferHandle, uint64_t cpuUsage,

                          const IMapper::Rect& accessRegion, int acquireFence);

    int unlock(const native_handle_t* bufferHandle);



   private:

graphics/mapper/2.0/vts/functional/Android.bp

+0 −21
Original line number Diff line number Diff line
@@ -14,27 +14,6 @@ 
// limitations under the License.

//



cc_library_static {

    name: "libVtsHalGraphicsMapperTestUtils",

    defaults: ["hidl_defaults"],

    srcs: ["VtsHalGraphicsMapperTestUtils.cpp"],

    shared_libs: [

        "android.hardware.graphics.allocator@2.0",

        "android.hardware.graphics.mapper@2.0",

    ],

    static_libs: [

        "VtsHalHidlTargetTestBase",

    ],

    cflags: [

        "-Wall",

        "-Wextra",

        "-Werror",

        "-O0",

        "-g",

    ],

    export_include_dirs: ["."],

}



cc_test {

    name: "VtsHalGraphicsMapperV2_0TargetTest",

    defaults: ["VtsHalTargetTestDefaults"],

graphics/mapper/2.0/vts/functional/VtsHalGraphicsMapperV2_0TargetTest.cpp

+62 −84
Original line number Diff line number Diff line
@@ -41,8 +41,8 @@ class GraphicsMapperHidlTest : public ::testing::VtsHalHidlTargetTestBase { 
        mDummyDescriptorInfo.height = 64;

        mDummyDescriptorInfo.layerCount = 1;

        mDummyDescriptorInfo.format = PixelFormat::RGBA_8888;

      mDummyDescriptorInfo.usage = static_cast<uint64_t>(

          BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN);

        mDummyDescriptorInfo.usage =

            static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN);

    }



    void TearDown() override {}
@@ -63,18 +63,16 @@ TEST_F(GraphicsMapperHidlTest, AllocatorDumpDebugInfo) { 
 */

TEST_F(GraphicsMapperHidlTest, AllocatorAllocate) {

    BufferDescriptor descriptor;

    ASSERT_NO_FATAL_FAILURE(

        descriptor = mGralloc->createDescriptor(mDummyDescriptorInfo));

    ASSERT_NO_FATAL_FAILURE(descriptor = mGralloc->createDescriptor(mDummyDescriptorInfo));



    for (uint32_t count = 0; count < 5; count++) {

        std::vector<const native_handle_t*> bufferHandles;

        uint32_t stride;

        ASSERT_NO_FATAL_FAILURE(bufferHandles = mGralloc->allocate(

                                    descriptor, count, false, &stride));

        ASSERT_NO_FATAL_FAILURE(bufferHandles =

                                    mGralloc->allocate(descriptor, count, false, &stride));



        if (count >= 1) {

            EXPECT_LE(mDummyDescriptorInfo.width, stride)

                << "invalid buffer stride";

            EXPECT_LE(mDummyDescriptorInfo.width, stride) << "invalid buffer stride";

        }



        for (auto bufferHandle : bufferHandles) {
@@ -89,8 +87,8 @@ TEST_F(GraphicsMapperHidlTest, AllocatorAllocate) { 
TEST_F(GraphicsMapperHidlTest, AllocatorAllocateNegative) {

    // this assumes any valid descriptor is non-empty

    BufferDescriptor descriptor;

    mGralloc->getAllocator()->allocate(

        descriptor, 1, [&](const auto& tmpError, const auto&, const auto&) {

    mGralloc->getAllocator()->allocate(descriptor, 1,

                                       [&](const auto& tmpError, const auto&, const auto&) {

                                           EXPECT_EQ(Error::BAD_DESCRIPTOR, tmpError);

                                       });

}
@@ -122,10 +120,8 @@ TEST_F(GraphicsMapperHidlTest, CreateDescriptorBasic) { 
TEST_F(GraphicsMapperHidlTest, CreateDescriptorNegative) {

    auto info = mDummyDescriptorInfo;

    info.width = 0;

    mGralloc->getMapper()->createDescriptor(

        info, [&](const auto& tmpError, const auto&) {

            EXPECT_EQ(Error::BAD_VALUE, tmpError)

                << "createDescriptor did not fail with BAD_VALUE";

    mGralloc->getMapper()->createDescriptor(info, [&](const auto& tmpError, const auto&) {

        EXPECT_EQ(Error::BAD_VALUE, tmpError) << "createDescriptor did not fail with BAD_VALUE";

    });

}
@@ -134,8 +130,7 @@ TEST_F(GraphicsMapperHidlTest, CreateDescriptorNegative) { 
 */

TEST_F(GraphicsMapperHidlTest, ImportFreeBufferBasic) {

    const native_handle_t* bufferHandle;

    ASSERT_NO_FATAL_FAILURE(bufferHandle =

                                mGralloc->allocate(mDummyDescriptorInfo, true));

    ASSERT_NO_FATAL_FAILURE(bufferHandle = mGralloc->allocate(mDummyDescriptorInfo, true));

    ASSERT_NO_FATAL_FAILURE(mGralloc->freeBuffer(bufferHandle));

}
@@ -144,16 +139,13 @@ TEST_F(GraphicsMapperHidlTest, ImportFreeBufferBasic) { 
 */

TEST_F(GraphicsMapperHidlTest, ImportFreeBufferClone) {

    const native_handle_t* clonedBufferHandle;

    ASSERT_NO_FATAL_FAILURE(

        clonedBufferHandle = mGralloc->allocate(mDummyDescriptorInfo, false));

    ASSERT_NO_FATAL_FAILURE(clonedBufferHandle = mGralloc->allocate(mDummyDescriptorInfo, false));



    // A cloned handle is a raw handle. Check that we can import it multiple

    // times.

    const native_handle_t* importedBufferHandles[2];

    ASSERT_NO_FATAL_FAILURE(importedBufferHandles[0] =

                                mGralloc->importBuffer(clonedBufferHandle));

    ASSERT_NO_FATAL_FAILURE(importedBufferHandles[1] =

                                mGralloc->importBuffer(clonedBufferHandle));

    ASSERT_NO_FATAL_FAILURE(importedBufferHandles[0] = mGralloc->importBuffer(clonedBufferHandle));

    ASSERT_NO_FATAL_FAILURE(importedBufferHandles[1] = mGralloc->importBuffer(clonedBufferHandle));

    ASSERT_NO_FATAL_FAILURE(mGralloc->freeBuffer(importedBufferHandles[0]));

    ASSERT_NO_FATAL_FAILURE(mGralloc->freeBuffer(importedBufferHandles[1]));
@@ -165,12 +157,10 @@ TEST_F(GraphicsMapperHidlTest, ImportFreeBufferClone) { 
 */

TEST_F(GraphicsMapperHidlTest, ImportFreeBufferSingleton) {

    const native_handle_t* rawHandle;

    ASSERT_NO_FATAL_FAILURE(

        rawHandle = mGralloc->allocate(mDummyDescriptorInfo, false));

    ASSERT_NO_FATAL_FAILURE(rawHandle = mGralloc->allocate(mDummyDescriptorInfo, false));



    native_handle_t* importedHandle = nullptr;

    mGralloc->getMapper()->importBuffer(

        rawHandle, [&](const auto& tmpError, const auto& buffer) {

    mGralloc->getMapper()->importBuffer(rawHandle, [&](const auto& tmpError, const auto& buffer) {

        ASSERT_EQ(Error::NONE, tmpError);

        importedHandle = static_cast<native_handle_t*>(buffer);

    });
@@ -203,15 +193,13 @@ TEST_F(GraphicsMapperHidlTest, ImportFreeBufferNoLeak) { 
 */

TEST_F(GraphicsMapperHidlTest, ImportBufferNegative) {

    native_handle_t* invalidHandle = nullptr;

    mGralloc->getMapper()->importBuffer(

        invalidHandle, [&](const auto& tmpError, const auto&) {

    mGralloc->getMapper()->importBuffer(invalidHandle, [&](const auto& tmpError, const auto&) {

        EXPECT_EQ(Error::BAD_BUFFER, tmpError)

            << "importBuffer with nullptr did not fail with BAD_BUFFER";

    });



    invalidHandle = native_handle_create(0, 0);

    mGralloc->getMapper()->importBuffer(invalidHandle, [&](const auto& tmpError,

                                                           const auto&) {

    mGralloc->getMapper()->importBuffer(invalidHandle, [&](const auto& tmpError, const auto&) {

        EXPECT_EQ(Error::BAD_BUFFER, tmpError)

            << "importBuffer with invalid handle did not fail with BAD_BUFFER";

    });
@@ -224,8 +212,7 @@ TEST_F(GraphicsMapperHidlTest, ImportBufferNegative) { 
TEST_F(GraphicsMapperHidlTest, FreeBufferNegative) {

    native_handle_t* invalidHandle = nullptr;

    Error error = mGralloc->getMapper()->freeBuffer(invalidHandle);

    EXPECT_EQ(Error::BAD_BUFFER, error)

        << "freeBuffer with nullptr did not fail with BAD_BUFFER";

    EXPECT_EQ(Error::BAD_BUFFER, error) << "freeBuffer with nullptr did not fail with BAD_BUFFER";



    invalidHandle = native_handle_create(0, 0);

    error = mGralloc->getMapper()->freeBuffer(invalidHandle);
@@ -234,8 +221,7 @@ TEST_F(GraphicsMapperHidlTest, FreeBufferNegative) { 
    native_handle_delete(invalidHandle);



    const native_handle_t* clonedBufferHandle;

    ASSERT_NO_FATAL_FAILURE(

        clonedBufferHandle = mGralloc->allocate(mDummyDescriptorInfo, false));

    ASSERT_NO_FATAL_FAILURE(clonedBufferHandle = mGralloc->allocate(mDummyDescriptorInfo, false));

    error = mGralloc->getMapper()->freeBuffer(invalidHandle);

    EXPECT_EQ(Error::BAD_BUFFER, error)

        << "freeBuffer with un-imported handle did not fail with BAD_BUFFER";
@@ -251,16 +237,15 @@ TEST_F(GraphicsMapperHidlTest, LockUnlockBasic) { 


    const native_handle_t* bufferHandle;

    uint32_t stride;

    ASSERT_NO_FATAL_FAILURE(bufferHandle =

                                mGralloc->allocate(info, true, &stride));

    ASSERT_NO_FATAL_FAILURE(bufferHandle = mGralloc->allocate(info, true, &stride));



    // lock buffer for writing

    const IMapper::Rect region{0, 0, static_cast<int32_t>(info.width),

                               static_cast<int32_t>(info.height)};

    int fence = -1;

    uint8_t* data;

    ASSERT_NO_FATAL_FAILURE(data = static_cast<uint8_t*>(mGralloc->lock(

                                bufferHandle, info.usage, region, fence)));

    ASSERT_NO_FATAL_FAILURE(

        data = static_cast<uint8_t*>(mGralloc->lock(bufferHandle, info.usage, region, fence)));



    // RGBA_8888

    size_t strideInBytes = stride * 4;
@@ -274,8 +259,8 @@ TEST_F(GraphicsMapperHidlTest, LockUnlockBasic) { 
    ASSERT_NO_FATAL_FAILURE(fence = mGralloc->unlock(bufferHandle));



    // lock again for reading

    ASSERT_NO_FATAL_FAILURE(data = static_cast<uint8_t*>(mGralloc->lock(

                                bufferHandle, info.usage, region, fence)));

    ASSERT_NO_FATAL_FAILURE(

        data = static_cast<uint8_t*>(mGralloc->lock(bufferHandle, info.usage, region, fence)));

    for (uint32_t y = 0; y < info.height; y++) {

        for (size_t i = 0; i < writeInBytes; i++) {

            EXPECT_EQ(static_cast<uint8_t>(y), data[i]);
@@ -299,16 +284,14 @@ TEST_F(GraphicsMapperHidlTest, LockYCbCrBasic) { 


    const native_handle_t* bufferHandle;

    uint32_t stride;

    ASSERT_NO_FATAL_FAILURE(bufferHandle =

                                mGralloc->allocate(info, true, &stride));

    ASSERT_NO_FATAL_FAILURE(bufferHandle = mGralloc->allocate(info, true, &stride));



    // lock buffer for writing

    const IMapper::Rect region{0, 0, static_cast<int32_t>(info.width),

                               static_cast<int32_t>(info.height)};

    int fence = -1;

    YCbCrLayout layout;

    ASSERT_NO_FATAL_FAILURE(

        layout = mGralloc->lockYCbCr(bufferHandle, info.usage, region, fence));

    ASSERT_NO_FATAL_FAILURE(layout = mGralloc->lockYCbCr(bufferHandle, info.usage, region, fence));



    auto yData = static_cast<uint8_t*>(layout.y);

    auto cbData = static_cast<uint8_t*>(layout.cb);
@@ -328,8 +311,7 @@ TEST_F(GraphicsMapperHidlTest, LockYCbCrBasic) { 
    ASSERT_NO_FATAL_FAILURE(fence = mGralloc->unlock(bufferHandle));



    // lock again for reading

    ASSERT_NO_FATAL_FAILURE(

        layout = mGralloc->lockYCbCr(bufferHandle, info.usage, region, fence));

    ASSERT_NO_FATAL_FAILURE(layout = mGralloc->lockYCbCr(bufferHandle, info.usage, region, fence));



    yData = static_cast<uint8_t*>(layout.y);

    cbData = static_cast<uint8_t*>(layout.cb);
@@ -357,25 +339,21 @@ TEST_F(GraphicsMapperHidlTest, LockYCbCrBasic) { 
 */

TEST_F(GraphicsMapperHidlTest, UnlockNegative) {

    native_handle_t* invalidHandle = nullptr;

    mGralloc->getMapper()->unlock(

        invalidHandle, [&](const auto& tmpError, const auto&) {

    mGralloc->getMapper()->unlock(invalidHandle, [&](const auto& tmpError, const auto&) {

        EXPECT_EQ(Error::BAD_BUFFER, tmpError)

            << "unlock with nullptr did not fail with BAD_BUFFER";

    });



    invalidHandle = native_handle_create(0, 0);

    mGralloc->getMapper()->unlock(

        invalidHandle, [&](const auto& tmpError, const auto&) {

    mGralloc->getMapper()->unlock(invalidHandle, [&](const auto& tmpError, const auto&) {

        EXPECT_EQ(Error::BAD_BUFFER, tmpError)

            << "unlock with invalid handle did not fail with BAD_BUFFER";

    });

    native_handle_delete(invalidHandle);



    ASSERT_NO_FATAL_FAILURE(invalidHandle =

                                const_cast<native_handle_t*>(mGralloc->allocate(

                                    mDummyDescriptorInfo, false)));

    mGralloc->getMapper()->unlock(invalidHandle, [&](const auto& tmpError,

                                                     const auto&) {

    ASSERT_NO_FATAL_FAILURE(invalidHandle = const_cast<native_handle_t*>(

                                mGralloc->allocate(mDummyDescriptorInfo, false)));

    mGralloc->getMapper()->unlock(invalidHandle, [&](const auto& tmpError, const auto&) {

        EXPECT_EQ(Error::BAD_BUFFER, tmpError)

            << "unlock with un-imported handle did not fail with BAD_BUFFER";

    });