1/*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15#include <map>
16#include <gtest/gtest.h>
17#include <surface.h>
18#include <buffer_extra_data_impl.h>
19#include <buffer_queue.h>
20#include "buffer_consumer_listener.h"
21#include "sync_fence.h"
22#include "consumer_surface.h"
23#include "producer_surface_delegator.h"
24
25using namespace testing;
26using namespace testing::ext;
27
28namespace OHOS::Rosen {
29class BufferQueueTest : public testing::Test {
30public:
31    static void SetUpTestCase();
32    static void TearDownTestCase();
33
34    static inline BufferRequestConfig requestConfig = {
35        .width = 0x100,
36        .height = 0x100,
37        .strideAlignment = 0x8,
38        .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
39        .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
40        .timeout = 0,
41    };
42    static inline BufferFlushConfigWithDamages flushConfig = {
43        .damages = {
44            {
45                .w = 0x100,
46                .h = 0x100,
47            }
48        },
49    };
50    static inline int64_t timestamp = 0;
51    static inline std::vector<Rect> damages = {};
52    static inline sptr<BufferQueue> bq = nullptr;
53    static inline std::map<int32_t, sptr<SurfaceBuffer>> cache;
54    static inline sptr<BufferExtraData> bedata = nullptr;
55    static inline sptr<ProducerSurfaceDelegator> surfaceDelegator = nullptr;
56    static inline sptr<IConsumerSurface> csurface1 = nullptr;
57};
58
59void BufferQueueTest::SetUpTestCase()
60{
61    bq = new BufferQueue("test");
62    sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
63    bq->RegisterConsumerListener(listener);
64    bedata = new OHOS::BufferExtraDataImpl;
65    csurface1 = IConsumerSurface::Create();
66}
67
68void BufferQueueTest::TearDownTestCase()
69{
70    bq = nullptr;
71}
72
73/*
74* Function: GetUsedSize
75* Type: Function
76* Rank: Important(2)
77* EnvConditions: N/A
78* CaseDescription: 1. call GetUsedSize and check ret
79 */
80HWTEST_F(BufferQueueTest, GetUsedSize001, Function | MediumTest | Level2)
81{
82    uint32_t usedSize = bq->GetUsedSize();
83    ASSERT_NE(usedSize, -1);
84}
85
86/*
87* Function: SetQueueSize and GetQueueSize
88* Type: Function
89* Rank: Important(2)
90* EnvConditions: N/A
91* CaseDescription: 1. call GetQueueSize for default
92*                  2. call SetQueueSize
93*                  3. call SetQueueSize again with abnormal input
94*                  4. check ret and call GetQueueSize
95 */
96HWTEST_F(BufferQueueTest, QueueSize001, Function | MediumTest | Level2)
97{
98    ASSERT_EQ(bq->GetQueueSize(), (uint32_t)SURFACE_DEFAULT_QUEUE_SIZE);
99
100    GSError ret = bq->SetQueueSize(2);
101    ASSERT_EQ(ret, OHOS::GSERROR_OK);
102
103    ret = bq->SetQueueSize(SURFACE_MAX_QUEUE_SIZE + 1);
104    ASSERT_NE(ret, OHOS::GSERROR_OK);
105
106    ASSERT_EQ(bq->GetQueueSize(), 2u);
107    BufferQueue *bqTmp = new BufferQueue("testTmp", true);
108    EXPECT_EQ(bqTmp->SetQueueSize(2), GSERROR_INVALID_ARGUMENTS);
109    EXPECT_EQ(bqTmp->SetQueueSize(1), GSERROR_OK);
110    bqTmp = nullptr;
111}
112
113/*
114* Function: SetQueueSize and GetQueueSize
115* Type: Function
116* Rank: Important(2)
117* EnvConditions: N/A
118* CaseDescription: 1. call SetQueueSize 2 times both with abnormal input
119*                  2. call GetQueueSize
120*                  3. check ret
121 */
122HWTEST_F(BufferQueueTest, QueueSize002, Function | MediumTest | Level2)
123{
124    GSError ret = bq->SetQueueSize(-1);
125    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
126    ASSERT_EQ(bq->GetQueueSize(), 2u);
127
128    ret = bq->SetQueueSize(0);
129    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
130    ASSERT_EQ(bq->GetQueueSize(), 2u);
131}
132
133/*
134* Function: RequestBuffer, FlushBuffer, AcquireBuffer and ReleaseBuffer
135* Type: Function
136* Rank: Important(2)
137* EnvConditions: N/A
138* CaseDescription: 1. call RequestBuffer and FlushBuffer
139*                  2. call AcquireBuffer and ReleaseBuffer
140*                  3. check ret
141 */
142HWTEST_F(BufferQueueTest, ReqCanFluAcqRel001, Function | MediumTest | Level2)
143{
144    IBufferProducer::RequestBufferReturnValue retval;
145
146    // first request
147    GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
148    ASSERT_EQ(ret, OHOS::GSERROR_OK);
149    ASSERT_NE(retval.buffer, nullptr);
150    ASSERT_GE(retval.sequence, 0);
151
152    // add cache
153    cache[retval.sequence] = retval.buffer;
154
155    // buffer queue will map
156    uint8_t *addr1 = reinterpret_cast<uint8_t*>(retval.buffer->GetVirAddr());
157    ASSERT_NE(addr1, nullptr);
158    addr1[0] = 5;
159
160    sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
161    ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
162    ASSERT_EQ(ret, OHOS::GSERROR_OK);
163
164    ret = bq->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
165    ASSERT_EQ(ret, OHOS::GSERROR_OK);
166    ASSERT_NE(retval.buffer, nullptr);
167
168    uint8_t *addr2 = reinterpret_cast<uint8_t*>(retval.buffer->GetVirAddr());
169    ASSERT_NE(addr2, nullptr);
170    if (addr2 != nullptr) {
171        ASSERT_EQ(addr2[0], 5u);
172    }
173
174    sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
175    ret = bq->ReleaseBuffer(retval.buffer, releaseFence);
176    ASSERT_EQ(ret, OHOS::GSERROR_OK);
177}
178
179/*
180* Function: RequestBuffer and CancelBuffer
181* Type: Function
182* Rank: Important(2)
183* EnvConditions: N/A
184* CaseDescription: 1. call RequestBuffer
185*                  2. call CancelBuffer
186*                  3. check ret
187 */
188HWTEST_F(BufferQueueTest, ReqCanFluAcqRel002, Function | MediumTest | Level2)
189{
190    IBufferProducer::RequestBufferReturnValue retval;
191
192    // not first request
193    GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
194    ASSERT_EQ(ret, OHOS::GSERROR_OK);
195    ASSERT_GE(retval.sequence, 0);
196    ASSERT_EQ(retval.buffer, nullptr);
197
198    ret = bq->CancelBuffer(retval.sequence, bedata);
199    ASSERT_EQ(ret, OHOS::GSERROR_OK);
200}
201
202/*
203* Function: RequestBuffer and CancelBuffer
204* Type: Function
205* Rank: Important(2)
206* EnvConditions: N/A
207* CaseDescription: 1. call RequestBuffer
208*                  2. call CancelBuffer 2 times
209*                  3. check ret
210 */
211HWTEST_F(BufferQueueTest, ReqCanFluAcqRel003, Function | MediumTest | Level2)
212{
213    IBufferProducer::RequestBufferReturnValue retval;
214
215    // not first request
216    GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
217    ASSERT_EQ(ret, OHOS::GSERROR_OK);
218    ASSERT_GE(retval.sequence, 0);
219    ASSERT_EQ(retval.buffer, nullptr);
220
221    ret = bq->CancelBuffer(retval.sequence, bedata);
222    ASSERT_EQ(ret, OHOS::GSERROR_OK);
223
224    ret = bq->CancelBuffer(retval.sequence, bedata);
225    ASSERT_NE(ret, OHOS::GSERROR_OK);
226}
227
228/*
229* Function: RequestBuffer and FlushBuffer
230* Type: Function
231* Rank: Important(2)
232* EnvConditions: N/A
233* CaseDescription: 1. call RequestBuffer
234*                  2. call FlushBuffer 2 times
235*                  3. check ret
236 */
237HWTEST_F(BufferQueueTest, ReqCanFluAcqRel004, Function | MediumTest | Level2)
238{
239    IBufferProducer::RequestBufferReturnValue retval;
240
241    // not first request
242    GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
243    ASSERT_EQ(ret, OHOS::GSERROR_OK);
244    ASSERT_GE(retval.sequence, 0);
245    ASSERT_EQ(retval.buffer, nullptr);
246
247    sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
248    ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
249    ASSERT_EQ(ret, OHOS::GSERROR_OK);
250
251    ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
252    ASSERT_NE(ret, OHOS::GSERROR_OK);
253
254    // call SetDesiredPresentTimestampAndUiTimestamp, check desiredPresentTimestamp and uiTimestamp
255    int64_t desiredPresentTimestamp = -1;
256    uint64_t uiTimestamp = 2;
257    bq->SetDesiredPresentTimestampAndUiTimestamp(retval.sequence, desiredPresentTimestamp, uiTimestamp);
258    ASSERT_GT(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, 0);
259    ASSERT_NE(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, uiTimestamp);
260    ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].timestamp, uiTimestamp);
261
262    desiredPresentTimestamp = 0;
263    bq->SetDesiredPresentTimestampAndUiTimestamp(retval.sequence, desiredPresentTimestamp, uiTimestamp);
264    ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, uiTimestamp);
265    ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].timestamp, uiTimestamp);
266
267    desiredPresentTimestamp = 1;
268    bq->SetDesiredPresentTimestampAndUiTimestamp(retval.sequence, desiredPresentTimestamp, uiTimestamp);
269    ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, desiredPresentTimestamp);
270    ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].timestamp, uiTimestamp);
271}
272
273/*
274* Function: AcquireBuffer and ReleaseBuffer
275* Type: Function
276* Rank: Important(2)
277* EnvConditions: N/A
278* CaseDescription: 1. call AcquireBuffer
279*                  2. call ReleaseBuffer 2 times
280*                  3. check ret
281 */
282HWTEST_F(BufferQueueTest, ReqCanFluAcqRel005, Function | MediumTest | Level2)
283{
284    sptr<SurfaceBuffer> buffer;
285
286    sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
287    GSError ret = bq->AcquireBuffer(buffer, acquireFence, timestamp, damages);
288    ASSERT_EQ(ret, OHOS::GSERROR_OK);
289
290    sptr<SyncFence> ReleaseFence = SyncFence::INVALID_FENCE;
291    ret = bq->ReleaseBuffer(buffer, ReleaseFence);
292    ASSERT_EQ(ret, OHOS::GSERROR_OK);
293
294    ret = bq->ReleaseBuffer(buffer, ReleaseFence);
295    ASSERT_NE(ret, OHOS::GSERROR_OK);
296}
297
298/*
299* Function: RequestBuffer, and CancelBuffer
300* Type: Function
301* Rank: Important(2)
302* EnvConditions: N/A
303* CaseDescription: 1. call RequestBuffer and CancelBuffer by different retval
304*                  2. check ret
305 */
306HWTEST_F(BufferQueueTest, ReqCanFluAcqRel006, Function | MediumTest | Level2)
307{
308    IBufferProducer::RequestBufferReturnValue retval1;
309    IBufferProducer::RequestBufferReturnValue retval2;
310    IBufferProducer::RequestBufferReturnValue retval3;
311    GSError ret;
312
313    // not alloc
314    ret = bq->RequestBuffer(requestConfig, bedata, retval1);
315    ASSERT_EQ(ret, OHOS::GSERROR_OK);
316    ASSERT_GE(retval1.sequence, 0);
317    ASSERT_EQ(retval1.buffer, nullptr);
318
319    // alloc
320    ret = bq->RequestBuffer(requestConfig, bedata, retval2);
321    ASSERT_EQ(ret, OHOS::GSERROR_OK);
322    ASSERT_GE(retval2.sequence, 0);
323    ASSERT_NE(retval2.buffer, nullptr);
324
325    cache[retval2.sequence] = retval2.buffer;
326
327    // no buffer
328    ret = bq->RequestBuffer(requestConfig, bedata, retval3);
329    ASSERT_NE(ret, OHOS::GSERROR_OK);
330    ASSERT_EQ(retval3.buffer, nullptr);
331
332    ret = bq->CancelBuffer(retval1.sequence, bedata);
333    ASSERT_EQ(ret, OHOS::GSERROR_OK);
334
335    ret = bq->CancelBuffer(retval2.sequence, bedata);
336    ASSERT_EQ(ret, OHOS::GSERROR_OK);
337
338    ret = bq->CancelBuffer(retval3.sequence, bedata);
339    ASSERT_NE(ret, OHOS::GSERROR_OK);
340}
341
342/*
343* Function: RequestBuffer, ReleaseBuffer and FlushBuffer
344* Type: Function
345* Rank: Important(2)
346* EnvConditions: N/A
347* CaseDescription: 1. call RequestBuffer
348*                  2. call ReleaseBuffer
349*                  3. call FlushBuffer
350*                  4. check ret
351 */
352HWTEST_F(BufferQueueTest, ReqCanFluAcqRel007, Function | MediumTest | Level2)
353{
354    IBufferProducer::RequestBufferReturnValue retval;
355
356    // not alloc
357    GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
358    ASSERT_EQ(ret, OHOS::GSERROR_OK);
359    ASSERT_GE(retval.sequence, 0);
360    ASSERT_EQ(retval.buffer, nullptr);
361
362    retval.buffer = cache[retval.sequence];
363
364    sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
365    ret = bq->ReleaseBuffer(retval.buffer, releaseFence);
366    ASSERT_NE(ret, OHOS::GSERROR_OK);
367
368    sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
369    ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
370    ASSERT_EQ(ret, OHOS::GSERROR_OK);
371}
372
373/*
374* Function: AcquireBuffer, FlushBuffer and ReleaseBuffer
375* Type: Function
376* Rank: Important(2)
377* EnvConditions: N/A
378* CaseDescription: 1. call AcquireBuffer
379*                  2. call FlushBuffer
380*                  3. call ReleaseBuffer
381*                  4. check ret
382 */
383HWTEST_F(BufferQueueTest, ReqCanFluAcqRel008, Function | MediumTest | Level2)
384{
385    sptr<SurfaceBuffer> buffer;
386    sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
387
388    // acq from last test
389    GSError ret = bq->AcquireBuffer(buffer, acquireFence, timestamp, damages);
390    ASSERT_EQ(ret, OHOS::GSERROR_OK);
391
392    uint32_t sequence;
393    for (auto it = cache.begin(); it != cache.end(); it++) {
394        if (it->second.GetRefPtr() == buffer.GetRefPtr()) {
395            sequence = it->first;
396        }
397    }
398    ASSERT_GE(sequence, 0);
399
400    ret = bq->FlushBuffer(sequence, bedata, acquireFence, flushConfig);
401    ASSERT_NE(ret, OHOS::GSERROR_OK);
402
403    sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
404    ret = bq->ReleaseBuffer(buffer, releaseFence);
405    ASSERT_EQ(ret, OHOS::GSERROR_OK);
406}
407
408/*
409* Function: RequestBuffer and CancelBuffer
410* Type: Function
411* Rank: Important(2)
412* EnvConditions: N/A
413* CaseDescription: 1. call RequestBuffer
414*                  2. call CancelBuffer
415*                  3. check retval and ret
416 */
417HWTEST_F(BufferQueueTest, ReqCanFluAcqRel009, Function | MediumTest | Level2)
418{
419    IBufferProducer::RequestBufferReturnValue retval;
420    BufferRequestConfig deleteconfig = requestConfig;
421    deleteconfig.width = 1921;
422
423    GSError ret = bq->RequestBuffer(deleteconfig, bedata, retval);
424    ASSERT_EQ(ret, OHOS::GSERROR_OK);
425    ASSERT_EQ(retval.deletingBuffers.size(), 1u);
426    ASSERT_GE(retval.sequence, 0);
427    ASSERT_NE(retval.buffer, nullptr);
428
429    ret = bq->CancelBuffer(retval.sequence, bedata);
430    ASSERT_EQ(ret, OHOS::GSERROR_OK);
431}
432
433/*
434* Function: RequestBuffer
435* Type: Function
436* Rank: Important(2)
437* EnvConditions: N/A
438* CaseDescription: 1. set BufferRequestConfig with abnormal value
439*                  2. call RequestBuffer
440*                  3. check ret
441 */
442HWTEST_F(BufferQueueTest, RequestBuffer001, Function | MediumTest | Level2)
443{
444    IBufferProducer::RequestBufferReturnValue retval;
445    BufferRequestConfig config = requestConfig;
446    config.width = -1;
447
448    GSError ret = bq->RequestBuffer(config, bedata, retval);
449    ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
450}
451
452/*
453* Function: RequestBuffer
454* Type: Function
455* Rank: Important(2)
456* EnvConditions: N/A
457* CaseDescription: 1. set BufferRequestConfig with abnormal value
458*                  2. call RequestBuffer
459*                  3. check ret
460 */
461HWTEST_F(BufferQueueTest, RequestBuffer002, Function | MediumTest | Level2)
462{
463    IBufferProducer::RequestBufferReturnValue retval;
464    BufferRequestConfig config = requestConfig;
465    config.height = -1;
466
467    GSError ret = bq->RequestBuffer(config, bedata, retval);
468    ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
469}
470
471
472/*
473* Function: RequestBuffer
474* Type: Function
475* Rank: Important(2)
476* EnvConditions: N/A
477* CaseDescription: 1. set BufferRequestConfig with abnormal value
478*                  2. call RequestBuffer
479*                  3. check ret
480 */
481HWTEST_F(BufferQueueTest, RequestBuffer003, Function | MediumTest | Level2)
482{
483    IBufferProducer::RequestBufferReturnValue retval;
484    BufferRequestConfig config = requestConfig;
485    config.strideAlignment = SURFACE_MIN_STRIDE_ALIGNMENT - 1;
486
487    GSError ret = bq->RequestBuffer(config, bedata, retval);
488    ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
489}
490
491/*
492* Function: RequestBuffer
493* Type: Function
494* Rank: Important(2)
495* EnvConditions: N/A
496* CaseDescription: 1. set BufferRequestConfig with abnormal value
497*                  2. call RequestBuffer
498*                  3. check ret
499 */
500HWTEST_F(BufferQueueTest, RequestBuffer004, Function | MediumTest | Level2)
501{
502    IBufferProducer::RequestBufferReturnValue retval;
503    BufferRequestConfig config = requestConfig;
504    config.strideAlignment = SURFACE_MAX_STRIDE_ALIGNMENT + 1;
505
506    GSError ret = bq->RequestBuffer(config, bedata, retval);
507    ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
508}
509
510/*
511* Function: RequestBuffer
512* Type: Function
513* Rank: Important(2)
514* EnvConditions: N/A
515* CaseDescription: 1. set BufferRequestConfig with abnormal value
516*                  2. call RequestBuffer
517*                  3. check ret
518 */
519HWTEST_F(BufferQueueTest, RequestBuffer005, Function | MediumTest | Level2)
520{
521    IBufferProducer::RequestBufferReturnValue retval;
522    BufferRequestConfig config = requestConfig;
523    config.strideAlignment = 3;
524
525    GSError ret = bq->RequestBuffer(config, bedata, retval);
526    ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
527}
528
529/*
530* Function: RequestBuffer
531* Type: Function
532* Rank: Important(2)
533* EnvConditions: N/A
534* CaseDescription: 1. set BufferRequestConfig with abnormal value
535*                  2. call RequestBuffer
536*                  3. check ret
537 */
538HWTEST_F(BufferQueueTest, RequestBuffer006, Function | MediumTest | Level2)
539{
540    IBufferProducer::RequestBufferReturnValue retval;
541    BufferRequestConfig config = requestConfig;
542    config.format = -1;
543
544    GSError ret = bq->RequestBuffer(config, bedata, retval);
545    ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
546}
547
548/*
549* Function: QueryIfBufferAvailable
550* Type: Function
551* Rank: Important(2)
552* EnvConditions: N/A
553* CaseDescription: 1. call QueryIfBufferAvailable and check ret
554 */
555HWTEST_F(BufferQueueTest, QueryIfBufferAvailable001, Function | MediumTest | Level2)
556{
557    bq->CleanCache(false);
558    bool ret = bq->QueryIfBufferAvailable();
559    ASSERT_EQ(ret, true);
560
561    GSError reqRet = OHOS::GSERROR_OK;
562    IBufferProducer::RequestBufferReturnValue retval;
563    BufferRequestConfig config = requestConfig;
564    while (reqRet != OHOS::GSERROR_NO_BUFFER) {
565        reqRet = bq->RequestBuffer(config, bedata, retval);
566    }
567
568    ret = bq->QueryIfBufferAvailable();
569    ASSERT_EQ(ret, false);
570}
571
572/*
573* Function: GetName
574* Type: Function
575* Rank: Important(2)
576* EnvConditions: N/A
577* CaseDescription: 1. call GetName and check ret
578 */
579HWTEST_F(BufferQueueTest, GetName001, Function | MediumTest | Level2)
580{
581    std::string name("na");
582    GSError ret = bq->GetName(name);
583    ASSERT_EQ(ret, GSERROR_OK);
584    ASSERT_NE(name, "na");
585}
586
587/*
588* Function: RegisterConsumerListener
589* Type: Function
590* Rank: Important(2)
591* EnvConditions: N/A
592* CaseDescription: 1. call RegisterConsumerListener and check ret
593 */
594HWTEST_F(BufferQueueTest, RegisterConsumerListener001, Function | MediumTest | Level2)
595{
596    sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
597    GSError ret = bq->RegisterConsumerListener(listener);
598    ASSERT_EQ(ret, GSERROR_OK);
599}
600
601/*
602* Function: SetDefaultWidthAndHeight
603* Type: Function
604* Rank: Important(2)
605* EnvConditions: N/A
606* CaseDescription: 1. call SetDefaultWidthAndHeight and check ret
607 */
608HWTEST_F(BufferQueueTest, SetDefaultWidthAndHeight001, Function | MediumTest | Level2)
609{
610    int width = 0;
611    int height = 0;
612    GSError ret = bq->SetDefaultWidthAndHeight(width, height);
613    ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
614
615    width = 1;
616    ret = bq->SetDefaultWidthAndHeight(width, height);
617    ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
618
619    width = 80;
620    height = 80;
621    ret = bq->SetDefaultWidthAndHeight(width, height);
622    ASSERT_EQ(ret, GSERROR_OK);
623}
624
625/*
626* Function: GetDefaultWidth and GetDefaultHeight
627* Type: Function
628* Rank: Important(2)
629* EnvConditions: N/A
630* CaseDescription: 1. call GetDefaultWidth and check ret
631 */
632HWTEST_F(BufferQueueTest, GetDefaultWidth001, Function | MediumTest | Level2)
633{
634    int32_t width = 80;
635    int32_t height = 80;
636    GSError ret = bq->SetDefaultWidthAndHeight(width, height);
637    ASSERT_EQ(ret, GSERROR_OK);
638
639    ASSERT_EQ(width, bq->GetDefaultWidth());
640    ASSERT_EQ(height, bq->GetDefaultHeight());
641}
642
643/*
644* Function: SetDefaultUsage and GetDefaultUsage
645* Type: Function
646* Rank: Important(2)
647* EnvConditions: N/A
648* CaseDescription: 1. call SetDefaultUsage and check ret
649 */
650HWTEST_F(BufferQueueTest, SetDefaultUsage001, Function | MediumTest | Level2)
651{
652    uint64_t usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA;
653    GSError ret = bq->SetDefaultUsage(usage);
654    ASSERT_EQ(ret, GSERROR_OK);
655    ASSERT_EQ(usage, bq->GetDefaultUsage());
656}
657
658/*
659* Function: CleanCache
660* Type: Function
661* Rank: Important(2)
662* EnvConditions: N/A
663* CaseDescription: 1. call CleanCache and check ret
664 */
665HWTEST_F(BufferQueueTest, CleanCache001, Function | MediumTest | Level2)
666{
667    GSError ret = bq->CleanCache(false);
668    ASSERT_EQ(ret, GSERROR_OK);
669}
670/*
671* Function: AttachBufferUpdateStatus
672* Type: Function
673* Rank: Important(2)
674* EnvConditions: N/A
675* CaseDescription: 1. call AttachBufferUpdateStatus and check ret
676 */
677HWTEST_F(BufferQueueTest, AttachBufferUpdateStatus, Function | MediumTest | Level2)
678{
679    uint32_t sequence = 2;
680    int32_t timeOut = 6;
681    std::mutex mutex_;
682    std::unique_lock<std::mutex> lock(mutex_);
683    GSError ret = bq->AttachBufferUpdateStatus(lock, sequence, timeOut);
684    ASSERT_EQ(ret, GSERROR_OK);
685}
686
687/*
688* Function: AttachBuffer
689* Type: Function
690* Rank: Important(2)
691* EnvConditions: N/A
692* CaseDescription: 1. call AttachBuffer, DetachBuffer and check ret
693 */
694HWTEST_F(BufferQueueTest, AttachBufferAndDetachBuffer001, Function | MediumTest | Level2)
695{
696    bq->CleanCache(false);
697    int32_t timeOut = 6;
698    IBufferProducer::RequestBufferReturnValue retval;
699    GSError ret = bq->AttachBuffer(retval.buffer, timeOut);
700    ASSERT_EQ(ret, GSERROR_INVALID_OPERATING);
701    EXPECT_EQ(bq->DetachBuffer(retval.buffer), GSERROR_INVALID_ARGUMENTS);
702    sptr<SurfaceBuffer> buffer = nullptr;
703    EXPECT_EQ(bq->DetachBuffer(buffer), GSERROR_INVALID_ARGUMENTS);
704    BufferQueue *bqTmp = new BufferQueue("testTmp", true);
705    EXPECT_EQ(bqTmp->DetachBuffer(buffer), GSERROR_INVALID_OPERATING);
706    bqTmp = nullptr;
707}
708
709/*
710* Function: AttachBuffer
711* Type: Function
712* Rank: Important(2)
713* EnvConditions: N/A
714* CaseDescription: 1. call AttachBuffer, DetachBuffer and check ret
715 */
716HWTEST_F(BufferQueueTest, AttachBufferAndDetachBuffer002, Function | MediumTest | Level2)
717{
718    bq->CleanCache(false);
719    int32_t timeOut = 6;
720    EXPECT_EQ(bq->SetQueueSize(SURFACE_MAX_QUEUE_SIZE), GSERROR_OK);
721    sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
722    ASSERT_NE(buffer, nullptr);
723    GSError ret = bq->AttachBuffer(buffer, timeOut);
724    sptr<SurfaceBuffer> buffer1 = SurfaceBuffer::Create();
725    EXPECT_EQ(bq->GetUsedSize(), 1);
726    ASSERT_EQ(ret, GSERROR_OK);
727    EXPECT_EQ(bq->AttachBuffer(buffer1, timeOut), GSERROR_OK);
728    ret= bq->DetachBuffer(buffer);
729    EXPECT_EQ(ret, GSERROR_NO_ENTRY);
730    EXPECT_EQ(bq->DetachBuffer(buffer1), GSERROR_NO_ENTRY);
731    EXPECT_EQ(bq->AllocBuffer(buffer1, requestConfig), GSERROR_OK);
732    EXPECT_EQ(bq->DetachBuffer(buffer1), GSERROR_OK);
733}
734
735/*
736* Function: RegisterSurfaceDelegator
737* Type: Function
738* Rank: Important(2)
739* EnvConditions: N/A
740* CaseDescription: 1. call RegisterSurfaceDelegator and check ret
741 */
742HWTEST_F(BufferQueueTest, RegisterSurfaceDelegator001, Function | MediumTest | Level2)
743{
744    surfaceDelegator = ProducerSurfaceDelegator::Create();
745    GSError ret = bq->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), csurface1);
746    ASSERT_EQ(ret, GSERROR_OK);
747}
748
749/*
750* Function: RegisterDeleteBufferListener
751* Type: Function
752* Rank: Important(2)
753* EnvConditions: N/A
754* CaseDescription: 1. call RegisterDeleteBufferListener and check ret
755 */
756HWTEST_F(BufferQueueTest, RegisterDeleteBufferListener001, Function | MediumTest | Level2)
757{
758    surfaceDelegator = ProducerSurfaceDelegator::Create();
759    GSError ret = bq->RegisterDeleteBufferListener(nullptr, true);
760    ASSERT_EQ(ret, GSERROR_OK);
761}
762
763/*
764* Function: QueueAndDequeueDelegator
765* Type: Function
766* Rank: Important(2)
767* EnvConditions: N/A
768* CaseDescription: 1. call RegisterSurfaceDelegator and check ret
769*                  2. call RequestBuffer and check ret (this will call DelegatorDequeueBuffer)
770*                  3. call FlushBuffer and check ret (this will call DelegatorQueueBuffer)
771 */
772HWTEST_F(BufferQueueTest, QueueAndDequeueDelegator001, Function | MediumTest | Level2)
773{
774    surfaceDelegator = ProducerSurfaceDelegator::Create();
775    GSError ret = bq->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), csurface1);
776    ASSERT_EQ(ret, GSERROR_OK);
777
778    IBufferProducer::RequestBufferReturnValue retval;
779    ret = bq->RequestBuffer(requestConfig, bedata, retval);
780    ASSERT_EQ(ret, GSERROR_OK);
781    ASSERT_NE(retval.buffer, nullptr);
782    ASSERT_GE(retval.sequence, 0);
783
784    sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
785    ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
786    ASSERT_EQ(ret, OHOS::GSERROR_OK);
787}
788
789/*
790* Function: SetSurfaceSourceType and GetSurfaceSourceType
791* Type: Function
792* Rank: Important(2)
793* EnvConditions: N/A
794* CaseDescription: 1. call SetSurfaceSourceType and check ret
795*                  2. call GetSurfaceSourceType and check the value
796*/
797HWTEST_F(BufferQueueTest, SurfaceSourceType001, Function | MediumTest | Level2)
798{
799    OHSurfaceSource sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
800    GSError ret = bq->SetSurfaceSourceType(sourceType);
801    ASSERT_EQ(ret, OHOS::GSERROR_OK);
802    ASSERT_EQ(sourceType, bq->GetSurfaceSourceType());
803}
804
805/*
806* Function: SetSurfaceAppFrameworkType
807* Type: Function
808* Rank: Important(2)
809* EnvConditions: N/A
810* CaseDescription: 1. call SetSurfaceAppFrameworkType and check ret
811*/
812HWTEST_F(BufferQueueTest, SetSurfaceAppFrameworkType001, Function | MediumTest | Level2)
813{
814    std::string type = "";
815    GSError ret = bq->SetSurfaceAppFrameworkType(type);
816    ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
817
818    std::string type1 = "AAAAABBBBBCCCCCDDDDDEEEEEFFFFFGGGGGAAAAABBBBBCCCCCDDDDDEEEEEFFFFFGGGGG";
819    ret = bq->SetSurfaceAppFrameworkType(type1);
820    ASSERT_EQ(ret, OHOS::GSERROR_OUT_OF_RANGE);
821
822    std::string type2 = "test";
823    ret = bq->SetSurfaceAppFrameworkType(type2);
824    ASSERT_EQ(ret, OHOS::GSERROR_OK);
825}
826
827/*
828* Function: GetSurfaceAppFrameworkType
829* Type: Function
830* Rank: Important(2)
831* EnvConditions: N/A
832* CaseDescription: 1. call GetSurfaceAppFrameworkType and check value
833*/
834HWTEST_F(BufferQueueTest, GetSurfaceAppFrameworkType001, Function | MediumTest | Level2)
835{
836    std::string type = "test";
837    GSError ret = bq->SetSurfaceAppFrameworkType(type);
838    ASSERT_EQ(ret, OHOS::GSERROR_OK);
839    ASSERT_EQ(bq->GetSurfaceAppFrameworkType(), "test");
840}
841
842/*
843* Function: SetGlobalAlpha and GetGlobalAlpha
844* Type: Function
845* Rank: Important(2)
846* EnvConditions: N/A
847* CaseDescription: 1. call SetGlobalAlpha and check value
848*                  2. call GetGlobalAlpha and check value
849*/
850HWTEST_F(BufferQueueTest, SetGlobalAlpha001, Function | MediumTest | Level2)
851{
852    int32_t alpha = 255;
853    GSError ret = bq->SetGlobalAlpha(alpha);
854    ASSERT_EQ(ret, OHOS::GSERROR_OK);
855
856    int32_t resultAlpha = -1;
857    ret = bq->GetGlobalAlpha(resultAlpha);
858    ASSERT_EQ(ret, OHOS::GSERROR_OK);
859    ASSERT_EQ(resultAlpha, alpha);
860}
861}
862