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

Commit 0e7ee22b authored by Jiwen 'Steve' Cai's avatar Jiwen 'Steve' Cai
Browse files

Move BufferHubBuffer_test to libui 

Bug: 111976433
Bug: 112940221
Test: BufferHubBuffer_test
Change-Id: Ice3507666f3b99184276c36262aab33d0f295d64
parent de7ddfe5

libs/ui/tests/Android.bp

+8 −0
Original line number Original line Diff line number Diff line
@@ -35,6 +35,14 @@ cc_test { 
    cflags: ["-Wall", "-Werror"],

    cflags: ["-Wall", "-Werror"],

}

}





cc_test {

    name: "BufferHubBuffer_test",

    header_libs: ["libbufferhub_headers", "libdvr_headers"],

    shared_libs: ["libpdx_default_transport", "libui", "libutils"],

    srcs: ["BufferHubBuffer_test.cpp"],

    cflags: ["-Wall", "-Werror"],

}



cc_test {

cc_test {

    name: "BufferHubMetadata_test",

    name: "BufferHubMetadata_test",

    header_libs: ["libbufferhub_headers", "libdvr_headers"],

    header_libs: ["libbufferhub_headers", "libdvr_headers"],

libs/ui/tests/BufferHubBuffer_test.cpp

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

 * Copyright 2018 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.

 */



#define LOG_TAG "BufferHubBufferTest"



#include <gtest/gtest.h>

#include <ui/BufferHubBuffer.h>



namespace android {



namespace {



const int kWidth = 640;

const int kHeight = 480;

const int kLayerCount = 1;

const int kFormat = HAL_PIXEL_FORMAT_RGBA_8888;

const int kUsage = 0;

const size_t kUserMetadataSize = 0;



} // namespace



using BufferHubBufferTest = ::testing::Test;



using dvr::BufferHubDefs::IsBufferGained;

using dvr::BufferHubDefs::kMetadataHeaderSize;

using dvr::BufferHubDefs::kProducerStateBit;

using pdx::LocalChannelHandle;



TEST_F(BufferHubBufferTest, CreateBufferHubBufferFails) {

    // Buffer Creation will fail: BLOB format requires height to be 1.

    auto b1 = BufferHubBuffer::Create(kWidth, /*height=*/2, kLayerCount,

                                      /*format=*/HAL_PIXEL_FORMAT_BLOB, kUsage, kUserMetadataSize);



    EXPECT_FALSE(b1->IsConnected());

    EXPECT_FALSE(b1->IsValid());



    // Buffer Creation will fail: user metadata size too large.

    auto b2 = BufferHubBuffer::Create(kWidth, kHeight, kLayerCount, kFormat, kUsage,

                                      /*userMetadataSize=*/std::numeric_limits<size_t>::max());



    EXPECT_FALSE(b2->IsConnected());

    EXPECT_FALSE(b2->IsValid());



    // Buffer Creation will fail: user metadata size too large.

    const size_t userMetadataSize = std::numeric_limits<size_t>::max() - kMetadataHeaderSize;

    auto b3 = BufferHubBuffer::Create(kWidth, kHeight, kLayerCount, kFormat, kUsage,

                                      userMetadataSize);



    EXPECT_FALSE(b3->IsConnected());

    EXPECT_FALSE(b3->IsValid());

}



TEST_F(BufferHubBufferTest, CreateBufferHubBuffer) {

    auto b1 = BufferHubBuffer::Create(kWidth, kHeight, kLayerCount, kFormat, kUsage,

                                      kUserMetadataSize);

    EXPECT_TRUE(b1->IsConnected());

    EXPECT_TRUE(b1->IsValid());

    EXPECT_NE(b1->id(), 0);

}



TEST_F(BufferHubBufferTest, DuplicateBufferHubBuffer) {

    auto b1 = BufferHubBuffer::Create(kWidth, kHeight, kLayerCount, kFormat, kUsage,

                                      kUserMetadataSize);

    int id1 = b1->id();

    EXPECT_TRUE(b1->IsValid());

    EXPECT_EQ(b1->user_metadata_size(), kUserMetadataSize);



    auto statusOrHandle = b1->Duplicate();

    EXPECT_TRUE(statusOrHandle);



    // The detached buffer should still be valid.

    EXPECT_TRUE(b1->IsConnected());

    EXPECT_TRUE(b1->IsValid());



    // Gets the channel handle for the duplicated buffer.

    LocalChannelHandle h2 = statusOrHandle.take();

    EXPECT_TRUE(h2.valid());



    std::unique_ptr<BufferHubBuffer> b2 = BufferHubBuffer::Import(std::move(h2));

    EXPECT_FALSE(h2.valid());

    ASSERT_TRUE(b2 != nullptr);

    EXPECT_TRUE(b2->IsValid());

    EXPECT_EQ(b2->user_metadata_size(), kUserMetadataSize);



    int id2 = b2->id();



    // These two buffer instances are based on the same physical buffer under the

    // hood, so they should share the same id.

    EXPECT_EQ(id1, id2);

    // We use buffer_state_bit() to tell those two instances apart.

    EXPECT_NE(b1->buffer_state_bit(), b2->buffer_state_bit());

    EXPECT_NE(b1->buffer_state_bit(), 0ULL);

    EXPECT_NE(b2->buffer_state_bit(), 0ULL);

    EXPECT_NE(b1->buffer_state_bit(), kProducerStateBit);

    EXPECT_NE(b2->buffer_state_bit(), kProducerStateBit);



    // Both buffer instances should be in gained state.

    EXPECT_TRUE(IsBufferGained(b1->buffer_state()));

    EXPECT_TRUE(IsBufferGained(b2->buffer_state()));



    // TODO(b/112338294): rewrite test after migration

    return;



    // Promote the detached buffer should fail as b1 is no longer the exclusive

    // owner of the buffer..

    statusOrHandle = b1->Promote();

    EXPECT_FALSE(statusOrHandle.ok());

    EXPECT_EQ(statusOrHandle.error(), EINVAL);

}



} // namespace android

libs/vr/libbufferhub/buffer_hub-test.cpp

+0 −85
Original line number Original line Diff line number Diff line
@@ -794,41 +794,6 @@ TEST_F(LibBufferHubTest, TestDetachBufferFromProducer) { 
  EXPECT_EQ(d->id(), p_id);

  EXPECT_EQ(d->id(), p_id);

}

}





TEST_F(LibBufferHubTest, TestCreateBufferHubBufferFails) {

  // Buffer Creation will fail: BLOB format requires height to be 1.

  auto b1 = BufferHubBuffer::Create(kWidth, /*height=2*/ 2, kLayerCount,

                                    /*format=*/HAL_PIXEL_FORMAT_BLOB, kUsage,

                                    kUserMetadataSize);



  EXPECT_FALSE(b1->IsConnected());

  EXPECT_FALSE(b1->IsValid());



  // Buffer Creation will fail: user metadata size too large.

  auto b2 = BufferHubBuffer::Create(

      kWidth, kHeight, kLayerCount, kFormat, kUsage,

      /*user_metadata_size=*/std::numeric_limits<size_t>::max());



  EXPECT_FALSE(b2->IsConnected());

  EXPECT_FALSE(b2->IsValid());



  // Buffer Creation will fail: user metadata size too large.

  auto b3 = BufferHubBuffer::Create(

      kWidth, kHeight, kLayerCount, kFormat, kUsage,

      /*user_metadata_size=*/std::numeric_limits<size_t>::max() -

          kMetadataHeaderSize);



  EXPECT_FALSE(b3->IsConnected());

  EXPECT_FALSE(b3->IsValid());

}



TEST_F(LibBufferHubTest, TestCreateBufferHubBuffer) {

  auto b1 = BufferHubBuffer::Create(kWidth, kHeight, kLayerCount, kFormat,

                                    kUsage, kUserMetadataSize);

  EXPECT_TRUE(b1->IsConnected());

  EXPECT_TRUE(b1->IsValid());

  EXPECT_NE(b1->id(), 0);

}



TEST_F(LibBufferHubTest, TestPromoteBufferHubBuffer) {

TEST_F(LibBufferHubTest, TestPromoteBufferHubBuffer) {

  // TODO(b/112338294) rewrite test after migration

  // TODO(b/112338294) rewrite test after migration

  return;

  return;
@@ -908,53 +873,3 @@ TEST_F(LibBufferHubTest, TestDetachThenPromote) { 
  EXPECT_EQ(b1_id, p2_id);

  EXPECT_EQ(b1_id, p2_id);

  EXPECT_TRUE(IsBufferGained(p2->buffer_state()));

  EXPECT_TRUE(IsBufferGained(p2->buffer_state()));

}
 
}
 


TEST_F(LibBufferHubTest, TestDuplicateBufferHubBuffer) {

  auto b1 = BufferHubBuffer::Create(kWidth, kHeight, kLayerCount, kFormat,

                                    kUsage, kUserMetadataSize);

  int b1_id = b1->id();

  EXPECT_TRUE(b1->IsValid());

  EXPECT_EQ(b1->user_metadata_size(), kUserMetadataSize);



  auto status_or_handle = b1->Duplicate();

  EXPECT_TRUE(status_or_handle);



  // The detached buffer should still be valid.

  EXPECT_TRUE(b1->IsConnected());

  EXPECT_TRUE(b1->IsValid());



  // Gets the channel handle for the duplicated buffer.

  LocalChannelHandle h2 = status_or_handle.take();

  EXPECT_TRUE(h2.valid());



  std::unique_ptr<BufferHubBuffer> b2 = BufferHubBuffer::Import(std::move(h2));

  EXPECT_FALSE(h2.valid());

  ASSERT_TRUE(b2 != nullptr);

  EXPECT_TRUE(b2->IsValid());

  EXPECT_EQ(b2->user_metadata_size(), kUserMetadataSize);



  int b2_id = b2->id();



  // These two buffer instances are based on the same physical buffer under the

  // hood, so they should share the same id.

  EXPECT_EQ(b1_id, b2_id);

  // We use buffer_state_bit() to tell those two instances apart.

  EXPECT_NE(b1->buffer_state_bit(), b2->buffer_state_bit());

  EXPECT_NE(b1->buffer_state_bit(), 0ULL);

  EXPECT_NE(b2->buffer_state_bit(), 0ULL);

  EXPECT_NE(b1->buffer_state_bit(), kProducerStateBit);

  EXPECT_NE(b2->buffer_state_bit(), kProducerStateBit);



  // Both buffer instances should be in gained state.

  EXPECT_TRUE(IsBufferGained(b1->buffer_state()));

  EXPECT_TRUE(IsBufferGained(b2->buffer_state()));



  // TODO(b/112338294) rewrite test after migration

  return;



  // Promote the detached buffer should fail as b1 is no longer the exclusive

  // owner of the buffer..

  status_or_handle = b1->Promote();

  EXPECT_FALSE(status_or_handle.ok());

  EXPECT_EQ(status_or_handle.error(), EINVAL);

}