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

Commit 1a60bb42 authored by Tianyu's avatar Tianyu
Browse files

Rename BufferConsumer/BufferProducer to ConsumerBuffer/ProducerBuffer in libbufferhub directory. 

Now naming under libbufferhub is consistent.

Test: buffer_hub-test
Bug: 116855254
Change-Id: I996b65ec307871af4cf58c1f95eee3f945ba7959
parent 00314aa2

libs/vr/libbufferhub/buffer_hub-test.cpp

+73 −73
Original line number Diff line number Diff line
@@ -21,9 +21,9 @@ 


using android::GraphicBuffer;

using android::sp;

using android::dvr::BufferConsumer;

using android::dvr::BufferProducer;

using android::dvr::ConsumerBuffer;

using android::dvr::DetachedBuffer;

using android::dvr::ProducerBuffer;

using android::dvr::BufferHubDefs::IsBufferAcquired;

using android::dvr::BufferHubDefs::IsBufferGained;

using android::dvr::BufferHubDefs::IsBufferPosted;
@@ -48,15 +48,15 @@ const int kPollTimeoutMs = 100; 
using LibBufferHubTest = ::testing::Test;



TEST_F(LibBufferHubTest, TestBasicUsage) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);

  // Check that consumers can spawn other consumers.

  std::unique_ptr<BufferConsumer> c2 =

      BufferConsumer::Import(c->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c2 =

      ConsumerBuffer::Import(c->CreateConsumer());

  ASSERT_TRUE(c2.get() != nullptr);



  // Producer state mask is unique, i.e. 1.
@@ -110,11 +110,11 @@ TEST_F(LibBufferHubTest, TestBasicUsage) { 
}



TEST_F(LibBufferHubTest, TestEpoll) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);



  LocalHandle epoll_fd{epoll_create1(EPOLL_CLOEXEC)};
@@ -177,15 +177,15 @@ TEST_F(LibBufferHubTest, TestEpoll) { 
}



TEST_F(LibBufferHubTest, TestStateMask) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);



  // It's ok to create up to kMaxConsumerCount consumer buffers.

  uint64_t buffer_state_bits = p->buffer_state_bit();

  std::array<std::unique_ptr<BufferConsumer>, kMaxConsumerCount> cs;

  std::array<std::unique_ptr<ConsumerBuffer>, kMaxConsumerCount> cs;

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

    cs[i] = BufferConsumer::Import(p->CreateConsumer());

    cs[i] = ConsumerBuffer::Import(p->CreateConsumer());

    ASSERT_TRUE(cs[i].get() != nullptr);

    // Expect all buffers have unique state mask.

    EXPECT_EQ(buffer_state_bits & cs[i]->buffer_state_bit(), 0U);
@@ -201,7 +201,7 @@ TEST_F(LibBufferHubTest, TestStateMask) { 
  for (size_t i = 0; i < kMaxConsumerCount; i++) {

    buffer_state_bits &= ~cs[i]->buffer_state_bit();

    cs[i] = nullptr;

    cs[i] = BufferConsumer::Import(p->CreateConsumer());

    cs[i] = ConsumerBuffer::Import(p->CreateConsumer());

    ASSERT_TRUE(cs[i].get() != nullptr);

    // The released state mask will be reused.

    EXPECT_EQ(buffer_state_bits & cs[i]->buffer_state_bit(), 0U);
@@ -211,11 +211,11 @@ TEST_F(LibBufferHubTest, TestStateMask) { 
}



TEST_F(LibBufferHubTest, TestStateTransitions) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);



  uint64_t context;
@@ -263,11 +263,11 @@ TEST_F(LibBufferHubTest, TestStateTransitions) { 
}



TEST_F(LibBufferHubTest, TestAsyncStateTransitions) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);



  DvrNativeBufferMetadata metadata;
@@ -334,7 +334,7 @@ TEST_F(LibBufferHubTest, TestAsyncStateTransitions) { 
}



TEST_F(LibBufferHubTest, TestZeroConsumer) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);
@@ -350,21 +350,21 @@ TEST_F(LibBufferHubTest, TestZeroConsumer) { 
  EXPECT_GE(0, RETRY_EINTR(p->Poll(kPollTimeoutMs)));



  // A new consumer should still be able to acquire the buffer immediately.

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);

  EXPECT_EQ(0, c->AcquireAsync(&metadata, &invalid_fence));

  EXPECT_TRUE(IsBufferAcquired(c->buffer_state()));

}



TEST_F(LibBufferHubTest, TestMaxConsumers) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);



  std::array<std::unique_ptr<BufferConsumer>, kMaxConsumerCount> cs;

  std::array<std::unique_ptr<ConsumerBuffer>, kMaxConsumerCount> cs;

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

    cs[i] = BufferConsumer::Import(p->CreateConsumer());

    cs[i] = ConsumerBuffer::Import(p->CreateConsumer());

    ASSERT_TRUE(cs[i].get() != nullptr);

    EXPECT_TRUE(IsBufferGained(cs[i]->buffer_state()));

  }
@@ -400,13 +400,13 @@ TEST_F(LibBufferHubTest, TestMaxConsumers) { 
}



TEST_F(LibBufferHubTest, TestCreateConsumerWhenBufferGained) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);

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



  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);

  EXPECT_TRUE(IsBufferGained(c->buffer_state()));
@@ -422,7 +422,7 @@ TEST_F(LibBufferHubTest, TestCreateConsumerWhenBufferGained) { 
}



TEST_F(LibBufferHubTest, TestCreateConsumerWhenBufferPosted) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);

  EXPECT_TRUE(IsBufferGained(p->buffer_state()));
@@ -435,8 +435,8 @@ TEST_F(LibBufferHubTest, TestCreateConsumerWhenBufferPosted) { 
  EXPECT_TRUE(IsBufferPosted(p->buffer_state()));



  // Newly created consumer should be automatically sigalled.

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);

  EXPECT_TRUE(IsBufferPosted(c->buffer_state()));

  EXPECT_EQ(0, c->AcquireAsync(&metadata, &invalid_fence));
@@ -444,12 +444,12 @@ TEST_F(LibBufferHubTest, TestCreateConsumerWhenBufferPosted) { 
}



TEST_F(LibBufferHubTest, TestCreateConsumerWhenBufferReleased) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);



  std::unique_ptr<BufferConsumer> c1 =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c1 =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c1.get() != nullptr);



  DvrNativeBufferMetadata metadata;
@@ -470,8 +470,8 @@ TEST_F(LibBufferHubTest, TestCreateConsumerWhenBufferReleased) { 


  // Create another consumer immediately after the release, should not make the

  // buffer un-released.

  std::unique_ptr<BufferConsumer> c2 =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c2 =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c2.get() != nullptr);



  EXPECT_TRUE(IsBufferReleased(p->buffer_state()));
@@ -484,11 +484,11 @@ TEST_F(LibBufferHubTest, TestWithCustomMetadata) { 
    int64_t field1;

    int64_t field2;

  };

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(Metadata));

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);



  Metadata m = {1, 3};
@@ -515,11 +515,11 @@ TEST_F(LibBufferHubTest, TestPostWithWrongMetaSize) { 
    int64_t field2;

    int64_t field3;

  };

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(Metadata));

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);



  // It is illegal to post metadata larger than originally requested during
@@ -544,11 +544,11 @@ TEST_F(LibBufferHubTest, TestAcquireWithWrongMetaSize) { 
    int64_t field2;

    int64_t field3;

  };

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(Metadata));

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);



  Metadata m = {1, 3};
@@ -569,11 +569,11 @@ TEST_F(LibBufferHubTest, TestAcquireWithWrongMetaSize) { 
}



TEST_F(LibBufferHubTest, TestAcquireWithNoMeta) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);



  int64_t sequence = 3;
@@ -584,11 +584,11 @@ TEST_F(LibBufferHubTest, TestAcquireWithNoMeta) { 
}



TEST_F(LibBufferHubTest, TestWithNoMeta) {

  std::unique_ptr<BufferProducer> p =

      BufferProducer::Create(kWidth, kHeight, kFormat, kUsage);

  std::unique_ptr<ProducerBuffer> p =

      ProducerBuffer::Create(kWidth, kHeight, kFormat, kUsage);

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);



  LocalHandle fence;
@@ -598,11 +598,11 @@ TEST_F(LibBufferHubTest, TestWithNoMeta) { 
}



TEST_F(LibBufferHubTest, TestFailureToPostMetaFromABufferWithoutMeta) {

  std::unique_ptr<BufferProducer> p =

      BufferProducer::Create(kWidth, kHeight, kFormat, kUsage);

  std::unique_ptr<ProducerBuffer> p =

      ProducerBuffer::Create(kWidth, kHeight, kFormat, kUsage);

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);



  int64_t sequence = 3;
@@ -619,11 +619,11 @@ int PollFd(int fd, int timeout_ms) { 
}  // namespace



TEST_F(LibBufferHubTest, TestAcquireFence) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, /*metadata_size=*/0);

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c.get() != nullptr);



  DvrNativeBufferMetadata meta;
@@ -680,11 +680,11 @@ TEST_F(LibBufferHubTest, TestAcquireFence) { 
}



TEST_F(LibBufferHubTest, TestOrphanedAcquire) {

  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p.get() != nullptr);

  std::unique_ptr<BufferConsumer> c1 =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c1 =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c1.get() != nullptr);

  const uint64_t consumer_state_bit1 = c1->buffer_state_bit();
@@ -699,8 +699,8 @@ TEST_F(LibBufferHubTest, TestOrphanedAcquire) { 
  c1 = nullptr;

  EXPECT_GE(0, RETRY_EINTR(p->Poll(kPollTimeoutMs)));



  std::unique_ptr<BufferConsumer> c2 =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c2 =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c2.get() != nullptr);

  const uint64_t consumer_state_bit2 = c2->buffer_state_bit();

  EXPECT_NE(consumer_state_bit1, consumer_state_bit2);
@@ -715,8 +715,8 @@ TEST_F(LibBufferHubTest, TestOrphanedAcquire) { 
  EXPECT_LT(0, RETRY_EINTR(p->Poll(kPollTimeoutMs)));



  // But if another consumer is created in released state.

  std::unique_ptr<BufferConsumer> c3 =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c3 =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(c3.get() != nullptr);

  const uint64_t consumer_state_bit3 = c3->buffer_state_bit();

  EXPECT_NE(consumer_state_bit2, consumer_state_bit3);
@@ -732,10 +732,10 @@ TEST_F(LibBufferHubTest, TestDetachBufferFromProducer) { 
  // TODO(b/112338294) rewrite test after migration

  return;



  std::unique_ptr<BufferProducer> p = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  std::unique_ptr<BufferConsumer> c =

      BufferConsumer::Import(p->CreateConsumer());

  std::unique_ptr<ConsumerBuffer> c =

      ConsumerBuffer::Import(p->CreateConsumer());

  ASSERT_TRUE(p.get() != nullptr);

  ASSERT_TRUE(c.get() != nullptr);
@@ -862,7 +862,7 @@ TEST_F(LibBufferHubTest, TestPromoteDetachedBuffer) { 
  LocalChannelHandle h1 = status_or_handle.take();

  EXPECT_TRUE(h1.valid());



  std::unique_ptr<BufferProducer> p1 = BufferProducer::Import(std::move(h1));

  std::unique_ptr<ProducerBuffer> p1 = ProducerBuffer::Import(std::move(h1));

  EXPECT_FALSE(h1.valid());

  ASSERT_TRUE(p1 != nullptr);

  int p1_id = p1->id();
@@ -876,7 +876,7 @@ TEST_F(LibBufferHubTest, TestDetachThenPromote) { 
  // TODO(b/112338294) rewrite test after migration

  return;



  std::unique_ptr<BufferProducer> p1 = BufferProducer::Create(

  std::unique_ptr<ProducerBuffer> p1 = ProducerBuffer::Create(

      kWidth, kHeight, kFormat, kUsage, sizeof(uint64_t));

  ASSERT_TRUE(p1.get() != nullptr);

  int p1_id = p1->id();
@@ -905,7 +905,7 @@ TEST_F(LibBufferHubTest, TestDetachThenPromote) { 
  LocalChannelHandle h2 = status_or_handle.take();

  EXPECT_TRUE(h2.valid());



  std::unique_ptr<BufferProducer> p2 = BufferProducer::Import(std::move(h2));

  std::unique_ptr<ProducerBuffer> p2 = ProducerBuffer::Import(std::move(h2));

  EXPECT_FALSE(h2.valid());

  ASSERT_TRUE(p2 != nullptr);

  int p2_id = p2->id();