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
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS::Rosen {
29 class BufferQueueTest : public testing::Test {
30 public:
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
SetUpTestCase()59 void 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
TearDownTestCase()68 void BufferQueueTest::TearDownTestCase()
69 {
70 bq = nullptr;
71 }
72
73 /*
74 * Function: Init
75 * Type: Function
76 * Rank: Important(2)
77 * EnvConditions: N/A
78 * CaseDescription: 1. call Init and check ret
79 */
80 HWTEST_F(BufferQueueTest, Init001, Function | MediumTest | Level2)
81 {
82 GSError ret = bq->Init();
83 ASSERT_EQ(ret, OHOS::GSERROR_OK);
84 }
85
86 /*
87 * Function: GetUsedSize
88 * Type: Function
89 * Rank: Important(2)
90 * EnvConditions: N/A
91 * CaseDescription: 1. call GetUsedSize and check ret
92 */
93 HWTEST_F(BufferQueueTest, GetUsedSize001, Function | MediumTest | Level2)
94 {
95 uint32_t usedSize = bq->GetUsedSize();
96 ASSERT_NE(usedSize, -1);
97 }
98
99 /*
100 * Function: SetQueueSize and GetQueueSize
101 * Type: Function
102 * Rank: Important(2)
103 * EnvConditions: N/A
104 * CaseDescription: 1. call GetQueueSize for default
105 * 2. call SetQueueSize
106 * 3. call SetQueueSize again with abnormal input
107 * 4. check ret and call GetQueueSize
108 */
109 HWTEST_F(BufferQueueTest, QueueSize001, Function | MediumTest | Level2)
110 {
111 ASSERT_EQ(bq->GetQueueSize(), (uint32_t)SURFACE_DEFAULT_QUEUE_SIZE);
112
113 GSError ret = bq->SetQueueSize(2);
114 ASSERT_EQ(ret, OHOS::GSERROR_OK);
115
116 ret = bq->SetQueueSize(SURFACE_MAX_QUEUE_SIZE + 1);
117 ASSERT_NE(ret, OHOS::GSERROR_OK);
118
119 ASSERT_EQ(bq->GetQueueSize(), 2u);
120 BufferQueue *bqTmp = new BufferQueue("testTmp", true);
121 EXPECT_EQ(bqTmp->SetQueueSize(2), GSERROR_INVALID_ARGUMENTS);
122 EXPECT_EQ(bqTmp->SetQueueSize(1), GSERROR_OK);
123 bqTmp = nullptr;
124 }
125
126 /*
127 * Function: SetQueueSize and GetQueueSize
128 * Type: Function
129 * Rank: Important(2)
130 * EnvConditions: N/A
131 * CaseDescription: 1. call SetQueueSize 2 times both with abnormal input
132 * 2. call GetQueueSize
133 * 3. check ret
134 */
135 HWTEST_F(BufferQueueTest, QueueSize002, Function | MediumTest | Level2)
136 {
137 GSError ret = bq->SetQueueSize(-1);
138 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
139 ASSERT_EQ(bq->GetQueueSize(), 2u);
140
141 ret = bq->SetQueueSize(0);
142 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
143 ASSERT_EQ(bq->GetQueueSize(), 2u);
144 }
145
146 /*
147 * Function: RequestBuffer, FlushBuffer, AcquireBuffer and ReleaseBuffer
148 * Type: Function
149 * Rank: Important(2)
150 * EnvConditions: N/A
151 * CaseDescription: 1. call RequestBuffer and FlushBuffer
152 * 2. call AcquireBuffer and ReleaseBuffer
153 * 3. check ret
154 */
155 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel001, Function | MediumTest | Level2)
156 {
157 IBufferProducer::RequestBufferReturnValue retval;
158
159 // first request
160 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
161 ASSERT_EQ(ret, OHOS::GSERROR_OK);
162 ASSERT_NE(retval.buffer, nullptr);
163 ASSERT_GE(retval.sequence, 0);
164
165 // add cache
166 cache[retval.sequence] = retval.buffer;
167
168 // buffer queue will map
169 uint8_t *addr1 = reinterpret_cast<uint8_t*>(retval.buffer->GetVirAddr());
170 ASSERT_NE(addr1, nullptr);
171 addr1[0] = 5;
172
173 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
174 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
175 ASSERT_EQ(ret, OHOS::GSERROR_OK);
176
177 ret = bq->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
178 ASSERT_EQ(ret, OHOS::GSERROR_OK);
179 ASSERT_NE(retval.buffer, nullptr);
180
181 uint8_t *addr2 = reinterpret_cast<uint8_t*>(retval.buffer->GetVirAddr());
182 ASSERT_NE(addr2, nullptr);
183 if (addr2 != nullptr) {
184 ASSERT_EQ(addr2[0], 5u);
185 }
186
187 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
188 ret = bq->ReleaseBuffer(retval.buffer, releaseFence);
189 ASSERT_EQ(ret, OHOS::GSERROR_OK);
190 }
191
192 /*
193 * Function: RequestBuffer and CancelBuffer
194 * Type: Function
195 * Rank: Important(2)
196 * EnvConditions: N/A
197 * CaseDescription: 1. call RequestBuffer
198 * 2. call CancelBuffer
199 * 3. check ret
200 */
201 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel002, Function | MediumTest | Level2)
202 {
203 IBufferProducer::RequestBufferReturnValue retval;
204
205 // not first request
206 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
207 ASSERT_EQ(ret, OHOS::GSERROR_OK);
208 ASSERT_GE(retval.sequence, 0);
209 ASSERT_EQ(retval.buffer, nullptr);
210
211 ret = bq->CancelBuffer(retval.sequence, bedata);
212 ASSERT_EQ(ret, OHOS::GSERROR_OK);
213 }
214
215 /*
216 * Function: RequestBuffer and CancelBuffer
217 * Type: Function
218 * Rank: Important(2)
219 * EnvConditions: N/A
220 * CaseDescription: 1. call RequestBuffer
221 * 2. call CancelBuffer 2 times
222 * 3. check ret
223 */
224 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel003, Function | MediumTest | Level2)
225 {
226 IBufferProducer::RequestBufferReturnValue retval;
227
228 // not first request
229 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
230 ASSERT_EQ(ret, OHOS::GSERROR_OK);
231 ASSERT_GE(retval.sequence, 0);
232 ASSERT_EQ(retval.buffer, nullptr);
233
234 ret = bq->CancelBuffer(retval.sequence, bedata);
235 ASSERT_EQ(ret, OHOS::GSERROR_OK);
236
237 ret = bq->CancelBuffer(retval.sequence, bedata);
238 ASSERT_NE(ret, OHOS::GSERROR_OK);
239 }
240
241 /*
242 * Function: RequestBuffer and FlushBuffer
243 * Type: Function
244 * Rank: Important(2)
245 * EnvConditions: N/A
246 * CaseDescription: 1. call RequestBuffer
247 * 2. call FlushBuffer 2 times
248 * 3. check ret
249 */
250 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel004, Function | MediumTest | Level2)
251 {
252 IBufferProducer::RequestBufferReturnValue retval;
253
254 // not first request
255 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
256 ASSERT_EQ(ret, OHOS::GSERROR_OK);
257 ASSERT_GE(retval.sequence, 0);
258 ASSERT_EQ(retval.buffer, nullptr);
259
260 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
261 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
262 ASSERT_EQ(ret, OHOS::GSERROR_OK);
263
264 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
265 ASSERT_NE(ret, OHOS::GSERROR_OK);
266 }
267
268 /*
269 * Function: AcquireBuffer and ReleaseBuffer
270 * Type: Function
271 * Rank: Important(2)
272 * EnvConditions: N/A
273 * CaseDescription: 1. call AcquireBuffer
274 * 2. call ReleaseBuffer 2 times
275 * 3. check ret
276 */
277 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel005, Function | MediumTest | Level2)
278 {
279 sptr<SurfaceBuffer> buffer;
280
281 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
282 GSError ret = bq->AcquireBuffer(buffer, acquireFence, timestamp, damages);
283 ASSERT_EQ(ret, OHOS::GSERROR_OK);
284
285 sptr<SyncFence> ReleaseFence = SyncFence::INVALID_FENCE;
286 ret = bq->ReleaseBuffer(buffer, ReleaseFence);
287 ASSERT_EQ(ret, OHOS::GSERROR_OK);
288
289 ret = bq->ReleaseBuffer(buffer, ReleaseFence);
290 ASSERT_NE(ret, OHOS::GSERROR_OK);
291 }
292
293 /*
294 * Function: RequestBuffer, and CancelBuffer
295 * Type: Function
296 * Rank: Important(2)
297 * EnvConditions: N/A
298 * CaseDescription: 1. call RequestBuffer and CancelBuffer by different retval
299 * 2. check ret
300 */
301 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel006, Function | MediumTest | Level2)
302 {
303 IBufferProducer::RequestBufferReturnValue retval1;
304 IBufferProducer::RequestBufferReturnValue retval2;
305 IBufferProducer::RequestBufferReturnValue retval3;
306 GSError ret;
307
308 // not alloc
309 ret = bq->RequestBuffer(requestConfig, bedata, retval1);
310 ASSERT_EQ(ret, OHOS::GSERROR_OK);
311 ASSERT_GE(retval1.sequence, 0);
312 ASSERT_EQ(retval1.buffer, nullptr);
313
314 // alloc
315 ret = bq->RequestBuffer(requestConfig, bedata, retval2);
316 ASSERT_EQ(ret, OHOS::GSERROR_OK);
317 ASSERT_GE(retval2.sequence, 0);
318 ASSERT_NE(retval2.buffer, nullptr);
319
320 cache[retval2.sequence] = retval2.buffer;
321
322 // no buffer
323 ret = bq->RequestBuffer(requestConfig, bedata, retval3);
324 ASSERT_NE(ret, OHOS::GSERROR_OK);
325 ASSERT_EQ(retval3.buffer, nullptr);
326
327 ret = bq->CancelBuffer(retval1.sequence, bedata);
328 ASSERT_EQ(ret, OHOS::GSERROR_OK);
329
330 ret = bq->CancelBuffer(retval2.sequence, bedata);
331 ASSERT_EQ(ret, OHOS::GSERROR_OK);
332
333 ret = bq->CancelBuffer(retval3.sequence, bedata);
334 ASSERT_NE(ret, OHOS::GSERROR_OK);
335 }
336
337 /*
338 * Function: RequestBuffer, ReleaseBuffer and FlushBuffer
339 * Type: Function
340 * Rank: Important(2)
341 * EnvConditions: N/A
342 * CaseDescription: 1. call RequestBuffer
343 * 2. call ReleaseBuffer
344 * 3. call FlushBuffer
345 * 4. check ret
346 */
347 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel007, Function | MediumTest | Level2)
348 {
349 IBufferProducer::RequestBufferReturnValue retval;
350
351 // not alloc
352 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
353 ASSERT_EQ(ret, OHOS::GSERROR_OK);
354 ASSERT_GE(retval.sequence, 0);
355 ASSERT_EQ(retval.buffer, nullptr);
356
357 retval.buffer = cache[retval.sequence];
358
359 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
360 ret = bq->ReleaseBuffer(retval.buffer, releaseFence);
361 ASSERT_NE(ret, OHOS::GSERROR_OK);
362
363 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
364 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
365 ASSERT_EQ(ret, OHOS::GSERROR_OK);
366 }
367
368 /*
369 * Function: AcquireBuffer, FlushBuffer and ReleaseBuffer
370 * Type: Function
371 * Rank: Important(2)
372 * EnvConditions: N/A
373 * CaseDescription: 1. call AcquireBuffer
374 * 2. call FlushBuffer
375 * 3. call ReleaseBuffer
376 * 4. check ret
377 */
378 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel008, Function | MediumTest | Level2)
379 {
380 sptr<SurfaceBuffer> buffer;
381 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
382
383 // acq from last test
384 GSError ret = bq->AcquireBuffer(buffer, acquireFence, timestamp, damages);
385 ASSERT_EQ(ret, OHOS::GSERROR_OK);
386
387 uint32_t sequence;
388 for (auto it = cache.begin(); it != cache.end(); it++) {
389 if (it->second.GetRefPtr() == buffer.GetRefPtr()) {
390 sequence = it->first;
391 }
392 }
393 ASSERT_GE(sequence, 0);
394
395 ret = bq->FlushBuffer(sequence, bedata, acquireFence, flushConfig);
396 ASSERT_NE(ret, OHOS::GSERROR_OK);
397
398 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
399 ret = bq->ReleaseBuffer(buffer, releaseFence);
400 ASSERT_EQ(ret, OHOS::GSERROR_OK);
401 }
402
403 /*
404 * Function: RequestBuffer and CancelBuffer
405 * Type: Function
406 * Rank: Important(2)
407 * EnvConditions: N/A
408 * CaseDescription: 1. call RequestBuffer
409 * 2. call CancelBuffer
410 * 3. check retval and ret
411 */
412 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel009, Function | MediumTest | Level2)
413 {
414 IBufferProducer::RequestBufferReturnValue retval;
415 BufferRequestConfig deleteconfig = requestConfig;
416 deleteconfig.width = 1921;
417
418 GSError ret = bq->RequestBuffer(deleteconfig, bedata, retval);
419 ASSERT_EQ(ret, OHOS::GSERROR_OK);
420 ASSERT_EQ(retval.deletingBuffers.size(), 1u);
421 ASSERT_GE(retval.sequence, 0);
422 ASSERT_NE(retval.buffer, nullptr);
423
424 ret = bq->CancelBuffer(retval.sequence, bedata);
425 ASSERT_EQ(ret, OHOS::GSERROR_OK);
426 }
427
428 /*
429 * Function: RequestBuffer
430 * Type: Function
431 * Rank: Important(2)
432 * EnvConditions: N/A
433 * CaseDescription: 1. set BufferRequestConfig with abnormal value
434 * 2. call RequestBuffer
435 * 3. check ret
436 */
437 HWTEST_F(BufferQueueTest, RequestBuffer001, Function | MediumTest | Level2)
438 {
439 IBufferProducer::RequestBufferReturnValue retval;
440 BufferRequestConfig config = requestConfig;
441 config.width = -1;
442
443 GSError ret = bq->RequestBuffer(config, bedata, retval);
444 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
445 }
446
447 /*
448 * Function: RequestBuffer
449 * Type: Function
450 * Rank: Important(2)
451 * EnvConditions: N/A
452 * CaseDescription: 1. set BufferRequestConfig with abnormal value
453 * 2. call RequestBuffer
454 * 3. check ret
455 */
456 HWTEST_F(BufferQueueTest, RequestBuffer002, Function | MediumTest | Level2)
457 {
458 IBufferProducer::RequestBufferReturnValue retval;
459 BufferRequestConfig config = requestConfig;
460 config.height = -1;
461
462 GSError ret = bq->RequestBuffer(config, bedata, retval);
463 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
464 }
465
466
467 /*
468 * Function: RequestBuffer
469 * Type: Function
470 * Rank: Important(2)
471 * EnvConditions: N/A
472 * CaseDescription: 1. set BufferRequestConfig with abnormal value
473 * 2. call RequestBuffer
474 * 3. check ret
475 */
476 HWTEST_F(BufferQueueTest, RequestBuffer003, Function | MediumTest | Level2)
477 {
478 IBufferProducer::RequestBufferReturnValue retval;
479 BufferRequestConfig config = requestConfig;
480 config.strideAlignment = SURFACE_MIN_STRIDE_ALIGNMENT - 1;
481
482 GSError ret = bq->RequestBuffer(config, bedata, retval);
483 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
484 }
485
486 /*
487 * Function: RequestBuffer
488 * Type: Function
489 * Rank: Important(2)
490 * EnvConditions: N/A
491 * CaseDescription: 1. set BufferRequestConfig with abnormal value
492 * 2. call RequestBuffer
493 * 3. check ret
494 */
495 HWTEST_F(BufferQueueTest, RequestBuffer004, Function | MediumTest | Level2)
496 {
497 IBufferProducer::RequestBufferReturnValue retval;
498 BufferRequestConfig config = requestConfig;
499 config.strideAlignment = SURFACE_MAX_STRIDE_ALIGNMENT + 1;
500
501 GSError ret = bq->RequestBuffer(config, bedata, retval);
502 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
503 }
504
505 /*
506 * Function: RequestBuffer
507 * Type: Function
508 * Rank: Important(2)
509 * EnvConditions: N/A
510 * CaseDescription: 1. set BufferRequestConfig with abnormal value
511 * 2. call RequestBuffer
512 * 3. check ret
513 */
514 HWTEST_F(BufferQueueTest, RequestBuffer005, Function | MediumTest | Level2)
515 {
516 IBufferProducer::RequestBufferReturnValue retval;
517 BufferRequestConfig config = requestConfig;
518 config.strideAlignment = 3;
519
520 GSError ret = bq->RequestBuffer(config, bedata, retval);
521 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
522 }
523
524 /*
525 * Function: RequestBuffer
526 * Type: Function
527 * Rank: Important(2)
528 * EnvConditions: N/A
529 * CaseDescription: 1. set BufferRequestConfig with abnormal value
530 * 2. call RequestBuffer
531 * 3. check ret
532 */
533 HWTEST_F(BufferQueueTest, RequestBuffer006, Function | MediumTest | Level2)
534 {
535 IBufferProducer::RequestBufferReturnValue retval;
536 BufferRequestConfig config = requestConfig;
537 config.format = -1;
538
539 GSError ret = bq->RequestBuffer(config, bedata, retval);
540 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
541 }
542
543 /*
544 * Function: QueryIfBufferAvailable
545 * Type: Function
546 * Rank: Important(2)
547 * EnvConditions: N/A
548 * CaseDescription: 1. call QueryIfBufferAvailable and check ret
549 */
550 HWTEST_F(BufferQueueTest, QueryIfBufferAvailable001, Function | MediumTest | Level2)
551 {
552 bq->CleanCache();
553 bool ret = bq->QueryIfBufferAvailable();
554 ASSERT_EQ(ret, true);
555
556 GSError reqRet = OHOS::GSERROR_OK;
557 IBufferProducer::RequestBufferReturnValue retval;
558 BufferRequestConfig config = requestConfig;
559 while (reqRet != OHOS::GSERROR_NO_BUFFER) {
560 reqRet = bq->RequestBuffer(config, bedata, retval);
561 }
562
563 ret = bq->QueryIfBufferAvailable();
564 ASSERT_EQ(ret, false);
565 }
566
567 /*
568 * Function: GetName
569 * Type: Function
570 * Rank: Important(2)
571 * EnvConditions: N/A
572 * CaseDescription: 1. call GetName and check ret
573 */
574 HWTEST_F(BufferQueueTest, GetName001, Function | MediumTest | Level2)
575 {
576 std::string name("na");
577 GSError ret = bq->GetName(name);
578 ASSERT_EQ(ret, GSERROR_OK);
579 ASSERT_NE(name, "na");
580 }
581
582 /*
583 * Function: RegisterConsumerListener
584 * Type: Function
585 * Rank: Important(2)
586 * EnvConditions: N/A
587 * CaseDescription: 1. call RegisterConsumerListener and check ret
588 */
589 HWTEST_F(BufferQueueTest, RegisterConsumerListener001, Function | MediumTest | Level2)
590 {
591 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
592 GSError ret = bq->RegisterConsumerListener(listener);
593 ASSERT_EQ(ret, GSERROR_OK);
594 }
595
596 /*
597 * Function: SetDefaultWidthAndHeight
598 * Type: Function
599 * Rank: Important(2)
600 * EnvConditions: N/A
601 * CaseDescription: 1. call SetDefaultWidthAndHeight and check ret
602 */
603 HWTEST_F(BufferQueueTest, SetDefaultWidthAndHeight001, Function | MediumTest | Level2)
604 {
605 int width = 0;
606 int height = 0;
607 GSError ret = bq->SetDefaultWidthAndHeight(width, height);
608 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
609
610 width = 1;
611 ret = bq->SetDefaultWidthAndHeight(width, height);
612 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
613
614 width = 80;
615 height = 80;
616 ret = bq->SetDefaultWidthAndHeight(width, height);
617 ASSERT_EQ(ret, GSERROR_OK);
618 }
619
620 /*
621 * Function: GetDefaultWidth and GetDefaultHeight
622 * Type: Function
623 * Rank: Important(2)
624 * EnvConditions: N/A
625 * CaseDescription: 1. call GetDefaultWidth and check ret
626 */
627 HWTEST_F(BufferQueueTest, GetDefaultWidth001, Function | MediumTest | Level2)
628 {
629 int32_t width = 80;
630 int32_t height = 80;
631 GSError ret = bq->SetDefaultWidthAndHeight(width, height);
632 ASSERT_EQ(ret, GSERROR_OK);
633
634 ASSERT_EQ(width, bq->GetDefaultWidth());
635 ASSERT_EQ(height, bq->GetDefaultHeight());
636 }
637
638 /*
639 * Function: SetDefaultUsage and GetDefaultUsage
640 * Type: Function
641 * Rank: Important(2)
642 * EnvConditions: N/A
643 * CaseDescription: 1. call SetDefaultUsage and check ret
644 */
645 HWTEST_F(BufferQueueTest, SetDefaultUsage001, Function | MediumTest | Level2)
646 {
647 uint32_t usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA;
648 GSError ret = bq->SetDefaultUsage(usage);
649 ASSERT_EQ(ret, GSERROR_OK);
650 ASSERT_EQ(usage, bq->GetDefaultUsage());
651 }
652
653 /*
654 * Function: CleanCache
655 * Type: Function
656 * Rank: Important(2)
657 * EnvConditions: N/A
658 * CaseDescription: 1. call CleanCache and check ret
659 */
660 HWTEST_F(BufferQueueTest, CleanCache001, Function | MediumTest | Level2)
661 {
662 GSError ret = bq->CleanCache();
663 ASSERT_EQ(ret, GSERROR_OK);
664 }
665 /*
666 * Function: AttachBufferUpdateStatus
667 * Type: Function
668 * Rank: Important(2)
669 * EnvConditions: N/A
670 * CaseDescription: 1. call AttachBufferUpdateStatus and check ret
671 */
672 HWTEST_F(BufferQueueTest, AttachBufferUpdateStatus, Function | MediumTest | Level2)
673 {
674 uint32_t sequence = 2;
675 int32_t timeOut = 6;
676 std::mutex mutex_;
677 std::unique_lock<std::mutex> lock(mutex_);
678 GSError ret = bq->AttachBufferUpdateStatus(lock, sequence, timeOut);
679 ASSERT_EQ(ret, GSERROR_OK);
680 }
681
682 /*
683 * Function: AttachBuffer
684 * Type: Function
685 * Rank: Important(2)
686 * EnvConditions: N/A
687 * CaseDescription: 1. call AttachBuffer, DetachBuffer and check ret
688 */
689 HWTEST_F(BufferQueueTest, AttachBufferAndDetachBuffer001, Function | MediumTest | Level2)
690 {
691 bq->CleanCache();
692 int32_t timeOut = 6;
693 IBufferProducer::RequestBufferReturnValue retval;
694 GSError ret = bq->AttachBuffer(retval.buffer, timeOut);
695 ASSERT_EQ(ret, GSERROR_INVALID_OPERATING);
696 EXPECT_EQ(bq->DetachBuffer(retval.buffer), GSERROR_INVALID_ARGUMENTS);
697 sptr<SurfaceBuffer> buffer = nullptr;
698 EXPECT_EQ(bq->DetachBuffer(buffer), GSERROR_INVALID_ARGUMENTS);
699 BufferQueue *bqTmp = new BufferQueue("testTmp", true);
700 EXPECT_EQ(bqTmp->DetachBuffer(buffer), GSERROR_INVALID_OPERATING);
701 bqTmp = nullptr;
702 }
703
704 /*
705 * Function: AttachBuffer
706 * Type: Function
707 * Rank: Important(2)
708 * EnvConditions: N/A
709 * CaseDescription: 1. call AttachBuffer, DetachBuffer and check ret
710 */
711 HWTEST_F(BufferQueueTest, AttachBufferAndDetachBuffer002, Function | MediumTest | Level2)
712 {
713 bq->CleanCache();
714 int32_t timeOut = 6;
715 EXPECT_EQ(bq->SetQueueSize(SURFACE_MAX_QUEUE_SIZE), GSERROR_OK);
716 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
717 ASSERT_NE(buffer, nullptr);
718 GSError ret = bq->AttachBuffer(buffer, timeOut);
719 sptr<SurfaceBuffer> buffer1 = SurfaceBuffer::Create();
720 EXPECT_EQ(bq->GetUsedSize(), 1);
721 ASSERT_EQ(ret, GSERROR_OK);
722 EXPECT_EQ(bq->AttachBuffer(buffer1, timeOut), GSERROR_OK);
723 ret= bq->DetachBuffer(buffer);
724 EXPECT_EQ(ret, GSERROR_NO_ENTRY);
725 EXPECT_EQ(bq->DetachBuffer(buffer1), GSERROR_NO_ENTRY);
726 EXPECT_EQ(bq->AllocBuffer(buffer1, requestConfig), GSERROR_OK);
727 EXPECT_EQ(bq->DetachBuffer(buffer1), GSERROR_OK);
728 }
729
730 /*
731 * Function: RegisterSurfaceDelegator
732 * Type: Function
733 * Rank: Important(2)
734 * EnvConditions: N/A
735 * CaseDescription: 1. call RegisterSurfaceDelegator and check ret
736 */
737 HWTEST_F(BufferQueueTest, RegisterSurfaceDelegator001, Function | MediumTest | Level2)
738 {
739 surfaceDelegator = ProducerSurfaceDelegator::Create();
740 GSError ret = bq->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), csurface1);
741 ASSERT_EQ(ret, GSERROR_OK);
742 }
743
744 /*
745 * Function: RegisterDeleteBufferListener
746 * Type: Function
747 * Rank: Important(2)
748 * EnvConditions: N/A
749 * CaseDescription: 1. call RegisterDeleteBufferListener and check ret
750 */
751 HWTEST_F(BufferQueueTest, RegisterDeleteBufferListener001, Function | MediumTest | Level2)
752 {
753 surfaceDelegator = ProducerSurfaceDelegator::Create();
754 GSError ret = bq->RegisterDeleteBufferListener(nullptr, true);
755 ASSERT_EQ(ret, GSERROR_OK);
756 }
757
758 /*
759 * Function: DumpToFile
760 * Type: Function
761 * Rank: Important(2)
762 * EnvConditions: N/A
763 * CaseDescription: 1. call DumpToFile and check ret
764 */
765 HWTEST_F(BufferQueueTest, DumpToFile001, Function | MediumTest | Level2)
766 {
767 bq->CleanCache();
768 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
769 ASSERT_NE(buffer, nullptr);
770 GSError ret = bq->AttachBuffer(buffer, 6);
771 sptr<SurfaceBuffer> buffer1 = SurfaceBuffer::Create();
772 ASSERT_EQ(ret, GSERROR_OK);
773 bq->DumpToFile(0);
774 bq->DumpToFile(1);
775 }
776 }
777