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

Commit ecb88121 authored by Nolan Scobie's avatar Nolan Scobie Committed by Automerger Merge Worker
Browse files

Merge changes I064786d2,I7bd56f60,I97c7cdce into udc-qpr-dev am: 68b5c004 am: 6944fcea 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/23483318



Change-Id: I6a76f9240f33f66bef29b43d12a2209ed09c1f58
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents e4cb752d 6944fcea

libs/gui/TEST_MAPPING

+51 −3
Original line number Diff line number Diff line
@@ -4,10 +4,58 @@ 
      "path": "frameworks/native/libs/nativewindow"

    }

  ],

  "postsubmit": [

  "presubmit": [

    {

      // TODO(257123981): move this to presubmit after dealing with existing breakages.

      "name": "libgui_test"

      "name": "libgui_test",

      "options": [

        // TODO(b/277604286): Failing on Cuttlefish.

        {

          "exclude-filter": "MultiTextureConsumerTest#EGLImageTargetWorks"

        },



        // TODO(b/285011590): Failing on Cuttlefish.

        {

          "exclude-filter": "SurfaceTest#GetHdrSupport"

        },

        {

          "exclude-filter": "SurfaceTest#GetWideColorSupport"

        },



        // TODO(b/285006554): Failing on Cuttlefish.

        {

          "exclude-filter": "SurfaceTextureGLTest#InvalidWidthOrHeightFails"

        },



        // TODO(b/277347351): Known test data issues, failing across devices.

        {

          "exclude-filter": "SurfaceTextureGLTest#TexturingFromCpuFilledYV12BufferNpot"

        },

        {

          "exclude-filter": "SurfaceTextureGLTest#TexturingFromCpuFilledYV12BufferPow2"

        },

        {

          "exclude-filter": "SurfaceTextureGLTest#TexturingFromCpuFilledYV12BufferWithCrop"

        },

        {

          "exclude-filter": "SurfaceTextureGLTest#TexturingFromCpuFilledYV12BuffersRepeatedly"

        },



        // TODO(b/285041169): Hanging on Cuttlefish.

        {

          "exclude-filter": "SurfaceTextureGLThreadToGLTest#UpdateTexImageBeforeFrameFinishedCompletes"

        },

        {

          "exclude-filter": "SurfaceTextureGLThreadToGLTest#RepeatedUpdateTexImageBeforeFrameFinishedCompletes"

        },

        {

          "exclude-filter": "SurfaceTextureGLThreadToGLTest#RepeatedUpdateTexImageAfterFrameFinishedCompletes"

        },



        // TODO(b/285041070): Failing on Cuttlefish.

        {

          "exclude-filter": "SurfaceTextureGLToGLTest#EglDestroySurfaceUnrefsBuffers"

        }

      ]

    }

  ]

}

libs/gui/tests/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ cc_test { 
    ],



    srcs: [

        "LibGuiMain.cpp", // Custom gtest entrypoint

        "BLASTBufferQueue_test.cpp",

        "BufferItemConsumer_test.cpp",

        "BufferQueue_test.cpp",

libs/gui/tests/AndroidTest.xml

+1 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
      <option name="screen-always-on" value="on" />

    </target_preparer>

    <option name="test-suite-tag" value="apct" />

    <option name="not-shardable" value="true" />

    <test class="com.android.tradefed.testtype.GTest" >

        <option name="native-test-device-path" value="/data/local/tmp" />

        <option name="module-name" value="libgui_test" />

libs/gui/tests/BLASTBufferQueue_test.cpp

+0 −12
Original line number Diff line number Diff line
@@ -176,18 +176,6 @@ private: 
class BLASTBufferQueueTest : public ::testing::Test {

public:

protected:

    BLASTBufferQueueTest() {

        const ::testing::TestInfo* const testInfo =

                ::testing::UnitTest::GetInstance()->current_test_info();

        ALOGD("Begin test: %s.%s", testInfo->test_case_name(), testInfo->name());

    }



    ~BLASTBufferQueueTest() {

        const ::testing::TestInfo* const testInfo =

                ::testing::UnitTest::GetInstance()->current_test_info();

        ALOGD("End test:   %s.%s", testInfo->test_case_name(), testInfo->name());

    }



    void SetUp() {

        mComposer = ComposerService::getComposerService();

        mClient = new SurfaceComposerClient();

libs/gui/tests/BufferQueue_test.cpp

+82 −48
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#define LOG_TAG "BufferQueue_test"

//#define LOG_NDEBUG 0



#include "Constants.h"

#include "MockConsumer.h"



#include <gui/BufferItem.h>
@@ -46,20 +47,6 @@ class BufferQueueTest : public ::testing::Test { 


public:

protected:

    BufferQueueTest() {

        const ::testing::TestInfo* const testInfo =

            ::testing::UnitTest::GetInstance()->current_test_info();

        ALOGD("Begin test: %s.%s", testInfo->test_case_name(),

                testInfo->name());

    }



    ~BufferQueueTest() {

        const ::testing::TestInfo* const testInfo =

            ::testing::UnitTest::GetInstance()->current_test_info();

        ALOGD("End test:   %s.%s", testInfo->test_case_name(),

                testInfo->name());

    }



    void GetMinUndequeuedBufferCount(int* bufferCount) {

        ASSERT_TRUE(bufferCount != nullptr);

        ASSERT_EQ(OK, mProducer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
@@ -535,7 +522,8 @@ TEST_F(BufferQueueTest, TestGenerationNumbers) { 
    int slot;

    sp<Fence> fence;

    ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));



    sp<GraphicBuffer> buffer;

    ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));
@@ -578,7 +566,8 @@ TEST_F(BufferQueueTest, TestSharedBufferModeWithoutAutoRefresh) { 
    sp<Fence> fence;

    sp<GraphicBuffer> buffer;

    ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,

              mProducer->dequeueBuffer(&sharedSlot, &fence, 0, 0, 0, 0, nullptr, nullptr));

              mProducer->dequeueBuffer(&sharedSlot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                       nullptr, nullptr));

    ASSERT_EQ(OK, mProducer->requestBuffer(sharedSlot, &buffer));



    // Queue the buffer
@@ -592,7 +581,9 @@ TEST_F(BufferQueueTest, TestSharedBufferModeWithoutAutoRefresh) { 
    // always the same one and because async mode gets enabled.

    int slot;

    for (int i = 0; i < 5; i++) {

        ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

        ASSERT_EQ(OK,

                  mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                           nullptr, nullptr));

        ASSERT_EQ(sharedSlot, slot);

        ASSERT_EQ(OK, mProducer->queueBuffer(sharedSlot, input, &output));

    }
@@ -629,7 +620,8 @@ TEST_F(BufferQueueTest, TestSharedBufferModeWithAutoRefresh) { 
    sp<Fence> fence;

    sp<GraphicBuffer> buffer;

    ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,

              mProducer->dequeueBuffer(&sharedSlot, &fence, 0, 0, 0, 0, nullptr, nullptr));

              mProducer->dequeueBuffer(&sharedSlot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                       nullptr, nullptr));

    ASSERT_EQ(OK, mProducer->requestBuffer(sharedSlot, &buffer));



    // Queue the buffer
@@ -656,7 +648,9 @@ TEST_F(BufferQueueTest, TestSharedBufferModeWithAutoRefresh) { 
    // always return the same one.

    int slot;

    for (int i = 0; i < 5; i++) {

        ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

        ASSERT_EQ(OK,

                  mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                           nullptr, nullptr));

        ASSERT_EQ(sharedSlot, slot);

        ASSERT_EQ(OK, mProducer->queueBuffer(sharedSlot, input, &output));

    }
@@ -695,7 +689,8 @@ TEST_F(BufferQueueTest, TestSharedBufferModeUsingAlreadyDequeuedBuffer) { 
    sp<Fence> fence;

    sp<GraphicBuffer> buffer;

    ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,

              mProducer->dequeueBuffer(&sharedSlot, &fence, 0, 0, 0, 0, nullptr, nullptr));

              mProducer->dequeueBuffer(&sharedSlot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                       nullptr, nullptr));

    ASSERT_EQ(OK, mProducer->requestBuffer(sharedSlot, &buffer));



    // Enable shared buffer mode
@@ -712,7 +707,9 @@ TEST_F(BufferQueueTest, TestSharedBufferModeUsingAlreadyDequeuedBuffer) { 
    // always the same one and because async mode gets enabled.

    int slot;

    for (int i = 0; i < 5; i++) {

        ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

        ASSERT_EQ(OK,

                  mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                           nullptr, nullptr));

        ASSERT_EQ(sharedSlot, slot);

        ASSERT_EQ(OK, mProducer->queueBuffer(sharedSlot, input, &output));

    }
@@ -747,7 +744,8 @@ TEST_F(BufferQueueTest, TestTimeouts) { 
    for (int i = 0; i < 5; ++i) {

        int slot = BufferQueue::INVALID_BUFFER_SLOT;

        sp<Fence> fence = Fence::NO_FENCE;

        auto result = mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr);

        auto result = mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                               nullptr, nullptr);

        if (i < 2) {

            ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,

                    result);
@@ -774,7 +772,9 @@ TEST_F(BufferQueueTest, TestTimeouts) { 
    for (int i = 0; i < 2; ++i) {

        int slot = BufferQueue::INVALID_BUFFER_SLOT;

        sp<Fence> fence = Fence::NO_FENCE;

        ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

        ASSERT_EQ(OK,

                  mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                           nullptr, nullptr));

        ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));

        IGraphicBufferProducer::QueueBufferInput input(0ull, true,

                HAL_DATASPACE_UNKNOWN, Rect::INVALID_RECT,
@@ -785,7 +785,9 @@ TEST_F(BufferQueueTest, TestTimeouts) { 
    int slot = BufferQueue::INVALID_BUFFER_SLOT;

    sp<Fence> fence = Fence::NO_FENCE;

    auto startTime = systemTime();

    ASSERT_EQ(TIMED_OUT, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(TIMED_OUT,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    ASSERT_GE(systemTime() - startTime, TIMEOUT);



    // We're technically attaching the same buffer multiple times (since we
@@ -806,7 +808,8 @@ TEST_F(BufferQueueTest, CanAttachWhileDisallowingAllocation) { 
    int slot = BufferQueue::INVALID_BUFFER_SLOT;

    sp<Fence> sourceFence;

    ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,

              mProducer->dequeueBuffer(&slot, &sourceFence, 0, 0, 0, 0, nullptr, nullptr));

              mProducer->dequeueBuffer(&slot, &sourceFence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                       nullptr, nullptr));

    sp<GraphicBuffer> buffer;

    ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));

    ASSERT_EQ(OK, mProducer->detachBuffer(slot));
@@ -829,7 +832,8 @@ TEST_F(BufferQueueTest, CanRetrieveLastQueuedBuffer) { 
    int slot = BufferQueue::INVALID_BUFFER_SLOT;

    sp<Fence> fence;

    ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    sp<GraphicBuffer> firstBuffer;

    ASSERT_EQ(OK, mProducer->requestBuffer(slot, &firstBuffer));
@@ -841,7 +845,8 @@ TEST_F(BufferQueueTest, CanRetrieveLastQueuedBuffer) { 
    // Dequeue a second buffer

    slot = BufferQueue::INVALID_BUFFER_SLOT;

    ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    sp<GraphicBuffer> secondBuffer;

    ASSERT_EQ(OK, mProducer->requestBuffer(slot, &secondBuffer));
@@ -892,8 +897,8 @@ TEST_F(BufferQueueTest, TestOccupancyHistory) { 
    int slots[3] = {};

    mProducer->setMaxDequeuedBufferCount(3);

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

        status_t result =

                mProducer->dequeueBuffer(&slots[i], &fence, 0, 0, 0, 0, nullptr, nullptr);

        status_t result = mProducer->dequeueBuffer(&slots[i], &fence, 0, 0, 0,

                                                   TEST_PRODUCER_USAGE_BITS, nullptr, nullptr);

        ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION, result);

        ASSERT_EQ(OK, mProducer->requestBuffer(slots[i], &buffer));

    }
@@ -906,7 +911,9 @@ TEST_F(BufferQueueTest, TestOccupancyHistory) { 
    // The first segment is a two-buffer segment, so we only put one buffer into

    // the queue at a time

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

        ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

        ASSERT_EQ(OK,

                  mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                           nullptr, nullptr));

        ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));

        ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));

        ASSERT_EQ(OK, mConsumer->releaseBuffer(item.mSlot, item.mFrameNumber,
@@ -921,16 +928,22 @@ TEST_F(BufferQueueTest, TestOccupancyHistory) { 
    // two-buffer segment, but then at the end, we put two buffers in the queue

    // at the same time before draining it.

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

        ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

        ASSERT_EQ(OK,

                  mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                           nullptr, nullptr));

        ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));

        ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));

        ASSERT_EQ(OK, mConsumer->releaseBuffer(item.mSlot, item.mFrameNumber,

                EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, Fence::NO_FENCE));

        std::this_thread::sleep_for(16ms);

    }

    ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(OK,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));

    ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(OK,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));

    ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));

    ASSERT_EQ(OK, mConsumer->releaseBuffer(item.mSlot, item.mFrameNumber,
@@ -945,10 +958,14 @@ TEST_F(BufferQueueTest, TestOccupancyHistory) { 


    // The third segment is a triple-buffer segment, so the queue is switching

    // between one buffer and two buffers deep.

    ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(OK,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));

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

        ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

        ASSERT_EQ(OK,

                  mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                           nullptr, nullptr));

        ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));

        ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));

        ASSERT_EQ(OK, mConsumer->releaseBuffer(item.mSlot, item.mFrameNumber,
@@ -1047,8 +1064,8 @@ TEST_F(BufferQueueTest, TestDiscardFreeBuffers) { 
    int slots[4] = {};

    mProducer->setMaxDequeuedBufferCount(4);

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

        status_t result =

                mProducer->dequeueBuffer(&slots[i], &fence, 0, 0, 0, 0, nullptr, nullptr);

        status_t result = mProducer->dequeueBuffer(&slots[i], &fence, 0, 0, 0,

                                                   TEST_PRODUCER_USAGE_BITS, nullptr, nullptr);

        ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION, result);

        ASSERT_EQ(OK, mProducer->requestBuffer(slots[i], &buffer));

    }
@@ -1059,14 +1076,22 @@ TEST_F(BufferQueueTest, TestDiscardFreeBuffers) { 
    // Get buffers in all states: dequeued, filled, acquired, free



    // Fill 3 buffers

    ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(OK,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));

    ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(OK,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));

    ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(OK,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));

    // Dequeue 1 buffer

    ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(OK,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));



    // Acquire and free 1 buffer

    ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
@@ -1132,8 +1157,8 @@ TEST_F(BufferQueueTest, TestBufferReplacedInQueueBuffer) { 
    int slots[2] = {};

    ASSERT_EQ(OK, mProducer->setMaxDequeuedBufferCount(2));

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

        status_t result =

                mProducer->dequeueBuffer(&slots[i], &fence, 0, 0, 0, 0, nullptr, nullptr);

        status_t result = mProducer->dequeueBuffer(&slots[i], &fence, 0, 0, 0,

                                                   TEST_PRODUCER_USAGE_BITS, nullptr, nullptr);

        ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION, result);

        ASSERT_EQ(OK, mProducer->requestBuffer(slots[i], &buffer));

    }
@@ -1143,10 +1168,14 @@ TEST_F(BufferQueueTest, TestBufferReplacedInQueueBuffer) { 


    // Fill 2 buffers without consumer consuming them. Verify that all

    // queued buffer returns proper bufferReplaced flag

    ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(OK,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));

    ASSERT_EQ(false, output.bufferReplaced);

    ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(OK,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));

    ASSERT_EQ(true, output.bufferReplaced);

}
@@ -1167,7 +1196,8 @@ TEST_F(BufferQueueTest, TestStaleBufferHandleSentAfterDisconnect) { 
            NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, Fence::NO_FENCE);



    // Dequeue, request, and queue one buffer

    status_t result = mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr);

    status_t result = mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS,

                                               nullptr, nullptr);

    ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION, result);

    ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));

    ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));
@@ -1182,7 +1212,9 @@ TEST_F(BufferQueueTest, TestStaleBufferHandleSentAfterDisconnect) { 
            EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, Fence::NO_FENCE));



    // Dequeue and queue the buffer again

    ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(OK,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));



    // Acquire and release the buffer again. Upon acquiring, the buffer handle
@@ -1194,7 +1226,9 @@ TEST_F(BufferQueueTest, TestStaleBufferHandleSentAfterDisconnect) { 
            EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, Fence::NO_FENCE));



    // Dequeue and queue the buffer again

    ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr, nullptr));

    ASSERT_EQ(OK,

              mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, TEST_PRODUCER_USAGE_BITS, nullptr,

                                       nullptr));

    ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));



    // Disconnect the producer end. This should clear all of the slots and mark