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

Commit e86947e8 authored by Chia-I Wu's avatar Chia-I Wu Committed by Android (Google) Code Review
Browse files

Merge changes Iae143d11,I400c347b,I0639df17,I6d56160d 

* changes:
  graphics: add a basic test for IMapper::lockFlex
  graphics: clean up composer VTS tests
  graphics: clean up mapper VTS tests
  graphics: clean up allocator VTS tests
parents 858a0329 c2e949ec

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

+26 −1
Original line number Diff line number Diff line
@@ -14,6 +14,25 @@ 
// limitations under the License.

//



cc_library_static {

    name: "libVtsHalGraphicsAllocatorTestUtils",

    srcs: ["VtsHalGraphicsAllocatorTestUtils.cpp"],

    shared_libs: [

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

    ],

    static_libs: [

        "VtsHalHidlTargetBaseTest",

    ],

    cflags: [

        "-Wall",

        "-Wextra",

        "-Werror",

        "-O0",

        "-g",

    ],

    export_include_dirs: ["."],

}



cc_test {

    name: "VtsHalGraphicsAllocatorV2_0TargetTest",

    srcs: ["VtsHalGraphicsAllocatorV2_0TargetTest.cpp"],
@@ -27,8 +46,14 @@ cc_test { 
        "libutils",

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

    ],

    static_libs: ["VtsHalHidlTargetBaseTest"],

    static_libs: [

        "libVtsHalGraphicsAllocatorTestUtils",

        "VtsHalHidlTargetBaseTest",

    ],

    cflags: [

        "-Wall",

        "-Wextra",

        "-Werror",

        "-O0",

        "-g",

    ]

graphics/allocator/2.0/vts/functional/VtsHalGraphicsAllocatorTestUtils.cpp

0 → 100644
+183 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 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.

 */



#include <VtsHalHidlTargetBaseTest.h>



#include "VtsHalGraphicsAllocatorTestUtils.h"



namespace android {

namespace hardware {

namespace graphics {

namespace allocator {

namespace V2_0 {

namespace tests {



Allocator::Allocator() { init(); }



void Allocator::init() {

  mAllocator = ::testing::VtsHalHidlTargetBaseTest::getService<IAllocator>();

  ASSERT_NE(nullptr, mAllocator.get()) << "failed to get allocator service";



  std::vector<IAllocator::Capability> capabilities = getCapabilities();

  mCapabilities.insert(capabilities.begin(), capabilities.end());

}



sp<IAllocator> Allocator::getRaw() const { return mAllocator; }



bool Allocator::hasCapability(IAllocator::Capability capability) const {

  return mCapabilities.count(capability) > 0;

}



std::vector<IAllocator::Capability> Allocator::getCapabilities() {

  std::vector<IAllocator::Capability> capabilities;

  mAllocator->getCapabilities(

      [&](const auto& tmpCapabilities) { capabilities = tmpCapabilities; });



  return capabilities;

}



std::string Allocator::dumpDebugInfo() {

  std::string debugInfo;

  mAllocator->dumpDebugInfo(

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



  return debugInfo;

}



std::unique_ptr<AllocatorClient> Allocator::createClient() {

  std::unique_ptr<AllocatorClient> client;

  mAllocator->createClient([&](const auto& tmpError, const auto& tmpClient) {

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

    client = std::make_unique<AllocatorClient>(tmpClient);

  });



  return client;

}



AllocatorClient::AllocatorClient(const sp<IAllocatorClient>& client)

    : mClient(client) {}



AllocatorClient::~AllocatorClient() {

  for (auto buffer : mBuffers) {

    EXPECT_EQ(Error::NONE, mClient->free(buffer))

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

  }

  mBuffers.clear();



  for (auto descriptor : mDescriptors) {

    EXPECT_EQ(Error::NONE, mClient->destroyDescriptor(descriptor))

        << "failed to destroy descriptor " << descriptor;

  }

  mDescriptors.clear();

}



sp<IAllocatorClient> AllocatorClient::getRaw() const { return mClient; }



BufferDescriptor AllocatorClient::createDescriptor(

    const IAllocatorClient::BufferDescriptorInfo& info) {

  BufferDescriptor descriptor = 0;

  mClient->createDescriptor(

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

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

        descriptor = tmpDescriptor;



        EXPECT_TRUE(mDescriptors.insert(descriptor).second)

            << "duplicated descriptor id " << descriptor;

      });



  return descriptor;

}



void AllocatorClient::destroyDescriptor(BufferDescriptor descriptor) {

  ASSERT_EQ(Error::NONE, mClient->destroyDescriptor(descriptor))

      << "failed to destroy descriptor " << descriptor;



  mDescriptors.erase(descriptor);

}



Error AllocatorClient::testAllocate(

    const std::vector<BufferDescriptor>& descriptors) {

  return mClient->testAllocate(descriptors);

}



bool AllocatorClient::testAllocate(BufferDescriptor descriptor) {

  std::vector<BufferDescriptor> descriptors(1, descriptor);

  Error error = testAllocate(descriptors);

  return (error == Error::NONE || error == Error::NOT_SHARED);

}



Error AllocatorClient::allocate(

    const std::vector<BufferDescriptor>& descriptors,

    std::vector<Buffer>& buffers) {

  Error error = Error::NO_RESOURCES;

  mClient->allocate(descriptors, [&](const auto& tmpError,

                                     const auto& tmpBuffers) {

    ASSERT_TRUE(tmpError == Error::NONE || tmpError == Error::NOT_SHARED)

        << "failed to allocate buffer";

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



    error = tmpError;

    buffers = tmpBuffers;



    for (auto buffer : buffers) {

      EXPECT_TRUE(mBuffers.insert(buffer).second)

          << "duplicated buffer id " << buffer;

    }

  });



  return error;

}



Buffer AllocatorClient::allocate(BufferDescriptor descriptor) {

  std::vector<BufferDescriptor> descriptors(1, descriptor);

  std::vector<Buffer> buffers;

  allocate(descriptors, buffers);

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

    return 0;

  }



  return buffers[0];

}



void AllocatorClient::free(Buffer buffer) {

  ASSERT_EQ(Error::NONE, mClient->free(buffer))

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



  mBuffers.erase(buffer);

}



native_handle_t* AllocatorClient::exportHandle(BufferDescriptor descriptor,

                                               Buffer buffer) {

  native_handle_t* handle;

  mClient->exportHandle(

      descriptor, buffer, [&](const auto& tmpError, const auto& tmpHandle) {

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

        ASSERT_NE(nullptr, tmpHandle.getNativeHandle())

            << "invalid buffer handle";



        handle = native_handle_clone(tmpHandle.getNativeHandle());

        ASSERT_NE(nullptr, handle) << "failed to clone handle";

      });



  return handle;

}



}  // namespace tests

}  // namespace V2_0

}  // namespace allocator

}  // namespace graphics

}  // namespace hardware

}  // namespace android

graphics/allocator/2.0/vts/functional/VtsHalGraphicsAllocatorTestUtils.h

0 → 100644
+98 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 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.

 */



#ifndef VTS_HAL_GRAPHICS_ALLOCATOR_UTILS

#define VTS_HAL_GRAPHICS_ALLOCATOR_UTILS



#include <memory>

#include <string>

#include <unordered_set>

#include <vector>



#include <android/hardware/graphics/allocator/2.0/IAllocator.h>

#include <utils/StrongPointer.h>



namespace android {

namespace hardware {

namespace graphics {

namespace allocator {

namespace V2_0 {

namespace tests {



class AllocatorClient;



// A wrapper to IAllocator.

class Allocator {

 public:

  Allocator();



  sp<IAllocator> getRaw() const;



  // Returns true when the allocator supports the specified capability.

  bool hasCapability(IAllocator::Capability capability) const;



  std::vector<IAllocator::Capability> getCapabilities();

  std::string dumpDebugInfo();

  std::unique_ptr<AllocatorClient> createClient();



 private:

  void init();



  sp<IAllocator> mAllocator;

  std::unordered_set<IAllocator::Capability> mCapabilities;

};



// A wrapper to IAllocatorClient.

class AllocatorClient {

 public:

  AllocatorClient(const sp<IAllocatorClient>& client);

  ~AllocatorClient();



  sp<IAllocatorClient> getRaw() const;



  BufferDescriptor createDescriptor(

      const IAllocatorClient::BufferDescriptorInfo& info);

  void destroyDescriptor(BufferDescriptor descriptor);



  Error testAllocate(const std::vector<BufferDescriptor>& descriptors);

  bool testAllocate(BufferDescriptor descriptor);



  Error allocate(const std::vector<BufferDescriptor>& descriptors,

                 std::vector<Buffer>& buffers);

  Buffer allocate(BufferDescriptor descriptor);

  void free(Buffer buffer);



  // Returns a handle to the buffer.  The ownership of the handle is

  // transferred to the caller.

  native_handle_t* exportHandle(BufferDescriptor descriptor, Buffer buffer);



 private:

  sp<IAllocatorClient> mClient;



  // Keep track of all descriptors and buffers.  When a test fails with

  // ASSERT_*, the destructor will clean up the resources for the test.

  std::unordered_set<BufferDescriptor> mDescriptors;

  std::unordered_set<Buffer> mBuffers;

};



}  // namespace tests

}  // namespace V2_0

}  // namespace allocator

}  // namespace graphics

}  // namespace hardware

}  // namespace android



#endif  // VTS_HAL_GRAPHICS_ALLOCATOR_UTILS

graphics/allocator/2.0/vts/functional/VtsHalGraphicsAllocatorV2_0TargetTest.cpp

+46 −173
Original line number Diff line number Diff line
@@ -16,12 +16,11 @@ 


#define LOG_TAG "graphics_allocator_hidl_hal_test"



#include <unordered_set>



#include <android-base/logging.h>

#include <android/hardware/graphics/allocator/2.0/IAllocator.h>

#include <VtsHalHidlTargetBaseTest.h>



#include "VtsHalGraphicsAllocatorTestUtils.h"



namespace android {

namespace hardware {

namespace graphics {
@@ -34,55 +33,18 @@ using android::hardware::graphics::common::V1_0::PixelFormat; 


#define CHECK_FEATURE_OR_SKIP(FEATURE_NAME)                 \

  do {                                                      \

    if (!hasCapability(FEATURE_NAME)) {                     \

    if (!mAllocator->hasCapability(FEATURE_NAME)) {         \

      std::cout << "[  SKIPPED ] Feature " << #FEATURE_NAME \

                << " not supported" << std::endl;           \

      return;                                               \

    }                                                       \

  } while (0)



class TempDescriptor {

 public:

  TempDescriptor(const sp<IAllocatorClient>& client,

                 const IAllocatorClient::BufferDescriptorInfo& info)

      : mClient(client), mError(Error::NO_RESOURCES) {

    mClient->createDescriptor(

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

          mError = tmpError;

          mDescriptor = tmpDescriptor;

        });

  }



  ~TempDescriptor() {

    if (mError == Error::NONE) {

      mClient->destroyDescriptor(mDescriptor);

    }

  }



  bool isValid() const { return (mError == Error::NONE); }



  operator BufferDescriptor() const { return mDescriptor; }



 private:

  sp<IAllocatorClient> mClient;

  Error mError;

  BufferDescriptor mDescriptor;

};



class GraphicsAllocatorHidlTest : public ::testing::VtsHalHidlTargetBaseTest {

 protected:

  void SetUp() override {

    mAllocator = ::testing::VtsHalHidlTargetBaseTest::getService<IAllocator>();

    ASSERT_NE(mAllocator, nullptr);



    mAllocator->createClient([this](const auto& error, const auto& client) {

      if (error == Error::NONE) {

        mClient = client;

      }

    });

    ASSERT_NE(mClient, nullptr);



    initCapabilities();

    ASSERT_NO_FATAL_FAILURE(mAllocator = std::make_unique<Allocator>());

    ASSERT_NO_FATAL_FAILURE(mClient = mAllocator->createClient());



    mDummyDescriptorInfo.width = 64;

    mDummyDescriptorInfo.height = 64;
@@ -96,66 +58,27 @@ class GraphicsAllocatorHidlTest : public ::testing::VtsHalHidlTargetBaseTest { 


  void TearDown() override {}



  /**

   * Initialize the set of supported capabilities.

   */

  void initCapabilities() {

    mAllocator->getCapabilities([this](const auto& capabilities) {

      std::vector<IAllocator::Capability> caps = capabilities;

      mCapabilities.insert(caps.cbegin(), caps.cend());

    });

  }



  /**

   * Test whether a capability is supported.

   */

  bool hasCapability(IAllocator::Capability capability) const {

    return (mCapabilities.count(capability) > 0);

  }



  sp<IAllocator> mAllocator;

  sp<IAllocatorClient> mClient;

  std::unique_ptr<Allocator> mAllocator;

  std::unique_ptr<AllocatorClient> mClient;

  IAllocatorClient::BufferDescriptorInfo mDummyDescriptorInfo{};



 private:

  std::unordered_set<IAllocator::Capability> mCapabilities;

};



TEST_F(GraphicsAllocatorHidlTest, GetCapabilities) {

  auto ret = mAllocator->getCapabilities([](const auto& capabilities) {

    std::vector<IAllocator::Capability> caps = capabilities;

    for (auto cap : caps) {

  auto capabilities = mAllocator->getCapabilities();

  for (auto cap : capabilities) {

    EXPECT_NE(IAllocator::Capability::INVALID, cap);

  }

  });



  ASSERT_TRUE(ret.isOk());

}



TEST_F(GraphicsAllocatorHidlTest, DumpDebugInfo) {

  auto ret = mAllocator->dumpDebugInfo([](const auto&) {

    // nothing to do

  });



  ASSERT_TRUE(ret.isOk());

  mAllocator->dumpDebugInfo();

}



TEST_F(GraphicsAllocatorHidlTest, CreateDestroyDescriptor) {

  Error error;

  BufferDescriptor descriptor;

  auto ret = mClient->createDescriptor(

      mDummyDescriptorInfo,

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

        error = tmpError;

        descriptor = tmpDescriptor;

      });



  ASSERT_TRUE(ret.isOk());

  ASSERT_EQ(Error::NONE, error);



  auto err_ret = mClient->destroyDescriptor(descriptor);

  ASSERT_TRUE(err_ret.isOk());

  ASSERT_EQ(Error::NONE, static_cast<Error>(err_ret));

  ASSERT_NO_FATAL_FAILURE(descriptor =

                              mClient->createDescriptor(mDummyDescriptorInfo));

  mClient->destroyDescriptor(descriptor);

}



/**
@@ -164,18 +87,11 @@ TEST_F(GraphicsAllocatorHidlTest, CreateDestroyDescriptor) { 
TEST_F(GraphicsAllocatorHidlTest, TestAllocateBasic) {

  CHECK_FEATURE_OR_SKIP(IAllocator::Capability::TEST_ALLOCATE);



  TempDescriptor descriptor(mClient, mDummyDescriptorInfo);

  ASSERT_TRUE(descriptor.isValid());



  hidl_vec<BufferDescriptor> descriptors;

  descriptors.resize(1);

  descriptors[0] = descriptor;



  auto ret = mClient->testAllocate(descriptors);

  ASSERT_TRUE(ret.isOk());

  BufferDescriptor descriptor;

  ASSERT_NO_FATAL_FAILURE(descriptor =

                              mClient->createDescriptor(mDummyDescriptorInfo));



  auto error = static_cast<Error>(ret);

  ASSERT_TRUE(error == Error::NONE || error == Error::NOT_SHARED);

  ASSERT_TRUE(mClient->testAllocate(descriptor));

}



/**
@@ -184,18 +100,16 @@ TEST_F(GraphicsAllocatorHidlTest, TestAllocateBasic) { 
TEST_F(GraphicsAllocatorHidlTest, TestAllocateArray) {

  CHECK_FEATURE_OR_SKIP(IAllocator::Capability::TEST_ALLOCATE);



  TempDescriptor descriptor(mClient, mDummyDescriptorInfo);

  ASSERT_TRUE(descriptor.isValid());

  BufferDescriptor descriptor;

  ASSERT_NO_FATAL_FAILURE(descriptor =

                              mClient->createDescriptor(mDummyDescriptorInfo));



  hidl_vec<BufferDescriptor> descriptors;

  descriptors.resize(2);

  descriptors[0] = descriptor;

  descriptors[1] = descriptor;



  auto ret = mClient->testAllocate(descriptors);

  ASSERT_TRUE(ret.isOk());



  auto error = static_cast<Error>(ret);

  auto error = mClient->testAllocate(descriptors);

  ASSERT_TRUE(error == Error::NONE || error == Error::NOT_SHARED);

}
@@ -203,41 +117,27 @@ TEST_F(GraphicsAllocatorHidlTest, TestAllocateArray) { 
 * Test allocate/free with a single buffer descriptor.

 */

TEST_F(GraphicsAllocatorHidlTest, AllocateFreeBasic) {

  TempDescriptor descriptor(mClient, mDummyDescriptorInfo);

  ASSERT_TRUE(descriptor.isValid());



  hidl_vec<BufferDescriptor> descriptors;

  descriptors.resize(1);

  descriptors[0] = descriptor;



  Error error;

  std::vector<Buffer> buffers;

  auto ret = mClient->allocate(

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

        error = tmpError;

        buffers = tmpBuffers;

      });

  BufferDescriptor descriptor;

  ASSERT_NO_FATAL_FAILURE(descriptor =

                              mClient->createDescriptor(mDummyDescriptorInfo));



  ASSERT_TRUE(ret.isOk());

  ASSERT_TRUE(error == Error::NONE || error == Error::NOT_SHARED);

  EXPECT_EQ(1u, buffers.size());

  Buffer buffer;

  ASSERT_NO_FATAL_FAILURE(buffer = mClient->allocate(descriptor));



  if (!buffers.empty()) {

    auto err_ret = mClient->free(buffers[0]);

    EXPECT_TRUE(err_ret.isOk());

    EXPECT_EQ(Error::NONE, static_cast<Error>(err_ret));

  }

  mClient->free(buffer);

}



/**

 * Test allocate/free with an array of buffer descriptors.

 */

TEST_F(GraphicsAllocatorHidlTest, AllocateFreeArray) {

  TempDescriptor descriptor1(mClient, mDummyDescriptorInfo);

  ASSERT_TRUE(descriptor1.isValid());

  BufferDescriptor descriptor1;

  ASSERT_NO_FATAL_FAILURE(descriptor1 =

                              mClient->createDescriptor(mDummyDescriptorInfo));



  TempDescriptor descriptor2(mClient, mDummyDescriptorInfo);

  ASSERT_TRUE(descriptor2.isValid());

  BufferDescriptor descriptor2;

  ASSERT_NO_FATAL_FAILURE(descriptor2 =

                              mClient->createDescriptor(mDummyDescriptorInfo));



  hidl_vec<BufferDescriptor> descriptors;

  descriptors.resize(3);
@@ -245,54 +145,27 @@ TEST_F(GraphicsAllocatorHidlTest, AllocateFreeArray) { 
  descriptors[1] = descriptor1;

  descriptors[2] = descriptor2;



  Error error;

  std::vector<Buffer> buffers;

  auto ret = mClient->allocate(

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

        error = tmpError;

        buffers = tmpBuffers;

      });



  ASSERT_TRUE(ret.isOk());

  ASSERT_TRUE(error == Error::NONE || error == Error::NOT_SHARED);

  EXPECT_EQ(descriptors.size(), buffers.size());

  ASSERT_NO_FATAL_FAILURE(mClient->allocate(descriptors, buffers));



  for (auto buf : buffers) {

    auto err_ret = mClient->free(buf);

    EXPECT_TRUE(err_ret.isOk());

    EXPECT_EQ(Error::NONE, static_cast<Error>(err_ret));

    mClient->free(buf);

  }

}



TEST_F(GraphicsAllocatorHidlTest, ExportHandle) {

  TempDescriptor descriptor(mClient, mDummyDescriptorInfo);

  ASSERT_TRUE(descriptor.isValid());



  hidl_vec<BufferDescriptor> descriptors;

  descriptors.resize(1);

  descriptors[0] = descriptor;



  Error error;

  std::vector<Buffer> buffers;

  auto ret = mClient->allocate(

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

        error = tmpError;

        buffers = tmpBuffers;

      });

  BufferDescriptor descriptor;

  ASSERT_NO_FATAL_FAILURE(descriptor =

                              mClient->createDescriptor(mDummyDescriptorInfo));



  ASSERT_TRUE(ret.isOk());

  ASSERT_TRUE(error == Error::NONE || error == Error::NOT_SHARED);

  ASSERT_EQ(1u, buffers.size());

  Buffer buffer;

  ASSERT_NO_FATAL_FAILURE(buffer = mClient->allocate(descriptor));



  ret = mClient->exportHandle(

      descriptors[0], buffers[0],

      [&](const auto& tmpError, const auto&) { error = tmpError; });

  EXPECT_TRUE(ret.isOk());

  EXPECT_EQ(Error::NONE, error);

  native_handle_t* handle;

  ASSERT_NO_FATAL_FAILURE(handle = mClient->exportHandle(descriptor, buffer));



  auto err_ret = mClient->free(buffers[0]);

  EXPECT_TRUE(err_ret.isOk());

  EXPECT_EQ(Error::NONE, static_cast<Error>(err_ret));

  native_handle_close(handle);

  native_handle_delete(handle);

}



}  // namespace anonymous

graphics/composer/2.1/vts/functional/Android.bp

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

//



cc_library_static {

    name: "libVtsHalGraphicsComposerTestUtils",

    srcs: ["VtsHalGraphicsComposerTestUtils.cpp"],

    shared_libs: ["android.hardware.graphics.composer@2.1"],

    static_libs: [

        "VtsHalHidlTargetBaseTest",

    ],

    cflags: [

        "-Wall",

        "-Wextra",

        "-Werror",

        "-O0",

        "-g",

    ],

    export_include_dirs: ["."],

}



cc_test {

    name: "VtsHalGraphicsComposerV2_1TargetTest",

    srcs: ["VtsHalGraphicsComposerV2_1TargetTest.cpp"],
@@ -31,8 +48,17 @@ cc_test { 
        "libsync",

        "libutils",

    ],

    static_libs: ["VtsHalHidlTargetBaseTest", "libhwcomposer-command-buffer"],

    static_libs: [

        "libhwcomposer-command-buffer",

        "libVtsHalGraphicsAllocatorTestUtils",

        "libVtsHalGraphicsComposerTestUtils",

        "libVtsHalGraphicsMapperTestUtils",

        "VtsHalHidlTargetBaseTest",

    ],

    cflags: [

        "-Wall",

        "-Wextra",

        "-Werror",

        "-O0",

        "-g",

    ]