IGraphicBufferProducer_test.cpp revision 2e336496c3b3b78910cf1c496e21dc4909ee32ad 
1/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "IGraphicBufferProducer_test"
18//#define LOG_NDEBUG 0
19
20#include <gtest/gtest.h>
21
22#include <utils/String8.h>
23#include <utils/threads.h>
24
25#include <ui/GraphicBuffer.h>
26
27#include <gui/BufferQueue.h>
28
29#include <vector>
30
31#define ASSERT_OK(x) ASSERT_EQ(OK, (x))
32#define EXPECT_OK(x) EXPECT_EQ(OK, (x))
33
34#define TEST_TOKEN ((IBinder*)(NULL))
35#define TEST_API NATIVE_WINDOW_API_CPU
36#define TEST_API_OTHER NATIVE_WINDOW_API_EGL // valid API that's not TEST_API
37#define TEST_CONTROLLED_BY_APP false
38#define TEST_PRODUCER_USAGE_BITS (0)
39
40// TODO: Make these public constants in a header
41enum {
42    // Default dimensions before setDefaultBufferSize is called
43    DEFAULT_WIDTH = 1,
44    DEFAULT_HEIGHT = 1,
45
46    // Default format before setDefaultBufferFormat is called
47    DEFAULT_FORMAT = HAL_PIXEL_FORMAT_RGBA_8888,
48
49    // Default transform hint before setTransformHint is called
50    DEFAULT_TRANSFORM_HINT = 0,
51};
52
53namespace android {
54
55namespace {
56// Parameters for a generic "valid" input for queueBuffer.
57const int64_t QUEUE_BUFFER_INPUT_TIMESTAMP = 1384888611;
58const bool QUEUE_BUFFER_INPUT_IS_AUTO_TIMESTAMP = false;
59const Rect QUEUE_BUFFER_INPUT_RECT = Rect(DEFAULT_WIDTH, DEFAULT_HEIGHT);
60const int QUEUE_BUFFER_INPUT_SCALING_MODE = 0;
61const int QUEUE_BUFFER_INPUT_TRANSFORM = 0;
62const bool QUEUE_BUFFER_INPUT_ASYNC = false;
63const sp<Fence> QUEUE_BUFFER_INPUT_FENCE = Fence::NO_FENCE;
64}; // namespace anonymous
65
66struct DummyConsumer : public BnConsumerListener {
67    virtual void onFrameAvailable() {}
68    virtual void onBuffersReleased() {}
69};
70
71class IGraphicBufferProducerTest : public ::testing::Test {
72protected:
73
74    IGraphicBufferProducerTest() {}
75
76    virtual void SetUp() {
77        const ::testing::TestInfo* const testInfo =
78            ::testing::UnitTest::GetInstance()->current_test_info();
79        ALOGV("Begin test: %s.%s", testInfo->test_case_name(),
80                testInfo->name());
81
82        mBQ = new BufferQueue();
83        mDC = new DummyConsumer;
84
85        mProducer = mBQ;
86        mConsumer = mBQ;
87
88        // Test check: Can't connect producer if no consumer yet
89        ASSERT_EQ(NO_INIT, TryConnectProducer());
90
91        // Must connect consumer before producer connects will succeed.
92        ASSERT_OK(mConsumer->consumerConnect(mDC, /*controlledByApp*/false));
93    }
94
95    virtual void TearDown() {
96        const ::testing::TestInfo* const testInfo =
97            ::testing::UnitTest::GetInstance()->current_test_info();
98        ALOGV("End test:   %s.%s", testInfo->test_case_name(),
99                testInfo->name());
100    }
101
102    status_t TryConnectProducer() {
103        IGraphicBufferProducer::QueueBufferOutput output;
104        return mProducer->connect(TEST_TOKEN,
105                                  TEST_API,
106                                  TEST_CONTROLLED_BY_APP,
107                                  &output);
108        // TODO: use params to vary token, api, producercontrolledbyapp, etc
109    }
110
111    // Connect to a producer in a 'correct' fashion.
112    //   Precondition: Consumer is connected.
113    void ConnectProducer() {
114        ASSERT_OK(TryConnectProducer());
115    }
116
117    // Create a generic "valid" input for queueBuffer
118    // -- uses the default buffer format, width, etc.
119    static IGraphicBufferProducer::QueueBufferInput CreateBufferInput() {
120        return QueueBufferInputBuilder().build();
121    }
122
123    // Builder pattern to slightly vary *almost* correct input
124    // -- avoids copying and pasting
125    struct QueueBufferInputBuilder {
126        QueueBufferInputBuilder() {
127           timestamp = QUEUE_BUFFER_INPUT_TIMESTAMP;
128           isAutoTimestamp = QUEUE_BUFFER_INPUT_IS_AUTO_TIMESTAMP;
129           crop = QUEUE_BUFFER_INPUT_RECT;
130           scalingMode = QUEUE_BUFFER_INPUT_SCALING_MODE;
131           transform = QUEUE_BUFFER_INPUT_TRANSFORM;
132           async = QUEUE_BUFFER_INPUT_ASYNC;
133           fence = QUEUE_BUFFER_INPUT_FENCE;
134        }
135
136        IGraphicBufferProducer::QueueBufferInput build() {
137            return IGraphicBufferProducer::QueueBufferInput(
138                    timestamp,
139                    isAutoTimestamp,
140                    crop,
141                    scalingMode,
142                    transform,
143                    async,
144                    fence);
145        }
146
147        QueueBufferInputBuilder& setTimestamp(int64_t timestamp) {
148            this->timestamp = timestamp;
149            return *this;
150        }
151
152        QueueBufferInputBuilder& setIsAutoTimestamp(bool isAutoTimestamp) {
153            this->isAutoTimestamp = isAutoTimestamp;
154            return *this;
155        }
156
157        QueueBufferInputBuilder& setCrop(Rect crop) {
158            this->crop = crop;
159            return *this;
160        }
161
162        QueueBufferInputBuilder& setScalingMode(int scalingMode) {
163            this->scalingMode = scalingMode;
164            return *this;
165        }
166
167        QueueBufferInputBuilder& setTransform(uint32_t transform) {
168            this->transform = transform;
169            return *this;
170        }
171
172        QueueBufferInputBuilder& setAsync(bool async) {
173            this->async = async;
174            return *this;
175        }
176
177        QueueBufferInputBuilder& setFence(sp<Fence> fence) {
178            this->fence = fence;
179            return *this;
180        }
181
182    private:
183        int64_t timestamp;
184        bool isAutoTimestamp;
185        Rect crop;
186        int scalingMode;
187        uint32_t transform;
188        int async;
189        sp<Fence> fence;
190    }; // struct QueueBufferInputBuilder
191
192    // To easily store dequeueBuffer results into containers
193    struct DequeueBufferResult {
194        int slot;
195        sp<Fence> fence;
196    };
197
198    status_t dequeueBuffer(bool async, uint32_t w, uint32_t h, uint32_t format, uint32_t usage, DequeueBufferResult* result) {
199        return mProducer->dequeueBuffer(&result->slot, &result->fence, async, w, h, format, usage);
200    }
201
202private: // hide from test body
203    sp<BufferQueue> mBQ;
204    sp<DummyConsumer> mDC;
205
206protected: // accessible from test body
207    sp<IGraphicBufferProducer> mProducer;
208    sp<IGraphicBufferConsumer> mConsumer;
209};
210
211TEST_F(IGraphicBufferProducerTest, ConnectFirst_ReturnsError) {
212    IGraphicBufferProducer::QueueBufferOutput output;
213
214    // NULL output returns BAD_VALUE
215    EXPECT_EQ(BAD_VALUE, mProducer->connect(TEST_TOKEN,
216                                            TEST_API,
217                                            TEST_CONTROLLED_BY_APP,
218                                            /*output*/NULL));
219
220    // Invalid API returns bad value
221    EXPECT_EQ(BAD_VALUE, mProducer->connect(TEST_TOKEN,
222                                            /*api*/0xDEADBEEF,
223                                            TEST_CONTROLLED_BY_APP,
224                                            &output));
225
226    // TODO: get a token from a dead process somehow
227}
228
229TEST_F(IGraphicBufferProducerTest, ConnectAgain_ReturnsError) {
230    ASSERT_NO_FATAL_FAILURE(ConnectProducer());
231
232    // Can't connect when there is already a producer connected
233    IGraphicBufferProducer::QueueBufferOutput output;
234    EXPECT_EQ(BAD_VALUE, mProducer->connect(TEST_TOKEN,
235                                            TEST_API,
236                                            TEST_CONTROLLED_BY_APP,
237                                            &output));
238
239    ASSERT_OK(mConsumer->consumerDisconnect());
240    // Can't connect when IGBP is abandoned
241    EXPECT_EQ(NO_INIT, mProducer->connect(TEST_TOKEN,
242                                          TEST_API,
243                                          TEST_CONTROLLED_BY_APP,
244                                          &output));
245}
246
247TEST_F(IGraphicBufferProducerTest, Disconnect_Succeeds) {
248    ASSERT_NO_FATAL_FAILURE(ConnectProducer());
249
250    ASSERT_OK(mProducer->disconnect(TEST_API));
251}
252
253
254TEST_F(IGraphicBufferProducerTest, Disconnect_ReturnsError) {
255    ASSERT_NO_FATAL_FAILURE(ConnectProducer());
256
257    // Must disconnect with same API number
258    ASSERT_EQ(BAD_VALUE, mProducer->disconnect(TEST_API_OTHER));
259    // API must not be out of range
260    ASSERT_EQ(BAD_VALUE, mProducer->disconnect(/*api*/0xDEADBEEF));
261
262    // TODO: somehow kill mProducer so that this returns DEAD_OBJECT
263}
264
265TEST_F(IGraphicBufferProducerTest, Query_Succeeds) {
266    ASSERT_NO_FATAL_FAILURE(ConnectProducer());
267
268    // TODO: Make these constants in header
269    const int DEFAULT_CONSUMER_USAGE_BITS = 0;
270
271    int value = -1;
272    EXPECT_OK(mProducer->query(NATIVE_WINDOW_WIDTH, &value));
273    EXPECT_EQ(DEFAULT_WIDTH, value);
274
275    EXPECT_OK(mProducer->query(NATIVE_WINDOW_HEIGHT, &value));
276    EXPECT_EQ(DEFAULT_HEIGHT, value);
277
278    EXPECT_OK(mProducer->query(NATIVE_WINDOW_FORMAT, &value));
279    EXPECT_EQ(DEFAULT_FORMAT, value);
280
281    EXPECT_OK(mProducer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &value));
282    EXPECT_LE(0, value);
283    EXPECT_GE(BufferQueue::NUM_BUFFER_SLOTS, value);
284
285    EXPECT_OK(mProducer->query(NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &value));
286    EXPECT_FALSE(value); // Can't run behind when we haven't touched the queue
287
288    EXPECT_OK(mProducer->query(NATIVE_WINDOW_CONSUMER_USAGE_BITS, &value));
289    EXPECT_EQ(DEFAULT_CONSUMER_USAGE_BITS, value);
290
291}
292
293TEST_F(IGraphicBufferProducerTest, Query_ReturnsError) {
294    ASSERT_NO_FATAL_FAILURE(ConnectProducer());
295
296    // One past the end of the last 'query' enum value. Update this if we add more enums.
297    const int NATIVE_WINDOW_QUERY_LAST_OFF_BY_ONE = NATIVE_WINDOW_CONSUMER_USAGE_BITS + 1;
298
299    int value;
300    // What was out of range
301    EXPECT_EQ(BAD_VALUE, mProducer->query(/*what*/-1, &value));
302    EXPECT_EQ(BAD_VALUE, mProducer->query(/*what*/0xDEADBEEF, &value));
303    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_QUERY_LAST_OFF_BY_ONE, &value));
304
305    // Some enums from window.h are 'invalid'
306    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER, &value));
307    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_CONCRETE_TYPE, &value));
308    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_DEFAULT_WIDTH, &value));
309    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_DEFAULT_HEIGHT, &value));
310    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_TRANSFORM_HINT, &value));
311    // TODO: Consider documented the above enums as unsupported or make a new enum for IGBP
312
313    // Value was NULL
314    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_FORMAT, /*value*/NULL));
315
316    ASSERT_OK(mConsumer->consumerDisconnect());
317
318    // BQ was abandoned
319    EXPECT_EQ(NO_INIT, mProducer->query(NATIVE_WINDOW_FORMAT, &value));
320
321    // TODO: other things in window.h that are supported by Surface::query
322    // but not by BufferQueue::query
323}
324
325// TODO: queue under more complicated situations not involving just a single buffer
326TEST_F(IGraphicBufferProducerTest, Queue_Succeeds) {
327    ASSERT_NO_FATAL_FAILURE(ConnectProducer());
328
329    int dequeuedSlot = -1;
330    sp<Fence> dequeuedFence;
331
332    // XX: OK to assume first call returns this flag or not? Not really documented.
333    ASSERT_EQ(OK | IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
334            mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence,
335                                     QUEUE_BUFFER_INPUT_ASYNC,
336                                     DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT,
337                                     TEST_PRODUCER_USAGE_BITS));
338
339    EXPECT_LE(0, dequeuedSlot);
340    EXPECT_GT(BufferQueue::NUM_BUFFER_SLOTS, dequeuedSlot);
341
342    // Request the buffer (pre-requisite for queueing)
343    sp<GraphicBuffer> dequeuedBuffer;
344    ASSERT_OK(mProducer->requestBuffer(dequeuedSlot, &dequeuedBuffer));
345
346    // A generic "valid" input
347    IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput();
348    IGraphicBufferProducer::QueueBufferOutput output;
349
350    // Queue the buffer back into the BQ
351    ASSERT_OK(mProducer->queueBuffer(dequeuedSlot, input, &output));
352
353    {
354        uint32_t width;
355        uint32_t height;
356        uint32_t transformHint;
357        uint32_t numPendingBuffers;
358
359        output.deflate(&width, &height, &transformHint, &numPendingBuffers);
360
361        EXPECT_EQ(DEFAULT_WIDTH, width);
362        EXPECT_EQ(DEFAULT_HEIGHT, height);
363        EXPECT_EQ(DEFAULT_TRANSFORM_HINT, transformHint);
364        EXPECT_EQ(1, numPendingBuffers); // since queueBuffer was called exactly once
365    }
366
367    // Buffer was not in the dequeued state
368    EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output));
369}
370
371TEST_F(IGraphicBufferProducerTest, Queue_ReturnsError) {
372    ASSERT_NO_FATAL_FAILURE(ConnectProducer());
373
374    // Invalid slot number
375    {
376        // A generic "valid" input
377        IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput();
378        IGraphicBufferProducer::QueueBufferOutput output;
379
380        EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(/*slot*/-1, input, &output));
381        EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(/*slot*/0xDEADBEEF, input, &output));
382        EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(BufferQueue::NUM_BUFFER_SLOTS,
383                                                    input, &output));
384    }
385
386    // Slot was not in the dequeued state (all slots start out in Free state)
387    {
388        IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput();
389        IGraphicBufferProducer::QueueBufferOutput output;
390
391        EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(/*slot*/0, input, &output));
392    }
393
394    // Put the slot into the "dequeued" state for the rest of the test
395    int dequeuedSlot = -1;
396    sp<Fence> dequeuedFence;
397
398    ASSERT_EQ(OK | IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
399            mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence,
400                                     QUEUE_BUFFER_INPUT_ASYNC,
401                                     DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT,
402                                     TEST_PRODUCER_USAGE_BITS));
403
404    // Slot was enqueued without requesting a buffer
405    {
406        IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput();
407        IGraphicBufferProducer::QueueBufferOutput output;
408
409        EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output));
410    }
411
412    // Request the buffer so that the rest of the tests don't fail on earlier checks.
413    sp<GraphicBuffer> dequeuedBuffer;
414    ASSERT_OK(mProducer->requestBuffer(dequeuedSlot, &dequeuedBuffer));
415
416    // Fence was NULL
417    {
418        sp<Fence> nullFence = NULL;
419
420        IGraphicBufferProducer::QueueBufferInput input =
421                QueueBufferInputBuilder().setFence(nullFence).build();
422        IGraphicBufferProducer::QueueBufferOutput output;
423
424        EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output));
425    }
426
427    // Scaling mode was unknown
428    {
429        IGraphicBufferProducer::QueueBufferInput input =
430                QueueBufferInputBuilder().setScalingMode(-1).build();
431        IGraphicBufferProducer::QueueBufferOutput output;
432
433        EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output));
434
435        input = QueueBufferInputBuilder().setScalingMode(0xDEADBEEF).build();
436
437        EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output));
438    }
439
440    // Crop rect is out of bounds of the buffer dimensions
441    {
442        IGraphicBufferProducer::QueueBufferInput input =
443                QueueBufferInputBuilder().setCrop(Rect(DEFAULT_WIDTH + 1, DEFAULT_HEIGHT + 1))
444                .build();
445        IGraphicBufferProducer::QueueBufferOutput output;
446
447        EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output));
448    }
449
450    // Abandon the buffer queue so that the last test fails
451    ASSERT_OK(mConsumer->consumerDisconnect());
452
453    // The buffer queue has been abandoned.
454    {
455        IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput();
456        IGraphicBufferProducer::QueueBufferOutput output;
457
458        EXPECT_EQ(NO_INIT, mProducer->queueBuffer(dequeuedSlot, input, &output));
459    }
460}
461
462TEST_F(IGraphicBufferProducerTest, CancelBuffer_DoesntCrash) {
463    ASSERT_NO_FATAL_FAILURE(ConnectProducer());
464
465    int dequeuedSlot = -1;
466    sp<Fence> dequeuedFence;
467
468    ASSERT_EQ(OK | IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
469            mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence,
470                                     QUEUE_BUFFER_INPUT_ASYNC,
471                                     DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT,
472                                     TEST_PRODUCER_USAGE_BITS));
473
474    // No return code, but at least test that it doesn't blow up...
475    // TODO: add a return code
476    mProducer->cancelBuffer(dequeuedSlot, dequeuedFence);
477}
478
479TEST_F(IGraphicBufferProducerTest, SetBufferCount_Succeeds) {
480
481    // The producer does not wish to set a buffer count
482    EXPECT_OK(mProducer->setBufferCount(0)) << "bufferCount: " << 0;
483    // TODO: how to test "0" buffer count?
484
485    int minBuffers;
486    ASSERT_OK(mProducer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &minBuffers));
487
488    // The MIN_UNDEQUEUED_BUFFERS limit is exclusive, so need to increment by at least 1
489    minBuffers++;
490
491    ASSERT_OK(mProducer->setBufferCount(minBuffers)) << "bufferCount: " << minBuffers;
492
493    std::vector<DequeueBufferResult> dequeueList;
494
495    // Should now be able to dequeue up to minBuffers times
496    for (int i = 0; i < minBuffers; ++i) {
497        DequeueBufferResult result;
498
499        EXPECT_LE(OK,
500                dequeueBuffer(QUEUE_BUFFER_INPUT_ASYNC,
501                              DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT,
502                              TEST_PRODUCER_USAGE_BITS, &result))
503                << "iteration: " << i << ", slot: " << result.slot;
504
505        dequeueList.push_back(result);
506    }
507
508    // Cancel every buffer, so we can set buffer count again
509    for (int i = 0; i < minBuffers; ++i) {
510        DequeueBufferResult& result = dequeueList[i];
511        mProducer->cancelBuffer(result.slot, result.fence);
512    }
513
514    ASSERT_OK(mProducer->setBufferCount(BufferQueue::NUM_BUFFER_SLOTS));
515
516    // Should now be able to dequeue up to NUM_BUFFER_SLOTS times
517    for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; ++i) {
518        int dequeuedSlot = -1;
519        sp<Fence> dequeuedFence;
520
521        EXPECT_LE(OK,
522                mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence,
523                                         QUEUE_BUFFER_INPUT_ASYNC,
524                                         DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT,
525                                         TEST_PRODUCER_USAGE_BITS))
526                << "iteration: " << i << ", slot: " << dequeuedSlot;
527    }
528}
529
530TEST_F(IGraphicBufferProducerTest, SetBufferCount_Fails) {
531    int minBuffers;
532    ASSERT_OK(mProducer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &minBuffers));
533
534    // The MIN_UNDEQUEUED_BUFFERS limit is exclusive, so need to increment by at least 1
535    minBuffers++;
536
537    // Buffer count was out of range
538    EXPECT_EQ(BAD_VALUE, mProducer->setBufferCount(-1)) << "bufferCount: " << -1;
539    EXPECT_EQ(BAD_VALUE, mProducer->setBufferCount(minBuffers - 1)) << "bufferCount: " << minBuffers - 1;
540    EXPECT_EQ(BAD_VALUE, mProducer->setBufferCount(BufferQueue::NUM_BUFFER_SLOTS + 1))
541            << "bufferCount: " << BufferQueue::NUM_BUFFER_SLOTS + 1;
542
543    // Pre-requisite to fail out a valid setBufferCount call
544    {
545        int dequeuedSlot = -1;
546        sp<Fence> dequeuedFence;
547
548        ASSERT_LE(OK,
549                mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence,
550                                         QUEUE_BUFFER_INPUT_ASYNC,
551                                         DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT,
552                                         TEST_PRODUCER_USAGE_BITS))
553                << "slot: " << dequeuedSlot;
554    }
555
556    // Client has one or more buffers dequeued
557    EXPECT_EQ(BAD_VALUE, mProducer->setBufferCount(minBuffers)) << "bufferCount: " << minBuffers;
558
559    // Abandon buffer queue
560    ASSERT_OK(mConsumer->consumerDisconnect());
561
562    // Fail because the buffer queue was abandoned
563    EXPECT_EQ(NO_INIT, mProducer->setBufferCount(minBuffers)) << "bufferCount: " << minBuffers;
564
565}
566
567} // namespace android
568