1 /*
2 * Copyright (c) 2021-2025 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 <fcntl.h>
16 #include <map>
17 #include <sys/mman.h>
18 #include <vector>
19 #include <gtest/gtest.h>
20 #include <surface.h>
21 #include <buffer_extra_data_impl.h>
22 #include <buffer_queue.h>
23 #include <buffer_producer_listener.h>
24 #include "buffer_consumer_listener.h"
25 #include "sync_fence.h"
26 #include "consumer_surface.h"
27 #include "producer_surface_delegator.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS::Rosen {
33 class BufferQueueTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37
38 static inline BufferRequestConfig requestConfig = {
39 .width = 0x100,
40 .height = 0x100,
41 .strideAlignment = 0x8,
42 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
43 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
44 .timeout = 0,
45 };
46 static inline BufferFlushConfigWithDamages flushConfig = {
47 .damages = {
48 {
49 .w = 0x100,
50 .h = 0x100,
51 }
52 },
53 };
54 static inline int64_t timestamp = 0;
55 static inline std::vector<Rect> damages = {};
56 static inline sptr<BufferQueue> bq = nullptr;
57 static inline std::map<int32_t, sptr<SurfaceBuffer>> cache;
58 static inline sptr<BufferExtraData> bedata = nullptr;
59 static inline sptr<ProducerSurfaceDelegator> surfaceDelegator = nullptr;
60 static inline sptr<IConsumerSurface> csurface1 = nullptr;
61 };
62
SetUpTestCase()63 void BufferQueueTest::SetUpTestCase()
64 {
65 bq = new BufferQueue("test");
66 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
67 bq->RegisterConsumerListener(listener);
68 bedata = new OHOS::BufferExtraDataImpl;
69 csurface1 = IConsumerSurface::Create();
70 }
71
TearDownTestCase()72 void BufferQueueTest::TearDownTestCase()
73 {
74 csurface1 = nullptr;
75 bedata = nullptr;
76 bq = nullptr;
77 surfaceDelegator = nullptr;
78 for (auto it : cache) {
79 it.second = nullptr;
80 }
81 cache.clear();
82 sleep(2); // 2 : sleep time
83 }
84
85 /*
86 * Function: GetUsedSize
87 * Type: Function
88 * Rank: Important(2)
89 * EnvConditions: N/A
90 * CaseDescription: 1. call GetUsedSize and check ret
91 */
92 HWTEST_F(BufferQueueTest, GetUsedSize001, TestSize.Level0)
93 {
94 uint32_t usedSize = bq->GetUsedSize();
95 ASSERT_NE(usedSize, -1);
96 }
97
98 /*
99 * Function: SetQueueSize and GetQueueSize
100 * Type: Function
101 * Rank: Important(2)
102 * EnvConditions: N/A
103 * CaseDescription: 1. call GetQueueSize for default
104 * 2. call SetQueueSize
105 * 3. call SetQueueSize again with abnormal input
106 * 4. check ret and call GetQueueSize
107 */
108 HWTEST_F(BufferQueueTest, QueueSize001, TestSize.Level0)
109 {
110 ASSERT_EQ(bq->GetQueueSize(), (uint32_t)SURFACE_DEFAULT_QUEUE_SIZE);
111
112 GSError ret = bq->SetQueueSize(2);
113 ASSERT_EQ(ret, OHOS::GSERROR_OK);
114
115 ret = bq->SetQueueSize(SURFACE_MAX_QUEUE_SIZE + 1);
116 ASSERT_NE(ret, OHOS::GSERROR_OK);
117
118 ASSERT_EQ(bq->GetQueueSize(), 2u);
119 BufferQueue *bqTmp = new BufferQueue("testTmp");
120 EXPECT_EQ(bqTmp->SetQueueSize(1), GSERROR_OK);
121 bqTmp = nullptr;
122 }
123
124 /*
125 * Function: SetQueueSize and GetQueueSize
126 * Type: Function
127 * Rank: Important(2)
128 * EnvConditions: N/A
129 * CaseDescription: 1. call SetQueueSize 2 times both with abnormal input
130 * 2. call GetQueueSize
131 * 3. check ret
132 */
133 HWTEST_F(BufferQueueTest, QueueSize002, TestSize.Level0)
134 {
135 GSError ret = bq->SetQueueSize(-1);
136 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
137 ASSERT_EQ(bq->GetQueueSize(), 2u);
138
139 ret = bq->SetQueueSize(0);
140 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
141 ASSERT_EQ(bq->GetQueueSize(), 2u);
142 }
143
144 /*
145 * Function: RequestBuffer, FlushBuffer, AcquireBuffer and ReleaseBuffer
146 * Type: Function
147 * Rank: Important(2)
148 * EnvConditions: N/A
149 * CaseDescription: 1. call RequestBuffer and FlushBuffer
150 * 2. call AcquireBuffer and ReleaseBuffer
151 * 3. check ret
152 */
153 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel001, TestSize.Level0)
154 {
155 IBufferProducer::RequestBufferReturnValue retval;
156
157 // first request
158 ASSERT_EQ(bq->freeList_.size(), 0);
159 ASSERT_EQ(bq->dirtyList_.size(), 0);
160 ASSERT_EQ(bq->GetUsedSize(), 0);
161 ASSERT_EQ(bq->bufferQueueSize_, 2);
162 ASSERT_EQ(bq->detachReserveSlotNum_, 0);
163
164 auto start = std::chrono::high_resolution_clock::now();
165 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
166 auto end = std::chrono::high_resolution_clock::now();
167 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
168 std::cout << "RequestBuffer costs: " << duration.count() << "ms" << std::endl;
169
170 ASSERT_EQ(ret, OHOS::GSERROR_OK);
171 ASSERT_NE(retval.buffer, nullptr);
172 ASSERT_GE(retval.sequence, 0);
173
174 // add cache
175 cache[retval.sequence] = retval.buffer;
176
177 // buffer queue will map
178 uint8_t *addr1 = reinterpret_cast<uint8_t*>(retval.buffer->GetVirAddr());
179 ASSERT_NE(addr1, nullptr);
180 addr1[0] = 5;
181
182 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
183 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
184 ASSERT_EQ(ret, OHOS::GSERROR_OK);
185
186 ret = bq->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
187 ASSERT_EQ(ret, OHOS::GSERROR_OK);
188 ASSERT_NE(retval.buffer, nullptr);
189
190 uint8_t *addr2 = reinterpret_cast<uint8_t*>(retval.buffer->GetVirAddr());
191 ASSERT_NE(addr2, nullptr);
192 if (addr2 != nullptr) {
193 ASSERT_EQ(addr2[0], 5u);
194 }
195
196 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
197 ret = bq->ReleaseBuffer(retval.buffer, releaseFence);
198 ASSERT_EQ(ret, OHOS::GSERROR_OK);
199 }
200
201 /*
202 * Function: RequestBuffer and CancelBuffer
203 * Type: Function
204 * Rank: Important(2)
205 * EnvConditions: N/A
206 * CaseDescription: 1. call RequestBuffer
207 * 2. call CancelBuffer
208 * 3. check ret
209 */
210 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel002, TestSize.Level0)
211 {
212 IBufferProducer::RequestBufferReturnValue retval;
213
214 // not first request
215 ASSERT_EQ(bq->freeList_.size(), 1);
216 ASSERT_EQ(bq->dirtyList_.size(), 0);
217 ASSERT_EQ(bq->GetUsedSize(), 1);
218 ASSERT_EQ(bq->bufferQueueSize_, 2);
219 ASSERT_EQ(bq->detachReserveSlotNum_, 0);
220 auto start = std::chrono::high_resolution_clock::now();
221 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
222 auto end = std::chrono::high_resolution_clock::now();
223 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
224 std::cout << "RequestBuffer costs: " << duration.count() << "ms" << std::endl;
225
226 ASSERT_EQ(ret, OHOS::GSERROR_OK);
227 ASSERT_GE(retval.sequence, 0);
228 ASSERT_EQ(retval.buffer, nullptr);
229
230 ret = bq->CancelBuffer(retval.sequence, bedata);
231 ASSERT_EQ(ret, OHOS::GSERROR_OK);
232 }
233
234 /*
235 * Function: RequestBuffer and CancelBuffer
236 * Type: Function
237 * Rank: Important(2)
238 * EnvConditions: N/A
239 * CaseDescription: 1. call RequestBuffer
240 * 2. call CancelBuffer 2 times
241 * 3. check ret
242 */
243 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel003, TestSize.Level0)
244 {
245 IBufferProducer::RequestBufferReturnValue retval;
246
247 // not first request
248 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
249 ASSERT_EQ(ret, OHOS::GSERROR_OK);
250 ASSERT_GE(retval.sequence, 0);
251 ASSERT_EQ(retval.buffer, nullptr);
252
253 ret = bq->CancelBuffer(retval.sequence, bedata);
254 ASSERT_EQ(ret, OHOS::GSERROR_OK);
255
256 ret = bq->CancelBuffer(retval.sequence, bedata);
257 ASSERT_NE(ret, OHOS::GSERROR_OK);
258 }
259
260 /*
261 * Function: RequestBuffer and FlushBuffer
262 * Type: Function
263 * Rank: Important(2)
264 * EnvConditions: N/A
265 * CaseDescription: 1. call RequestBuffer
266 * 2. call FlushBuffer 2 times
267 * 3. check ret
268 */
269 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel004, TestSize.Level0)
270 {
271 IBufferProducer::RequestBufferReturnValue retval;
272
273 // not first request
274 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
275 ASSERT_EQ(ret, OHOS::GSERROR_OK);
276 ASSERT_GE(retval.sequence, 0);
277 ASSERT_EQ(retval.buffer, nullptr);
278
279 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
280 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
281 ASSERT_EQ(ret, OHOS::GSERROR_OK);
282
283 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
284 ASSERT_NE(ret, OHOS::GSERROR_OK);
285 }
286
287 /*
288 * Function: AcquireBuffer and ReleaseBuffer
289 * Type: Function
290 * Rank: Important(2)
291 * EnvConditions: N/A
292 * CaseDescription: 1. call AcquireBuffer
293 * 2. call ReleaseBuffer 2 times
294 * 3. check ret
295 */
296 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel005, TestSize.Level0)
297 {
298 sptr<SurfaceBuffer> buffer;
299
300 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
301 GSError ret = bq->AcquireBuffer(buffer, acquireFence, timestamp, damages);
302 ASSERT_EQ(ret, OHOS::GSERROR_OK);
303
304 ASSERT_EQ(buffer->GetSyncFence(), nullptr);
305 buffer->SetAndMergeSyncFence(SyncFence::INVALID_FENCE);
306 ASSERT_NE(buffer->GetSyncFence(), nullptr);
307 ASSERT_FALSE(buffer->GetSyncFence()->IsValid());
308 sptr<SyncFence> ReleaseFence = SyncFence::INVALID_FENCE;
309 ret = bq->ReleaseBuffer(buffer, ReleaseFence);
310 ASSERT_EQ(ret, OHOS::GSERROR_OK);
311
312 ret = bq->ReleaseBuffer(buffer, ReleaseFence);
313 ASSERT_NE(ret, OHOS::GSERROR_OK);
314 }
315
316 /*
317 * Function: RequestBuffer, and CancelBuffer
318 * Type: Function
319 * Rank: Important(2)
320 * EnvConditions: N/A
321 * CaseDescription: 1. call RequestBuffer and CancelBuffer by different retval
322 * 2. check ret
323 */
324 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel006, TestSize.Level0)
325 {
326 IBufferProducer::RequestBufferReturnValue retval1;
327 IBufferProducer::RequestBufferReturnValue retval2;
328 IBufferProducer::RequestBufferReturnValue retval3;
329 GSError ret;
330
331 // not alloc
332 ret = bq->RequestBuffer(requestConfig, bedata, retval1);
333 ASSERT_EQ(ret, OHOS::GSERROR_OK);
334 ASSERT_GE(retval1.sequence, 0);
335 ASSERT_EQ(retval1.buffer, nullptr);
336
337 // alloc
338 ret = bq->RequestBuffer(requestConfig, bedata, retval2);
339 ASSERT_EQ(ret, OHOS::GSERROR_OK);
340 ASSERT_GE(retval2.sequence, 0);
341 ASSERT_NE(retval2.buffer, nullptr);
342
343 cache[retval2.sequence] = retval2.buffer;
344
345 // no buffer
346 ASSERT_EQ(bq->freeList_.size(), 0);
347 ASSERT_EQ(bq->dirtyList_.size(), 0);
348 ASSERT_EQ(bq->GetUsedSize(), 2u);
349 ASSERT_EQ(bq->bufferQueueSize_, 2);
350 ASSERT_EQ(bq->detachReserveSlotNum_, 0);
351 auto start = std::chrono::high_resolution_clock::now();
352 ret = bq->RequestBuffer(requestConfig, bedata, retval3);
353 auto end = std::chrono::high_resolution_clock::now();
354 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
355 std::cout << "RequestBuffer costs: " << duration.count() << "ms" << std::endl;
356
357 ASSERT_NE(ret, OHOS::GSERROR_OK);
358 ASSERT_EQ(retval3.buffer, nullptr);
359
360 ret = bq->CancelBuffer(retval1.sequence, bedata);
361 ASSERT_EQ(ret, OHOS::GSERROR_OK);
362
363 ret = bq->CancelBuffer(retval2.sequence, bedata);
364 ASSERT_EQ(ret, OHOS::GSERROR_OK);
365
366 ret = bq->CancelBuffer(retval3.sequence, bedata);
367 ASSERT_NE(ret, OHOS::GSERROR_OK);
368 }
369
370 /*
371 * Function: RequestBuffer, ReleaseBuffer and FlushBuffer
372 * Type: Function
373 * Rank: Important(2)
374 * EnvConditions: N/A
375 * CaseDescription: 1. call RequestBuffer
376 * 2. call ReleaseBuffer
377 * 3. call FlushBuffer
378 * 4. check ret
379 */
380 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel007, TestSize.Level0)
381 {
382 IBufferProducer::RequestBufferReturnValue retval;
383
384 // not alloc
385 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
386 ASSERT_EQ(ret, OHOS::GSERROR_OK);
387 ASSERT_GE(retval.sequence, 0);
388 ASSERT_EQ(retval.buffer, nullptr);
389
390 retval.buffer = cache[retval.sequence];
391 retval.buffer->SetAndMergeSyncFence(new SyncFence(0));
392 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
393 ret = bq->ReleaseBuffer(retval.buffer, releaseFence);
394 ASSERT_NE(ret, OHOS::GSERROR_OK);
395
396 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
397 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
398 ASSERT_EQ(ret, OHOS::GSERROR_OK);
399 }
400
401 /*
402 * Function: AcquireBuffer, FlushBuffer and ReleaseBuffer
403 * Type: Function
404 * Rank: Important(2)
405 * EnvConditions: N/A
406 * CaseDescription: 1. call AcquireBuffer
407 * 2. call FlushBuffer
408 * 3. call ReleaseBuffer
409 * 4. check ret
410 */
411 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel008, TestSize.Level0)
412 {
413 sptr<SurfaceBuffer> buffer;
414 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
415
416 // acq from last test
417 GSError ret = bq->AcquireBuffer(buffer, acquireFence, timestamp, damages);
418 ASSERT_EQ(ret, OHOS::GSERROR_OK);
419
420 uint32_t sequence;
421 for (auto it = cache.begin(); it != cache.end(); it++) {
422 if (it->second.GetRefPtr() == buffer.GetRefPtr()) {
423 sequence = it->first;
424 }
425 }
426 ASSERT_GE(sequence, 0);
427
428 ret = bq->FlushBuffer(sequence, bedata, acquireFence, flushConfig);
429 ASSERT_NE(ret, OHOS::GSERROR_OK);
430
431 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
432 ret = bq->ReleaseBuffer(buffer, releaseFence);
433 ASSERT_EQ(ret, OHOS::GSERROR_OK);
434 }
435
436 /*
437 * Function: RequestBuffer and CancelBuffer
438 * Type: Function
439 * Rank: Important(2)
440 * EnvConditions: N/A
441 * CaseDescription: 1. call RequestBuffer
442 * 2. call CancelBuffer
443 * 3. check retval and ret
444 */
445 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel009, TestSize.Level0)
446 {
447 IBufferProducer::RequestBufferReturnValue retval;
448 BufferRequestConfig deleteconfig = requestConfig;
449 deleteconfig.width = 1921;
450
451 GSError ret = bq->RequestBuffer(deleteconfig, bedata, retval);
452 ASSERT_EQ(ret, OHOS::GSERROR_OK);
453 ASSERT_EQ(retval.deletingBuffers.size(), 1u);
454 ASSERT_GE(retval.sequence, 0);
455 ASSERT_NE(retval.buffer, nullptr);
456
457 ret = bq->CancelBuffer(retval.sequence, bedata);
458 ASSERT_EQ(ret, OHOS::GSERROR_OK);
459 }
460
461 /*
462 * Function: RequestBuffer, FlushBuffer, AcquireBuffer and ReleaseBuffer
463 * Type: Function
464 * Rank: Important(2)
465 * EnvConditions: N/A
466 * CaseDescription: 1. call RequestBuffer and FlushBuffer
467 * 2. call AcquireBuffer and ReleaseBuffer
468 * 3. check ret
469 */
470 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel0010, Function | MediumTest | Level2)
471 {
472 IBufferProducer::RequestBufferReturnValue retval;
473 IBufferProducer::RequestBufferReturnValue retval1;
474 IBufferProducer::RequestBufferReturnValue retval2;
475
476 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
477 ASSERT_EQ(ret, OHOS::GSERROR_OK);
478 ASSERT_GE(retval.sequence, 0);
479 ASSERT_EQ(retval.buffer, nullptr);
480
481 ret = bq->RequestBuffer(requestConfig, bedata, retval1);
482 ASSERT_EQ(ret, OHOS::GSERROR_OK);
483 ASSERT_GE(retval1.sequence, 0);
484 ASSERT_NE(retval1.buffer, nullptr);
485
486 ASSERT_EQ(bq->freeList_.size(), 0);
487 ASSERT_EQ(bq->GetUsedSize(), 2u);
488 ASSERT_EQ(bq->bufferQueueSize_, 2);
489 ASSERT_EQ(bq->detachReserveSlotNum_, 0);
490 ASSERT_EQ(bq->dirtyList_.size(), 0);
491
492 bq->SetRequestBufferNoblockMode(true);
493 bool noblock = false;
494 bq->GetRequestBufferNoblockMode(noblock);
495 ASSERT_TRUE(noblock);
496 auto start = std::chrono::high_resolution_clock::now();
497 ret = bq->RequestBuffer(requestConfig, bedata, retval2);
498 auto end = std::chrono::high_resolution_clock::now();
499 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
500 std::cout << "RequestBuffer costs: " << duration.count() << "ms" << std::endl;
501
502 ASSERT_EQ(ret, OHOS::GSERROR_NO_BUFFER);
503
504 ret = bq->CancelBuffer(retval.sequence, bedata);
505 ASSERT_EQ(ret, OHOS::GSERROR_OK);
506
507 ret = bq->CancelBuffer(retval1.sequence, bedata);
508 ASSERT_EQ(ret, OHOS::GSERROR_OK);
509 }
510
511 /*
512 * Function: RequestBuffer and CancelBuffer
513 * Type: Function
514 * Rank: Important(2)
515 * EnvConditions: N/A
516 * CaseDescription: 1. call RequestBuffer
517 * 2. call CancelBuffer
518 * 3. check retval and ret
519 */
520 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel0011, Function | MediumTest | Level2)
521 {
522 IBufferProducer::RequestBufferReturnValue retval;
523 IBufferProducer::RequestBufferReturnValue retval1;
524 IBufferProducer::RequestBufferReturnValue retval2;
525
526 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
527 ASSERT_EQ(ret, OHOS::GSERROR_OK);
528 ASSERT_GE(retval.sequence, 0);
529 ASSERT_EQ(retval.buffer, nullptr);
530
531 ret = bq->RequestBuffer(requestConfig, bedata, retval1);
532 ASSERT_EQ(ret, OHOS::GSERROR_OK);
533 ASSERT_GE(retval1.sequence, 0);
534 ASSERT_EQ(retval1.buffer, nullptr);
535
536 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
537 ret = bq->FlushBuffer(retval1.sequence, bedata, acquireFence, flushConfig);
538 ASSERT_EQ(ret, OHOS::GSERROR_OK);
539
540 // no buffer
541 ASSERT_EQ(bq->freeList_.size(), 0);
542 ASSERT_EQ(bq->GetUsedSize(), 2u);
543 ASSERT_EQ(bq->bufferQueueSize_, 2);
544 ASSERT_EQ(bq->detachReserveSlotNum_, 0);
545 ASSERT_EQ(bq->dirtyList_.size(), 1);
546
547 auto start = std::chrono::high_resolution_clock::now();
548 ret = bq->RequestBuffer(requestConfig, bedata, retval2);
549 auto end = std::chrono::high_resolution_clock::now();
550 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
551 std::cout << "RequestBuffer costs: " << duration.count() << "ms" << std::endl;
552
553 ASSERT_EQ(ret, OHOS::GSERROR_OK);
554 ASSERT_EQ(retval2.buffer, nullptr);
555
556 ret = bq->CancelBuffer(retval.sequence, bedata);
557 ASSERT_EQ(ret, OHOS::GSERROR_OK);
558
559 acquireFence = SyncFence::INVALID_FENCE;
560 ret = bq->FlushBuffer(retval2.sequence, bedata, acquireFence, flushConfig);
561 ASSERT_EQ(ret, OHOS::GSERROR_OK);
562
563 ret = bq->AcquireBuffer(retval2.buffer, retval.fence, timestamp, damages);
564 ASSERT_EQ(ret, OHOS::GSERROR_OK);
565
566 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
567 ret = bq->ReleaseBuffer(retval2.buffer, releaseFence);
568 ASSERT_EQ(ret, OHOS::GSERROR_OK);
569 bq->SetRequestBufferNoblockMode(false);
570 bool noblock = true;
571 bq->GetRequestBufferNoblockMode(noblock);
572 ASSERT_FALSE(noblock);
573 }
574
575 /*
576 * Function: RequestBuffer and CancelBuffer
577 * Type: Function
578 * Rank: Important(2)
579 * EnvConditions: N/A
580 * CaseDescription: 1. call RequestBuffer
581 * 2. call CancelBuffer
582 * 3. check ret
583 */
584 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel0012, Function | MediumTest | Level2)
585 {
586 IBufferProducer::RequestBufferReturnValue retval;
587
588 for (auto i = 0; i != 1000; i++) {
589 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
590 ASSERT_EQ(ret, OHOS::GSERROR_OK);
591
592 ret = bq->CancelBuffer(retval.sequence, bedata);
593 ASSERT_EQ(ret, OHOS::GSERROR_OK);
594 }
595 }
596
597 /*
598 * Function: GetLastConsumeTime
599 * Type: Function
600 * Rank: Important(2)
601 * EnvConditions: N/A
602 * CaseDescription: 1. call GetLastConsumeTime
603 * 2. check lastConsumeTime
604 */
605 HWTEST_F(BufferQueueTest, GetLastConsumeTimeTest, TestSize.Level0)
606 {
607 int64_t lastConsumeTime = 0;
608 bq->GetLastConsumeTime(lastConsumeTime);
609 std::cout << "lastConsumeTime = " << lastConsumeTime << std::endl;
610 ASSERT_NE(lastConsumeTime, 0);
611 }
612
613 /*
614 * Function: SetDesiredPresentTimestampAndUiTimestamp
615 * Type: Function
616 * Rank: Important(2)
617 * EnvConditions: N/A
618 * CaseDescription: 1. call SetDesiredPresentTimestampAndUiTimestamp with different parameter and check ret
619 * 2. call SetDesiredPresentTimestampAndUiTimestamp with empty parameter and check ret
620 * 3. repeatly call SetDesiredPresentTimestampAndUiTimestamp with different parameter and check ret
621 */
622 HWTEST_F(BufferQueueTest, SetDesiredPresentTimestampAndUiTimestamp001, TestSize.Level0)
623 {
624 IBufferProducer::RequestBufferReturnValue retval;
625 BufferRequestConfig config = requestConfig;
626 config.width = 1921;
627 GSError ret = bq->RequestBuffer(config, bedata, retval);
628 ASSERT_EQ(ret, OHOS::GSERROR_OK);
629 ASSERT_GE(retval.sequence, 0);
630
631 // call SetDesiredPresentTimestampAndUiTimestamp with different uiTimestamp and desireTimestamp, check ret
632 int64_t desiredPresentTimestamp = 0;
633 uint64_t uiTimestamp = 2;
634 bq->SetDesiredPresentTimestampAndUiTimestamp(retval.sequence, desiredPresentTimestamp, uiTimestamp);
635 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, uiTimestamp);
636 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].timestamp, uiTimestamp);
637 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].isAutoTimestamp, false);
638
639 desiredPresentTimestamp = -1;
640 bq->SetDesiredPresentTimestampAndUiTimestamp(retval.sequence, desiredPresentTimestamp, uiTimestamp);
641 ASSERT_GT(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, 0);
642 ASSERT_NE(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, uiTimestamp);
643 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].timestamp, uiTimestamp);
644 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].isAutoTimestamp, true);
645
646 desiredPresentTimestamp = 1;
647 bq->SetDesiredPresentTimestampAndUiTimestamp(retval.sequence, desiredPresentTimestamp, uiTimestamp);
648 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, desiredPresentTimestamp);
649 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].timestamp, uiTimestamp);
650 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].isAutoTimestamp, false);
651
652 // call SetDesiredPresentTimestampAndUiTimestamp with empty uiTimestamp and desireTimestamp, check ret
653 desiredPresentTimestamp = 0;
654 uiTimestamp = 0;
655 bq->SetDesiredPresentTimestampAndUiTimestamp(retval.sequence, desiredPresentTimestamp, uiTimestamp);
656 ASSERT_NE(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, desiredPresentTimestamp);
657 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].timestamp, uiTimestamp);
658 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].isAutoTimestamp, true);
659
660 //repeatly call SetDesiredPresentTimestampAndUiTimestamp with different uiTimestamp and desireTimestamp, check ret
661 desiredPresentTimestamp = 0;
662 uiTimestamp = 2;
663 bq->SetDesiredPresentTimestampAndUiTimestamp(retval.sequence, desiredPresentTimestamp, uiTimestamp);
664 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, uiTimestamp);
665 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].timestamp, uiTimestamp);
666 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].isAutoTimestamp, false);
667
668 desiredPresentTimestamp = -1;
669 bq->SetDesiredPresentTimestampAndUiTimestamp(retval.sequence, desiredPresentTimestamp, uiTimestamp);
670 ASSERT_GT(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, 0);
671 ASSERT_NE(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, uiTimestamp);
672 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].timestamp, uiTimestamp);
673 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].isAutoTimestamp, true);
674
675 desiredPresentTimestamp = 1;
676 bq->SetDesiredPresentTimestampAndUiTimestamp(retval.sequence, desiredPresentTimestamp, uiTimestamp);
677 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].desiredPresentTimestamp, desiredPresentTimestamp);
678 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].timestamp, uiTimestamp);
679 ASSERT_EQ(bq->bufferQueueCache_[retval.sequence].isAutoTimestamp, false);
680
681 ret = bq->CancelBuffer(retval.sequence, bedata);
682 ASSERT_EQ(ret, OHOS::GSERROR_OK);
683 }
684
685 /*
686 * Function: RequestBuffer
687 * Type: Function
688 * Rank: Important(2)
689 * EnvConditions: N/A
690 * CaseDescription: 1. set BufferRequestConfig with abnormal value
691 * 2. call RequestBuffer
692 * 3. check ret
693 */
694 HWTEST_F(BufferQueueTest, RequestBuffer001, TestSize.Level0)
695 {
696 IBufferProducer::RequestBufferReturnValue retval;
697 BufferRequestConfig config = requestConfig;
698 config.width = -1;
699
700 GSError ret = bq->RequestBuffer(config, bedata, retval);
701 ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
702 }
703
704 /*
705 * Function: RequestBuffer
706 * Type: Function
707 * Rank: Important(2)
708 * EnvConditions: N/A
709 * CaseDescription: 1. set BufferRequestConfig with abnormal value
710 * 2. call RequestBuffer
711 * 3. check ret
712 */
713 HWTEST_F(BufferQueueTest, RequestBuffer002, TestSize.Level0)
714 {
715 IBufferProducer::RequestBufferReturnValue retval;
716 BufferRequestConfig config = requestConfig;
717 config.height = -1;
718
719 GSError ret = bq->RequestBuffer(config, bedata, retval);
720 ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
721 }
722
723 /*
724 * Function: RequestBuffer
725 * Type: Function
726 * Rank: Important(2)
727 * EnvConditions: N/A
728 * CaseDescription: 1. set BufferRequestConfig with abnormal value
729 * 2. call RequestBuffer
730 * 3. check ret
731 */
732 HWTEST_F(BufferQueueTest, RequestBuffer006, TestSize.Level0)
733 {
734 IBufferProducer::RequestBufferReturnValue retval;
735 BufferRequestConfig config = requestConfig;
736 config.format = -1;
737
738 GSError ret = bq->RequestBuffer(config, bedata, retval);
739 ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
740 }
741
742 /*
743 * Function: QueryIfBufferAvailable
744 * Type: Function
745 * Rank: Important(2)
746 * EnvConditions: N/A
747 * CaseDescription: 1. call QueryIfBufferAvailable and check ret
748 */
749 HWTEST_F(BufferQueueTest, QueryIfBufferAvailable001, TestSize.Level0)
750 {
751 bq->CleanCache(false, nullptr);
752 bool ret = bq->QueryIfBufferAvailable();
753 ASSERT_EQ(ret, true);
754
755 GSError reqRet = OHOS::GSERROR_OK;
756 IBufferProducer::RequestBufferReturnValue retval;
757 BufferRequestConfig config = requestConfig;
758 while (reqRet != OHOS::GSERROR_NO_BUFFER) {
759 reqRet = bq->RequestBuffer(config, bedata, retval);
760 }
761
762 ret = bq->QueryIfBufferAvailable();
763 ASSERT_EQ(ret, false);
764 }
765
766 /*
767 * Function: GetName
768 * Type: Function
769 * Rank: Important(2)
770 * EnvConditions: N/A
771 * CaseDescription: 1. call GetName and check ret
772 */
773 HWTEST_F(BufferQueueTest, GetName001, TestSize.Level0)
774 {
775 std::string name("na");
776 GSError ret = bq->GetName(name);
777 ASSERT_EQ(ret, GSERROR_OK);
778 ASSERT_NE(name, "na");
779 }
780
781 /*
782 * Function: RegisterConsumerListener
783 * Type: Function
784 * Rank: Important(2)
785 * EnvConditions: N/A
786 * CaseDescription: 1. call RegisterConsumerListener and check ret
787 */
788 HWTEST_F(BufferQueueTest, RegisterConsumerListener001, TestSize.Level0)
789 {
790 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
791 GSError ret = bq->RegisterConsumerListener(listener);
792 ASSERT_EQ(ret, GSERROR_OK);
793 }
794
795 /*
796 * Function: SetDefaultWidthAndHeight
797 * Type: Function
798 * Rank: Important(2)
799 * EnvConditions: N/A
800 * CaseDescription: 1. call SetDefaultWidthAndHeight and check ret
801 */
802 HWTEST_F(BufferQueueTest, SetDefaultWidthAndHeight001, TestSize.Level0)
803 {
804 int width = 0;
805 int height = 0;
806 GSError ret = bq->SetDefaultWidthAndHeight(width, height);
807 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
808
809 width = 1;
810 ret = bq->SetDefaultWidthAndHeight(width, height);
811 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
812
813 width = 80;
814 height = 80;
815 ret = bq->SetDefaultWidthAndHeight(width, height);
816 ASSERT_EQ(ret, GSERROR_OK);
817 }
818
819 /*
820 * Function: GetDefaultWidth and GetDefaultHeight
821 * Type: Function
822 * Rank: Important(2)
823 * EnvConditions: N/A
824 * CaseDescription: 1. call GetDefaultWidth and check ret
825 */
826 HWTEST_F(BufferQueueTest, GetDefaultWidth001, TestSize.Level0)
827 {
828 int32_t width = 80;
829 int32_t height = 80;
830 GSError ret = bq->SetDefaultWidthAndHeight(width, height);
831 ASSERT_EQ(ret, GSERROR_OK);
832
833 ASSERT_EQ(width, bq->GetDefaultWidth());
834 ASSERT_EQ(height, bq->GetDefaultHeight());
835 }
836
837 /*
838 * Function: SetDefaultUsage and GetDefaultUsage
839 * Type: Function
840 * Rank: Important(2)
841 * EnvConditions: N/A
842 * CaseDescription: 1. call SetDefaultUsage and check ret
843 */
844 HWTEST_F(BufferQueueTest, SetDefaultUsage001, TestSize.Level0)
845 {
846 uint64_t usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA;
847 GSError ret = bq->SetDefaultUsage(usage);
848 ASSERT_EQ(ret, GSERROR_OK);
849 ASSERT_EQ(usage, bq->GetDefaultUsage());
850 }
851
852 /*
853 * Function: CleanCache
854 * Type: Function
855 * Rank: Important(2)
856 * EnvConditions: N/A
857 * CaseDescription: 1. call CleanCache and check ret
858 */
859 HWTEST_F(BufferQueueTest, CleanCache001, TestSize.Level0)
860 {
861 GSError ret = bq->CleanCache(false, nullptr);
862 ASSERT_EQ(ret, GSERROR_OK);
863 }
864 /*
865 * Function: AttachBufferUpdateStatus
866 * Type: Function
867 * Rank: Important(2)
868 * EnvConditions: N/A
869 * CaseDescription: 1. call AttachBufferUpdateStatus and check ret
870 */
871 HWTEST_F(BufferQueueTest, AttachBufferUpdateStatus, TestSize.Level0)
872 {
873 uint32_t sequence = 2;
874 int32_t timeOut = 6;
875 std::mutex mutex_;
876 std::unique_lock<std::mutex> lock(mutex_);
877 auto mapIter = bq->bufferQueueCache_.find(sequence);
878 GSError ret = bq->AttachBufferUpdateStatus(lock, sequence, timeOut, mapIter);
879 ASSERT_EQ(ret, GSERROR_OK);
880 }
881
882 /*
883 * Function: AttachBuffer
884 * Type: Function
885 * Rank: Important(2)
886 * EnvConditions: N/A
887 * CaseDescription: 1. call AttachBuffer, DetachBuffer and check ret
888 */
889 HWTEST_F(BufferQueueTest, AttachBufferAndDetachBuffer001, TestSize.Level0)
890 {
891 bq->CleanCache(false, nullptr);
892 int32_t timeOut = 6;
893 IBufferProducer::RequestBufferReturnValue retval;
894 GSError ret = bq->AttachBuffer(retval.buffer, timeOut);
895 ASSERT_EQ(ret, GSERROR_INVALID_OPERATING);
896 EXPECT_EQ(bq->DetachBuffer(retval.buffer), GSERROR_INVALID_ARGUMENTS);
897 sptr<SurfaceBuffer> buffer = nullptr;
898 EXPECT_EQ(bq->DetachBuffer(buffer), GSERROR_INVALID_ARGUMENTS);
899 }
900
901 /*
902 * Function: AttachBuffer
903 * Type: Function
904 * Rank: Important(2)
905 * EnvConditions: N/A
906 * CaseDescription: 1. call AttachBuffer, DetachBuffer and check ret
907 */
908 HWTEST_F(BufferQueueTest, AttachBufferAndDetachBuffer002, TestSize.Level0)
909 {
910 bq->CleanCache(false, nullptr);
911 int32_t timeOut = 6;
912 EXPECT_EQ(bq->SetQueueSize(SURFACE_MAX_QUEUE_SIZE), GSERROR_OK);
913 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
914 ASSERT_NE(buffer, nullptr);
915 GSError ret = bq->AttachBuffer(buffer, timeOut);
916 sptr<SurfaceBuffer> buffer1 = SurfaceBuffer::Create();
917 EXPECT_EQ(bq->GetUsedSize(), 1);
918 ASSERT_EQ(ret, GSERROR_OK);
919 EXPECT_EQ(bq->AttachBuffer(buffer1, timeOut), GSERROR_OK);
920 bq->sourceType_ = OHSurfaceSource::OH_SURFACE_SOURCE_LOWPOWERVIDEO;
921 bq->AttachBuffer(buffer, timeOut);
922 ASSERT_EQ(ret, GSERROR_OK);
923 ret= bq->DetachBuffer(buffer);
924 EXPECT_EQ(ret, GSERROR_NO_ENTRY);
925 EXPECT_EQ(bq->DetachBuffer(buffer1), GSERROR_NO_ENTRY);
926 {
927 std::mutex mutex;
928 std::unique_lock<std::mutex> lock(mutex);
929 EXPECT_EQ(bq->AllocBuffer(buffer1, nullptr, requestConfig, lock), GSERROR_OK);
930 }
931 EXPECT_EQ(bq->DetachBuffer(buffer1), GSERROR_OK);
932 }
933
934 /*
935 * Function: RegisterSurfaceDelegator
936 * Type: Function
937 * Rank: Important(2)
938 * EnvConditions: N/A
939 * CaseDescription: 1. call RegisterSurfaceDelegator and check ret
940 */
941 HWTEST_F(BufferQueueTest, RegisterSurfaceDelegator001, TestSize.Level0)
942 {
943 surfaceDelegator = ProducerSurfaceDelegator::Create();
944 GSError ret = bq->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), csurface1);
945 ASSERT_EQ(ret, GSERROR_OK);
946 }
947
948 /*
949 * Function: RegisterDeleteBufferListener
950 * Type: Function
951 * Rank: Important(2)
952 * EnvConditions: N/A
953 * CaseDescription: 1. call RegisterDeleteBufferListener and check ret
954 */
955 HWTEST_F(BufferQueueTest, RegisterDeleteBufferListener001, TestSize.Level0)
956 {
957 surfaceDelegator = ProducerSurfaceDelegator::Create();
958 GSError ret = bq->RegisterDeleteBufferListener(nullptr, true);
959 ASSERT_EQ(ret, GSERROR_OK);
960 }
961
962 /*
963 * Function: QueueAndDequeueDelegator
964 * Type: Function
965 * Rank: Important(2)
966 * EnvConditions: N/A
967 * CaseDescription: 1. call RegisterSurfaceDelegator and check ret
968 * 2. call RequestBuffer and check ret (this will call DelegatorDequeueBuffer)
969 * 3. call FlushBuffer and check ret (this will call DelegatorQueueBuffer)
970 */
971 HWTEST_F(BufferQueueTest, QueueAndDequeueDelegator001, TestSize.Level0)
972 {
973 surfaceDelegator = ProducerSurfaceDelegator::Create();
974 GSError ret = bq->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), csurface1);
975 ASSERT_EQ(ret, GSERROR_OK);
976
977 IBufferProducer::RequestBufferReturnValue retval;
978 ret = bq->RequestBuffer(requestConfig, bedata, retval);
979 ASSERT_EQ(ret, GSERROR_OK);
980 ASSERT_NE(retval.buffer, nullptr);
981 ASSERT_GE(retval.sequence, 0);
982
983 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
984 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
985 ASSERT_EQ(ret, OHOS::GSERROR_OK);
986 }
987
988 /*
989 * Function: SetSurfaceSourceType and GetSurfaceSourceType
990 * Type: Function
991 * Rank: Important(2)
992 * EnvConditions: N/A
993 * CaseDescription: 1. call SetSurfaceSourceType and check ret
994 * 2. call GetSurfaceSourceType and check the value
995 */
996 HWTEST_F(BufferQueueTest, SurfaceSourceType001, TestSize.Level0)
997 {
998 OHSurfaceSource sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
999 GSError ret = bq->SetSurfaceSourceType(sourceType);
1000 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1001 ASSERT_EQ(sourceType, bq->GetSurfaceSourceType());
1002 }
1003
1004 /*
1005 * Function: SetSurfaceAppFrameworkType
1006 * Type: Function
1007 * Rank: Important(2)
1008 * EnvConditions: N/A
1009 * CaseDescription: 1. call SetSurfaceAppFrameworkType and check ret
1010 */
1011 HWTEST_F(BufferQueueTest, SetSurfaceAppFrameworkType001, TestSize.Level0)
1012 {
1013 std::string type = "";
1014 GSError ret = bq->SetSurfaceAppFrameworkType(type);
1015 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1016
1017 std::string type1 = "AAAAABBBBBCCCCCDDDDDEEEEEFFFFFGGGGGAAAAABBBBBCCCCCDDDDDEEEEEFFFFFGGGGG";
1018 ret = bq->SetSurfaceAppFrameworkType(type1);
1019 ASSERT_EQ(ret, OHOS::GSERROR_OUT_OF_RANGE);
1020
1021 std::string type2 = "test";
1022 ret = bq->SetSurfaceAppFrameworkType(type2);
1023 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1024 }
1025
1026 /*
1027 * Function: GetSurfaceAppFrameworkType
1028 * Type: Function
1029 * Rank: Important(2)
1030 * EnvConditions: N/A
1031 * CaseDescription: 1. call GetSurfaceAppFrameworkType and check value
1032 */
1033 HWTEST_F(BufferQueueTest, GetSurfaceAppFrameworkType001, TestSize.Level0)
1034 {
1035 std::string type = "test";
1036 GSError ret = bq->SetSurfaceAppFrameworkType(type);
1037 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1038 ASSERT_EQ(bq->GetSurfaceAppFrameworkType(), "test");
1039 }
1040
1041 /*
1042 * Function: SetGlobalAlpha and GetGlobalAlpha
1043 * Type: Function
1044 * Rank: Important(2)
1045 * EnvConditions: N/A
1046 * CaseDescription: 1. call SetGlobalAlpha and check value
1047 * 2. call GetGlobalAlpha and check value
1048 */
1049 HWTEST_F(BufferQueueTest, SetGlobalAlpha001, TestSize.Level0)
1050 {
1051 int32_t alpha = 255;
1052 GSError ret = bq->SetGlobalAlpha(alpha);
1053 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1054
1055 int32_t resultAlpha = -1;
1056 ret = bq->GetGlobalAlpha(resultAlpha);
1057 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1058 ASSERT_EQ(resultAlpha, alpha);
1059 }
1060
1061 /*
1062 * Function: SetFrameGravity and GetGlobalAlpha
1063 * Type: Function
1064 * Rank: Important(2)
1065 * EnvConditions: N/A
1066 * CaseDescription: 1. call SetFrameGravity and check value
1067 * 2. call GetGlobalAlpha and check value
1068 */
1069 HWTEST_F(BufferQueueTest, SetFrameGravity001, TestSize.Level0)
1070 {
1071 int32_t frameGravity = 15;
1072 GSError ret = bq->SetFrameGravity(frameGravity);
1073 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1074
1075 int32_t resultFrameGravity = -1;
1076 ret = bq->GetFrameGravity(resultFrameGravity);
1077 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1078 ASSERT_EQ(resultFrameGravity, frameGravity);
1079 }
1080
1081 /*
1082 * Function: SetFixedRotation and GetFixedRotation
1083 * Type: Function
1084 * Rank: Important(2)
1085 * EnvConditions: N/A
1086 * CaseDescription: 1. call SetFixedRotation and check value
1087 * 2. call GetFixedRotation and check value
1088 */
1089 HWTEST_F(BufferQueueTest, SetFixedRotation001, TestSize.Level0)
1090 {
1091 int32_t fixedRotation = 1;
1092 GSError ret = bq->SetFixedRotation(fixedRotation);
1093 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1094
1095 int32_t resultFixedRotation = -1;
1096 ret = bq->GetFixedRotation(resultFixedRotation);
1097 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1098 ASSERT_EQ(resultFixedRotation, fixedRotation);
1099 }
1100
1101 /*
1102 * Function: GetLastFlushedDesiredPresentTimeStamp
1103 * Type: Function
1104 * Rank: Important(2)
1105 * EnvConditions: N/A
1106 * CaseDescription: 1. call GetLastFlushedDesiredPresentTimeStamp and check value
1107 */
1108 HWTEST_F(BufferQueueTest, GetLastFlushedDesiredPresentTimeStamp001, TestSize.Level0)
1109 {
1110 int64_t timeStampValue = 100000;
1111 bq->lastFlushedDesiredPresentTimeStamp_ = timeStampValue;
1112 int64_t result = 0;
1113 GSError ret = bq->GetLastFlushedDesiredPresentTimeStamp(result);
1114 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1115 ASSERT_EQ(result, timeStampValue);
1116 }
1117
1118 /*
1119 * Function: GetFrontDesiredPresentTimeStamp
1120 * Type: Function
1121 * Rank: Important(2)
1122 * EnvConditions: N/A
1123 * CaseDescription: 1. call GetFrontDesiredPresentTimeStamp and check value
1124 */
1125 HWTEST_F(BufferQueueTest, GetFrontDesiredPresentTimeStamp001, Function | MediumTest | Level2)
1126 {
1127 int64_t result = 0;
1128 bool isAutoTimeStamp = false;
1129 bq->dirtyList_.clear();
1130 GSError ret = bq->GetFrontDesiredPresentTimeStamp(result, isAutoTimeStamp);
1131 ASSERT_EQ(ret, OHOS::GSERROR_NO_BUFFER);
1132 ASSERT_EQ(result, 0);
1133 }
1134
1135
1136 /*
1137 * Function: GetFrontDesiredPresentTimeStamp
1138 * Type: Function
1139 * Rank: Important(2)
1140 * EnvConditions: N/A
1141 * CaseDescription: 1. call GetFrontDesiredPresentTimeStamp and check value
1142 */
1143 HWTEST_F(BufferQueueTest, GetFrontDesiredPresentTimeStamp002, Function | MediumTest | Level2)
1144 {
1145 int64_t timeStampValue = 100;
1146 bool isAutoTimeStamp = false;
1147 int64_t result = -1;
1148 bq->dirtyList_.clear();
1149 bq->bufferQueueCache_.clear();
1150 uint32_t seqId = 100;
1151 bq->dirtyList_.push_back(seqId);
1152 bq->bufferQueueCache_[seqId].desiredPresentTimestamp = timeStampValue;
1153 bq->bufferQueueCache_[seqId].isAutoTimestamp = isAutoTimeStamp;
1154 GSError ret = bq->GetFrontDesiredPresentTimeStamp(result, isAutoTimeStamp);
1155 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1156 ASSERT_EQ(result, timeStampValue);
1157 }
1158
1159 /*
1160 * Function: GetFrontDesiredPresentTimeStamp
1161 * Type: Function
1162 * Rank: Important(2)
1163 * EnvConditions: N/A
1164 * CaseDescription: 1. call GetFrontDesiredPresentTimeStamp and check value
1165 */
1166 HWTEST_F(BufferQueueTest, GetFrontDesiredPresentTimeStamp003, Function | MediumTest | Level2)
1167 {
1168 std::unique_lock<std::mutex> lock;
1169 int64_t timeStampValue1 = 100;
1170 bool isAutoTimeStamp1 = false;
1171 int64_t timeStampValue2 = 200;
1172 bool isAutoTimeStamp2 = true;
1173 bq->ClearLocked(lock);
1174 uint32_t seqId1 = 100;
1175 uint32_t seqId2 = 200;
1176 bq->dirtyList_.push_back(seqId1);
1177 bq->dirtyList_.push_back(seqId2);
1178 bq->bufferQueueCache_[seqId1].desiredPresentTimestamp = timeStampValue1;
1179 bq->bufferQueueCache_[seqId1].isAutoTimestamp = isAutoTimeStamp1;
1180 bq->bufferQueueCache_[seqId2].desiredPresentTimestamp = timeStampValue2;
1181 bq->bufferQueueCache_[seqId2].isAutoTimestamp = isAutoTimeStamp2;
1182 int64_t result = -1;
1183 bool isAutoTimeStamp = false;
1184 GSError ret = bq->GetFrontDesiredPresentTimeStamp(result, isAutoTimeStamp);
1185 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1186 ASSERT_EQ(result, timeStampValue1);
1187 }
1188
1189 /*
1190 * Function: GetBufferSupportFastCompose
1191 * Type: Function
1192 * Rank: Important(2)
1193 * EnvConditions: N/A
1194 * CaseDescription: 1. call GetBufferSupportFastCompose and check value
1195 */
1196 HWTEST_F(BufferQueueTest, GetBufferSupportFastCompose001, TestSize.Level0)
1197 {
1198 bool supportFastCompose = true;
1199 bq->bufferSupportFastCompose_ = supportFastCompose;
1200 bool result = false;
1201 GSError ret = bq->GetBufferSupportFastCompose(result);
1202 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1203 ASSERT_EQ(result, supportFastCompose);
1204 }
1205
1206 /*
1207 * Function: RegisterProducerPropertyListener
1208 * Type: Function
1209 * Rank: Important(2)
1210 * EnvConditions: N/A
1211 * CaseDescription: 1. call RegisterProducerPropertyListener and check value
1212 */
1213 HWTEST_F(BufferQueueTest, RegisterProducerPropertyListener001, TestSize.Level0)
1214 {
1215 bool producerId = 6;
1216 OnReleaseFunc onBufferRelease = nullptr;
1217 sptr<IProducerListener> listener = new BufferReleaseProducerListener(onBufferRelease);
1218 std::map<uint64_t, sptr<IProducerListener>> propertyChangeListeners_ = {{producerId, listener}};
1219 GSError ret = bq->RegisterProducerPropertyListener(listener, producerId);
1220 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1221 }
1222
1223 /*
1224 * Function: UnRegisterProducerPropertyListener
1225 * Type: Function
1226 * Rank: Important(2)
1227 * EnvConditions: N/A
1228 * CaseDescription: 1. call UnRegisterProducerPropertyListener and check value
1229 */
1230 HWTEST_F(BufferQueueTest, UnRegisterProducerPropertyListener001, TestSize.Level0)
1231 {
1232 bool producerId = 6;
1233 OnReleaseFunc onBufferRelease = nullptr;
1234 sptr<IProducerListener> listener = new BufferReleaseProducerListener(onBufferRelease);
1235 std::map<uint64_t, sptr<IProducerListener>> propertyChangeListeners_ = {{producerId, listener}};
1236 GSError ret = bq->UnRegisterProducerPropertyListener(producerId);
1237 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1238 }
1239
1240 /*
1241 * Function: SetTransformHint
1242 * Type: Function
1243 * Rank: Important(2)
1244 * EnvConditions: N/A
1245 * CaseDescription: 1. call SetTransformHint and check value
1246 */
1247 HWTEST_F(BufferQueueTest, SetTransformHint001, TestSize.Level0)
1248 {
1249 GraphicTransformType transformHint = GraphicTransformType::GRAPHIC_ROTATE_90;
1250 uint64_t producerId = 0;
1251 EXPECT_EQ(bq->SetTransformHint(transformHint, producerId), GSERROR_OK);
1252 transformHint = GraphicTransformType::GRAPHIC_ROTATE_NONE;
1253 ASSERT_EQ(bq->SetTransformHint(transformHint, producerId), OHOS::GSERROR_OK);
1254 }
1255
1256 /*
1257 * Function: PreAllocBuffers
1258 * Type: Function
1259 * Rank: Important(2)
1260 * EnvConditions: N/A
1261 * CaseDescription: 1. preSetUp: producer calls PreAllocBuffers and check the ret
1262 * 2. operation: producer sends invalid width/height/format/allocBufferCount config to bufferQueue
1263 * 3. result: bufferQueue return GSERROR_INVALID_ARGUMENTS
1264 */
1265 HWTEST_F(BufferQueueTest, PreAllocBuffers001, TestSize.Level0)
1266 {
1267 BufferQueue *bqTmp = new BufferQueue("testTmp");
1268 EXPECT_EQ(bqTmp->SetQueueSize(3), GSERROR_OK);
1269 BufferRequestConfig requestConfigTmp = {
1270 .width = 0x0,
1271 .height = 0x100,
1272 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1273 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1274 };
1275 uint32_t allocBufferCount = 3;
1276 GSError ret = bqTmp->PreAllocBuffers(requestConfigTmp, allocBufferCount);
1277 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1278 ASSERT_EQ((bqTmp->bufferQueueCache_).size(), 0);
1279
1280 requestConfigTmp = {
1281 .width = 0x100,
1282 .height = 0x0,
1283 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1284 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1285 };
1286 ret = bqTmp->PreAllocBuffers(requestConfigTmp, allocBufferCount);
1287 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1288 ASSERT_EQ((bqTmp->bufferQueueCache_).size(), 0);
1289
1290 requestConfigTmp = {
1291 .width = 0x100,
1292 .height = 0x100,
1293 .format = GRAPHIC_PIXEL_FMT_BUTT,
1294 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1295 };
1296 ret = bqTmp->PreAllocBuffers(requestConfigTmp, allocBufferCount);
1297 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1298 ASSERT_EQ((bqTmp->bufferQueueCache_).size(), 0);
1299
1300 requestConfigTmp = {
1301 .width = 0x100,
1302 .height = 0x100,
1303 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1304 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1305 };
1306 allocBufferCount = 0;
1307 ret = bqTmp->PreAllocBuffers(requestConfigTmp, allocBufferCount);
1308 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1309 ASSERT_EQ((bqTmp->bufferQueueCache_).size(), 0);
1310 bqTmp = nullptr;
1311 }
1312
1313 /*
1314 * Function: PreAllocBuffers
1315 * Type: Function
1316 * Rank: Important(2)
1317 * EnvConditions: N/A
1318 * CaseDescription: 1. preSetUp: producer calls PreAllocBuffers and check the ret
1319 * 2. operation: producer sends valid width/height/format/allocBufferCount config to bufferQueue
1320 * 3. result: bufferQueue return GSERROR_OK
1321 */
1322 HWTEST_F(BufferQueueTest, PreAllocBuffers002, TestSize.Level0)
1323 {
1324 BufferQueue *bqTmp = new BufferQueue("testTmp");
1325 EXPECT_EQ(bqTmp->SetQueueSize(3), GSERROR_OK);
1326 BufferRequestConfig requestConfigTmp = {
1327 .width = 0x100,
1328 .height = 0x100,
1329 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1330 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1331 };
1332 uint32_t allocBufferCount = 3;
1333 GSError ret = bqTmp->PreAllocBuffers(requestConfigTmp, allocBufferCount);
1334 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1335 ASSERT_EQ((bqTmp->bufferQueueCache_).size(), 3);
1336 bqTmp = nullptr;
1337 }
1338
1339 /*
1340 * Function: PreAllocBuffers
1341 * Type: Function
1342 * Rank: Important(2)
1343 * EnvConditions: N/A
1344 * CaseDescription: 1. preSetUp: producer calls PreAllocBuffers and check the ret
1345 * 2. operation: producer sends valid width/height/format/allocBufferCount and larger allocBufferCount
1346 * than empty bufferQueueSize config to bufferQueue
1347 * 3. result: bufferQueue return GSERROR_OK
1348 */
1349 HWTEST_F(BufferQueueTest, PreAllocBuffers003, TestSize.Level0)
1350 {
1351 BufferQueue *bqTmp = new BufferQueue("testTmp");
1352 EXPECT_EQ(bqTmp->SetQueueSize(1), GSERROR_OK);
1353 BufferRequestConfig requestConfigTmp = {
1354 .width = 0x100,
1355 .height = 0x100,
1356 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1357 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1358 };
1359 uint32_t allocBufferCount = 3;
1360 GSError ret = bqTmp->PreAllocBuffers(requestConfigTmp, allocBufferCount);
1361 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1362 ASSERT_EQ((bqTmp->bufferQueueCache_).size(), 1);
1363 bqTmp = nullptr;
1364 }
1365
1366 /*
1367 * Function: PreAllocBuffers
1368 * Type: Function
1369 * Rank: Important(2)
1370 * EnvConditions: N/A
1371 * CaseDescription: 1. preSetUp: producer calls PreAllocBuffers and check the ret
1372 * 2. operation: producer sends all usage type
1373 * 3. result: bufferQueue return GSERROR_OK
1374 */
1375 HWTEST_F(BufferQueueTest, PreAllocBuffers004, TestSize.Level0)
1376 {
1377 BufferQueue *bqTmp = new BufferQueue("testTmp");
1378 EXPECT_EQ(bqTmp->SetQueueSize(1), GSERROR_OK);
1379 BufferRequestConfig requestConfigTmp = {
1380 .width = 0x100,
1381 .height = 0x100,
1382 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1383 };
1384
1385 uint32_t allocBufferCount = 3;
1386 std::vector<SurfaceBufferUsage> bufferUsages = {
1387 SurfaceBufferUsage::BUFFER_USAGE_CPU_READ,
1388 SurfaceBufferUsage::BUFFER_USAGE_CPU_WRITE,
1389 SurfaceBufferUsage::BUFFER_USAGE_MEM_MMZ,
1390 SurfaceBufferUsage::BUFFER_USAGE_MEM_DMA,
1391 SurfaceBufferUsage::BUFFER_USAGE_MEM_SHARE,
1392 SurfaceBufferUsage::BUFFER_USAGE_MEM_MMZ_CACHE,
1393 SurfaceBufferUsage::BUFFER_USAGE_MEM_FB,
1394 SurfaceBufferUsage::BUFFER_USAGE_ASSIGN_SIZE,
1395 SurfaceBufferUsage::BUFFER_USAGE_HW_RENDER,
1396 SurfaceBufferUsage::BUFFER_USAGE_HW_TEXTURE,
1397 SurfaceBufferUsage::BUFFER_USAGE_HW_COMPOSER,
1398 SurfaceBufferUsage::BUFFER_USAGE_PROTECTED,
1399 SurfaceBufferUsage::BUFFER_USAGE_CAMERA_READ,
1400 SurfaceBufferUsage::BUFFER_USAGE_CAMERA_WRITE,
1401 SurfaceBufferUsage::BUFFER_USAGE_VIDEO_ENCODER,
1402 SurfaceBufferUsage::BUFFER_USAGE_VIDEO_DECODER,
1403 SurfaceBufferUsage::BUFFER_USAGE_CPU_READ_OFTEN,
1404 SurfaceBufferUsage::BUFFER_USAGE_CPU_HW_BOTH,
1405 SurfaceBufferUsage::BUFFER_USAGE_ALIGNMENT_512,
1406 SurfaceBufferUsage::BUFFER_USAGE_DRM_REDRAW,
1407 SurfaceBufferUsage::BUFFER_USAGE_GRAPHIC_2D_ACCEL,
1408 SurfaceBufferUsage::BUFFER_USAGE_PREFER_NO_PADDING
1409 };
1410
1411 for (const auto& bufferUsage : bufferUsages) {
1412 // 遍历不同的usage
1413 requestConfigTmp.usage = bufferUsage;
1414 GSError ret = bqTmp->PreAllocBuffers(requestConfigTmp, allocBufferCount);
1415 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1416 ASSERT_EQ((bqTmp->bufferQueueCache_).size(), 1);
1417 bqTmp = nullptr;
1418 }
1419 }
1420
1421 /*
1422 * Function: PreAllocBuffers
1423 * Type: Function
1424 * Rank: Important(2)
1425 * EnvConditions: N/A
1426 * CaseDescription: 1. preSetUp: producer calls PreAllocBuffers and check the ret
1427 * 2. operation: producer sends valid width/height/format and larger allocBufferCount
1428 * than max bufferQueueSize config to bufferQueue
1429 * 3. result: bufferQueue return GSERROR_OK
1430 */
1431 HWTEST_F(BufferQueueTest, PreAllocBuffers005, TestSize.Level0)
1432 {
1433 BufferQueue *bqTmp = new BufferQueue("testTmp");
1434 // max queue size为64
1435 EXPECT_EQ(bqTmp->SetQueueSize(64), GSERROR_OK);
1436 BufferRequestConfig requestConfigTmp = {
1437 .width = 0x100,
1438 .height = 0x100,
1439 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1440 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1441 };
1442 uint32_t allocBufferCount = 65;
1443 GSError ret = bqTmp->PreAllocBuffers(requestConfigTmp, allocBufferCount);
1444 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1445 ASSERT_EQ((bqTmp->bufferQueueCache_).size(), 64);
1446 bqTmp = nullptr;
1447 }
1448
1449 /*
1450 * Function: MarkBufferReclaimableByIdLocked
1451 * Type: Function
1452 * Rank: Important(2)
1453 * EnvConditions: N/A
1454 * CaseDescription: 1. call MarkBufferReclaimableByIdLocked and check value
1455 */
1456 HWTEST_F(BufferQueueTest, MarkBufferReclaimableByIdLocked001, TestSize.Level0)
1457 {
1458 for (const auto &[id, ele] : bq->bufferQueueCache_) {
1459 printf("seq: %u\n", id);
1460 bq->MarkBufferReclaimableByIdLocked(id);
1461 ASSERT_GT(bq->bufferQueueCache_.size(), 0);
1462 }
1463 }
1464
1465 /*
1466 * Function: SetupNewBufferLockedAndAllocBuffer
1467 * Type: Function
1468 * Rank: Important(2)
1469 * EnvConditions: N/A
1470 * CaseDescription: 1. call SetupNewBufferLocked and AllocBuffer check ret
1471 */
1472 HWTEST_F(BufferQueueTest, SetupNewBufferLockedAndAllocBuffer001, TestSize.Level0)
1473 {
1474 BufferRequestConfig requestConfig = {
1475 .width = 0x100,
1476 .height = 0x100,
1477 .strideAlignment = 0x8,
1478 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1479 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1480 .timeout = 0,
1481 };
1482 BufferRequestConfig updateConfig = {
1483 .width = 0,
1484 .height = 0,
1485 .strideAlignment = 0x8,
1486 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1487 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1488 .timeout = 0,
1489 };
1490 IBufferProducer::RequestBufferReturnValue retval;
1491 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1492 std::mutex mutex;
1493 std::unique_lock<std::mutex> lock(mutex);
1494 EXPECT_EQ(bq->SetupNewBufferLocked(buffer, bedata, updateConfig, requestConfig,
1495 retval, lock), SURFACE_ERROR_UNKOWN);
1496 }
1497
1498 /*
1499 * Function: Multiple requests for buffer in blocking mode, other threads release buffer and reuse buffer
1500 * Type: Function
1501 * Rank: Important(2)
1502 * EnvConditions: N/A
1503 * CaseDescription: 1. requestThread multiple requests for buffer in blocking mode
1504 * 2. releaseThread release buffer
1505 * 3. requestThread reuse buffer
1506 * 4. check ret
1507 */
1508 HWTEST_F(BufferQueueTest, ReqBufferWithBlockModeAndReuseBuffer001, TestSize.Level0)
1509 {
1510 IBufferProducer::RequestBufferReturnValue retval;
1511 IBufferProducer::RequestBufferReturnValue retval1;
1512 IBufferProducer::RequestBufferReturnValue retval2;
1513 IBufferProducer::RequestBufferReturnValue retval3;
1514
1515 BufferRequestConfig requestConfigTest = {
1516 .width = 0x100,
1517 .height = 0x100,
1518 .strideAlignment = 0x8,
1519 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1520 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1521 .timeout = 5000,
1522 };
1523 std::mutex mtx;
1524 std::condition_variable cv;
1525 bool conditionMet = false;
1526 std::atomic<bool> stopRequest(false);
1527 std::atomic<bool> stopRelease(false);
1528 sptr<BufferQueue> bqTest = new BufferQueue("test");
1529 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
1530 bqTest->RegisterConsumerListener(listener);
1531 // Create thread for requesting buffer
__anon57f68eb70102() 1532 std::thread requestThread([&]() {
1533 while (!stopRequest) {
1534 GSError ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval);
1535 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1536 ASSERT_GE(retval.sequence, 0);
1537 ASSERT_NE(retval.buffer, nullptr);
1538
1539 ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval1);
1540 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1541 ASSERT_GE(retval1.sequence, 0);
1542 ASSERT_NE(retval1.buffer, nullptr);
1543
1544 ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval2);
1545 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1546 ASSERT_GE(retval2.sequence, 0);
1547 ASSERT_NE(retval2.buffer, nullptr);
1548
1549 ASSERT_EQ(bqTest->freeList_.size(), 0);
1550 ASSERT_EQ(bqTest->GetUsedSize(), 3U);
1551 ASSERT_EQ(bqTest->bufferQueueSize_, 3U);
1552 ASSERT_EQ(bqTest->detachReserveSlotNum_, 0);
1553 ASSERT_EQ(bqTest->dirtyList_.size(), 0);
1554
1555 conditionMet = true;
1556 cv.notify_one();
1557 auto start = std::chrono::high_resolution_clock::now();
1558 ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval3);
1559 auto end = std::chrono::high_resolution_clock::now();
1560 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
1561 std::cout << "RequestBuffer costs: " << duration.count() << "ms" << std::endl;
1562 ASSERT_LT(duration.count(), 1500); // Confirm blockage 1500 means timeout value
1563 ASSERT_GT(duration.count(), 800); // Confirm blockage 800 means timeout value
1564 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1565 ASSERT_EQ(retval3.buffer, nullptr);
1566 }
1567 });
1568
1569 // Create a thread to release the buffer
__anon57f68eb70202() 1570 std::thread releaseThread([&]() {
1571 std::unique_lock<std::mutex> lock(mtx);
1572 cv.wait(lock, [&]() { return conditionMet || stopRelease; });
1573 std::this_thread::sleep_for(std::chrono::seconds(1));
1574 if (conditionMet) {
1575 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
1576 GSError ret = bqTest->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
1577 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1578 ASSERT_EQ(bqTest->freeList_.size(), 0);
1579 ASSERT_EQ(bqTest->dirtyList_.size(), 1);
1580 ret = bqTest->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
1581 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1582 ASSERT_NE(retval.buffer, nullptr);
1583 ASSERT_EQ(bqTest->freeList_.size(), 0);
1584 ASSERT_EQ(bqTest->dirtyList_.size(), 0);
1585 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
1586 ret = bqTest->ReleaseBuffer(retval.buffer, releaseFence);
1587 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1588 ASSERT_EQ(bqTest->freeList_.size(), 1);
1589 ASSERT_EQ(bqTest->dirtyList_.size(), 0);
1590 }
1591 });
1592 // Stop the threads after 1 second
1593 std::this_thread::sleep_for(std::chrono::seconds(1));
1594 stopRequest = true;
1595 stopRelease = true;
1596 cv.notify_one();
1597
1598 requestThread.join();
1599 releaseThread.join();
1600 }
1601
1602 /*
1603 * Function: Multiple requests for buffer in blocking mode, other threads set status wrong
1604 * Type: Function
1605 * Rank: Important(2)
1606 * EnvConditions: N/A
1607 * CaseDescription: 1. requestThread multiple requests for buffer in blocking mode
1608 * 2. releaseThread set status wrong
1609 * 3. requestThread return GSERROR_NO_CONSUMER
1610 */
1611 HWTEST_F(BufferQueueTest, ReqBufferWithBlockModeAndStatusWrong001, TestSize.Level0)
1612 {
1613 IBufferProducer::RequestBufferReturnValue retval;
1614 IBufferProducer::RequestBufferReturnValue retval1;
1615 IBufferProducer::RequestBufferReturnValue retval2;
1616 IBufferProducer::RequestBufferReturnValue retval3;
1617
1618 BufferRequestConfig requestConfigTest = {
1619 .width = 0x100,
1620 .height = 0x100,
1621 .strideAlignment = 0x8,
1622 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1623 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1624 .timeout = 5000,
1625 };
1626 std::mutex mtx;
1627 std::condition_variable cv;
1628 bool conditionMet = false;
1629 std::atomic<bool> stopRequest(false);
1630 std::atomic<bool> stopRelease(false);
1631 sptr<BufferQueue> bqTest = new BufferQueue("test");
1632 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
1633 bqTest->RegisterConsumerListener(listener);
1634 // Create thread for requesting buffer
__anon57f68eb70402() 1635 std::thread requestThread([&]() {
1636 while (!stopRequest) {
1637 GSError ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval);
1638 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1639 ASSERT_GE(retval.sequence, 0);
1640 ASSERT_NE(retval.buffer, nullptr);
1641
1642 ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval1);
1643 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1644 ASSERT_GE(retval1.sequence, 0);
1645 ASSERT_NE(retval1.buffer, nullptr);
1646
1647 ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval2);
1648 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1649 ASSERT_GE(retval2.sequence, 0);
1650 ASSERT_NE(retval2.buffer, nullptr);
1651
1652 ASSERT_EQ(bqTest->freeList_.size(), 0);
1653 ASSERT_EQ(bqTest->GetUsedSize(), 3U);
1654 ASSERT_EQ(bqTest->bufferQueueSize_, 3U);
1655 ASSERT_EQ(bqTest->detachReserveSlotNum_, 0);
1656 ASSERT_EQ(bqTest->dirtyList_.size(), 0);
1657
1658 conditionMet = true;
1659 cv.notify_one();
1660 auto start = std::chrono::high_resolution_clock::now();
1661 ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval3);
1662 auto end = std::chrono::high_resolution_clock::now();
1663 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
1664 std::cout << "RequestBuffer costs: " << duration.count() << "ms" << std::endl;
1665 ASSERT_LT(duration.count(), 1500); // Confirm blockage 1500 means timeout value
1666 ASSERT_GT(duration.count(), 800); // Confirm blockage 800 means timeout value
1667 ASSERT_EQ(ret, OHOS::GSERROR_NO_CONSUMER);
1668 ASSERT_EQ(retval3.buffer, nullptr);
1669 }
1670 });
1671
1672 // Create a thread to set status wrong
__anon57f68eb70502() 1673 std::thread releaseThread([&]() {
1674 std::unique_lock<std::mutex> lock(mtx);
1675 cv.wait(lock, [&]() { return conditionMet || stopRelease; });
1676 std::this_thread::sleep_for(std::chrono::seconds(1));
1677 if (conditionMet) {
1678 bqTest->SetStatus(false);
1679 }
1680 });
1681 // Stop the threads after 1 second
1682 std::this_thread::sleep_for(std::chrono::seconds(1));
1683 stopRequest = true;
1684 stopRelease = true;
1685 cv.notify_one();
1686
1687 requestThread.join();
1688 releaseThread.join();
1689 }
1690
1691 /*
1692 * Function: SetIsActiveGame
1693 * Type: Function
1694 * Rank: Important(2)
1695 * EnvConditions: N/A
1696 * CaseDescription: 1. call SetIsActiveGame and check value
1697 */
1698 HWTEST_F(BufferQueueTest, SetIsActiveGame001, TestSize.Level0)
1699 {
1700 BufferQueue *bqTmp = new BufferQueue("testTmp");
1701 ASSERT_EQ(bqTmp->SetQueueSize(1), GSERROR_OK);
1702
1703 bqTmp->SetIsActiveGame(true);
1704 ASSERT_EQ(bqTmp->isActiveGame_, true);
1705 bqTmp = nullptr;
1706 }
1707
1708 /*
1709 * Function: AcquireBuffer and ReleaseBuffer
1710 * Type: Function
1711 * Rank: Important(2)
1712 * EnvConditions: N/A
1713 * CaseDescription: 1. call AcquireBuffer and check value
1714 */
1715 HWTEST_F(BufferQueueTest, ReleaseBufferBySeq001, TestSize.Level0)
1716 {
1717 sptr<BufferQueue> bqTest = new BufferQueue("test");
1718 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
1719 bqTest->RegisterConsumerListener(listener);
1720
1721 IBufferProducer::RequestBufferReturnValue retval;
1722 BufferRequestConfig requestConfigTest = {
1723 .width = 0x100,
1724 .height = 0x100,
1725 .strideAlignment = 0x8,
1726 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1727 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1728 .timeout = 5000,
1729 };
1730 bqTest->SetIsActiveGame(true);
1731
1732 GSError ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval);
1733 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1734 ASSERT_NE(retval.buffer, nullptr);
1735 ASSERT_GE(retval.sequence, 0);
1736
1737 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
1738 ret = bqTest->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
1739 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1740
1741 IConsumerSurface::AcquireBufferReturnValue returnVal;
1742 ret = bqTest->AcquireBuffer(returnVal);
1743 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1744
1745 ret = bqTest->ReleaseBuffer(returnVal.buffer->GetSeqNum(), returnVal.fence);
1746 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1747
1748 ret = bqTest->ReleaseBuffer(returnVal.buffer->GetSeqNum(), returnVal.fence);
1749 ASSERT_EQ(ret, OHOS::GSERROR_BUFFER_STATE_INVALID);
1750
1751 bqTest = nullptr;
1752 }
1753
1754 /*
1755 * Function: AcquireLppBuffer
1756 * Type: Function
1757 * Rank: Important(2)
1758 * EnvConditions: N/A
1759 * CaseDescription: call AcquireLppBuffer
1760 */
1761 HWTEST_F(BufferQueueTest, AcquireLppBuffer001, TestSize.Level0)
1762 {
1763 sptr<SurfaceBuffer> buffer = nullptr;
1764 sptr<SyncFence> acquireFence = SyncFence::InvalidFence();
1765 int64_t timestamp = 0;
1766 std::vector<Rect> damage;
1767 sptr<BufferQueue> tmpBq = new BufferQueue("test");
1768
1769 tmpBq->sourceType_ = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
1770 tmpBq->lppSlotInfo_ = nullptr;
1771 ASSERT_EQ(tmpBq->AcquireLppBuffer(buffer, acquireFence, timestamp, damage), OHOS::GSERROR_TYPE_ERROR);
1772
1773 tmpBq->sourceType_ = OHSurfaceSource::OH_SURFACE_SOURCE_LOWPOWERVIDEO;
1774 tmpBq->lppSlotInfo_ = nullptr;
1775 ASSERT_EQ(tmpBq->AcquireLppBuffer(buffer, acquireFence, timestamp, damage), OHOS::GSERROR_TYPE_ERROR);
1776
1777 tmpBq->lppSlotInfo_ = new LppSlotInfo{.readOffset = -1,
1778 .writeOffset = -1,
1779 .slot = {{.seqId = 100, .timestamp = 1000, .damage = {1, 2, 3, 4}}},
1780 .frameRate = 30,
1781 .isStopShbDraw = false};
1782 ASSERT_EQ(tmpBq->AcquireLppBuffer(buffer, acquireFence, timestamp, damage), OHOS::GSERROR_INVALID_ARGUMENTS);
1783
1784 tmpBq->lppSlotInfo_->readOffset = 9;
1785 ASSERT_EQ(tmpBq->AcquireLppBuffer(buffer, acquireFence, timestamp, damage), OHOS::GSERROR_INVALID_ARGUMENTS);
1786
1787 tmpBq->lppSlotInfo_->readOffset = 0;
1788 ASSERT_EQ(tmpBq->AcquireLppBuffer(buffer, acquireFence, timestamp, damage), OHOS::GSERROR_INVALID_ARGUMENTS);
1789
1790 tmpBq->lppSlotInfo_->writeOffset = 9;
1791 ASSERT_EQ(tmpBq->AcquireLppBuffer(buffer, acquireFence, timestamp, damage), OHOS::GSERROR_INVALID_ARGUMENTS);
1792
1793 tmpBq->lppSlotInfo_->writeOffset = 1;
1794 tmpBq->isRsDrawLpp_ = false;
1795 tmpBq->lppBufferCache_.clear();
1796 ASSERT_EQ(tmpBq->AcquireLppBuffer(buffer, acquireFence, timestamp, damage), OHOS::GSERROR_NO_BUFFER);
1797
1798 tmpBq->isRsDrawLpp_ = true;
1799 tmpBq->lastLppWriteOffset_ = tmpBq->lppSlotInfo_->writeOffset;
1800 ASSERT_EQ(tmpBq->AcquireLppBuffer(buffer, acquireFence, timestamp, damage), OHOS::GSERROR_NO_BUFFER);
1801
1802 tmpBq->lppSlotInfo_->readOffset = 7;
1803 ASSERT_EQ(tmpBq->AcquireLppBuffer(buffer, acquireFence, timestamp, damage), OHOS::GSERROR_NO_BUFFER);
1804
1805 tmpBq->lppSlotInfo_->readOffset = 0;
1806 tmpBq->lastLppWriteOffset_ = tmpBq->lppSlotInfo_->writeOffset + 1;
1807 ASSERT_EQ(tmpBq->AcquireLppBuffer(buffer, acquireFence, timestamp, damage), OHOS::GSERROR_NO_BUFFER);
1808
1809 tmpBq->lppSlotInfo_->readOffset = 7;
1810 tmpBq->lppBufferCache_[100] = SurfaceBuffer::Create();
1811 ASSERT_EQ(tmpBq->AcquireLppBuffer(buffer, acquireFence, timestamp, damage), OHOS::GSERROR_OK);
1812 tmpBq->sourceType_ = OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT;
1813 std::cout << "AcquireLppBuffer001 End" << std::endl;
1814 }
1815 /*
1816 * Function: SetLppShareFd
1817 * Type: Function
1818 * Rank: Important(2)
1819 * EnvConditions: N/A
1820 * CaseDescription: call SetLppShareFd
1821 */
1822 HWTEST_F(BufferQueueTest, SetLppShareFd001, TestSize.Level0)
1823 {
1824 sptr<BufferQueue> tmpBq = new BufferQueue("test");
1825 int fd = -1;
1826 bool state = true;
1827 tmpBq->sourceType_ = OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT;
1828 ASSERT_EQ(tmpBq->SetLppShareFd(fd, state), OHOS::GSERROR_TYPE_ERROR);
1829
1830 tmpBq->sourceType_ = OHSurfaceSource::OH_SURFACE_SOURCE_LOWPOWERVIDEO;
1831 tmpBq->lppSlotInfo_ = nullptr;
1832 ASSERT_EQ(tmpBq->SetLppShareFd(fd, state), OHOS::GSERROR_INVALID_ARGUMENTS);
1833
1834 state = false;
1835 ASSERT_EQ(tmpBq->SetLppShareFd(fd, state), OHOS::GSERROR_OK);
1836 }
1837
1838 /*
1839 * Function: SetLppShareFd
1840 * Type: Function
1841 * Rank: Important(2)
1842 * EnvConditions: N/A
1843 * CaseDescription: call SetLppShareFd
1844 */
1845 HWTEST_F(BufferQueueTest, SetLppShareFd002, TestSize.Level0)
1846 {
1847 sptr<BufferQueue> tmpBq = new BufferQueue("test");
1848 bool state = true;
1849 int fd = open("/dev/lpptest", O_RDWR | O_CREAT, static_cast<mode_t>(0600));
1850 ASSERT_NE(fd, -1);
1851 ASSERT_NE(ftruncate(fd, 0x1000), -1);
1852
1853 tmpBq->lppSlotInfo_ = nullptr;
1854 tmpBq->sourceType_ = OHSurfaceSource::OH_SURFACE_SOURCE_LOWPOWERVIDEO;
1855 ASSERT_EQ(tmpBq->SetLppShareFd(fd, state), OHOS::GSERROR_OK);
1856 state = false;
1857 ASSERT_EQ(tmpBq->SetLppShareFd(fd, state), OHOS::GSERROR_OK);
1858 close(fd);
1859
1860 state = true;
1861 fd = open("/dev/lpptest", O_RDWR | O_CREAT, static_cast<mode_t>(0600));
1862 ASSERT_NE(fd, -1);
1863 ASSERT_NE(ftruncate(fd, 0x1000), -1);
1864 tmpBq->lppSlotInfo_ = nullptr;
1865 tmpBq->sourceType_ = OHSurfaceSource::OH_SURFACE_SOURCE_LOWPOWERVIDEO;
1866 ASSERT_EQ(tmpBq->SetLppShareFd(fd, state), OHOS::GSERROR_OK);
1867 ASSERT_EQ(tmpBq->SetLppShareFd(-1, state), OHOS::GSERROR_INVALID_ARGUMENTS);
1868 close(fd);
1869 }
1870 /*
1871 * Function: FlushLppBuffer
1872 * Type: Function
1873 * Rank: Important(2)
1874 * EnvConditions: N/A
1875 * CaseDescription: call FlushLppBuffer
1876 */
1877 HWTEST_F(BufferQueueTest, FlushLppBuffer001, TestSize.Level0)
1878 {
1879 sptr<BufferQueue> tmpBq = new BufferQueue("test");
1880 ASSERT_NE(tmpBq, nullptr);
1881 tmpBq->FlushLppBuffer();
1882 ASSERT_TRUE(tmpBq->dirtyList_.empty());
1883 tmpBq->sourceType_ = OHSurfaceSource::OH_SURFACE_SOURCE_LOWPOWERVIDEO;
1884 tmpBq->lppSlotInfo_ = new LppSlotInfo{.readOffset = 0,
1885 .writeOffset = 1,
1886 .slot = {{.seqId = 100, .timestamp = 1000, .damage = {1, 2, 3, 4}}},
1887 .frameRate = 30,
1888 .isStopShbDraw = false};
1889 tmpBq->isRsDrawLpp_ = false;
1890 tmpBq->lppBufferCache_[100] = SurfaceBuffer::Create();
1891 tmpBq->FlushLppBuffer();
1892 ASSERT_TRUE(tmpBq->dirtyList_.empty());
1893 }
1894 /*
1895 * Function: SetLppDrawSource
1896 * Type: Function
1897 * Rank: Important(2)
1898 * EnvConditions: N/A
1899 * CaseDescription: call SetLppDrawSource
1900 */
1901 HWTEST_F(BufferQueueTest, SetLppDrawSource001, TestSize.Level0)
1902 {
1903 sptr<BufferQueue> tmpBq = new BufferQueue("test");
1904 bool isShbDrawLpp = false;
1905 bool isRsDrawLpp = false;
1906 tmpBq->sourceType_ = OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT;
1907 ASSERT_EQ(tmpBq->SetLppDrawSource(isShbDrawLpp, isRsDrawLpp), OHOS::GSERROR_TYPE_ERROR);
1908
1909 tmpBq->sourceType_ = OHSurfaceSource::OH_SURFACE_SOURCE_LOWPOWERVIDEO;
1910 tmpBq->lppSlotInfo_ = nullptr;
1911 ASSERT_EQ(tmpBq->SetLppDrawSource(isShbDrawLpp, isRsDrawLpp), OHOS::GSERROR_TYPE_ERROR);
1912
1913 tmpBq->lppSlotInfo_ = new LppSlotInfo{.readOffset = 0,
1914 .writeOffset = 1,
1915 .slot = {{.seqId = 100, .timestamp = 1000, .damage = {1, 2, 3, 4}}},
1916 .frameRate = 30,
1917 .isStopShbDraw = false};
1918 tmpBq->lppSkipCount_ = 11;
1919 ASSERT_EQ(tmpBq->SetLppDrawSource(isShbDrawLpp, isRsDrawLpp), OHOS::GSERROR_OUT_OF_RANGE);
1920
1921 tmpBq->lppSkipCount_ = 0;
1922 ASSERT_EQ(tmpBq->SetLppDrawSource(isShbDrawLpp, isRsDrawLpp), OHOS::GSERROR_OK);
1923 }
1924
1925 /*
1926 * Function: SetAlphaType
1927 * Type: Function
1928 * Rank: Important(2)
1929 * EnvConditions: N/A
1930 * CaseDescription: call SetAlphaType
1931 */
1932 HWTEST_F(BufferQueueTest, SetAlphaTypeTest, TestSize.Level0)
1933 {
1934 sptr<BufferQueue> tmpBq = new BufferQueue("test");
1935 GraphicAlphaType alphaType = static_cast<GraphicAlphaType>(-1);
1936 ASSERT_EQ(tmpBq->SetAlphaType(alphaType), OHOS::GSERROR_INVALID_ARGUMENTS);
1937
1938 alphaType = static_cast<GraphicAlphaType>(0);
1939 ASSERT_EQ(tmpBq->SetAlphaType(alphaType), OHOS::GSERROR_OK);
1940
1941 alphaType = static_cast<GraphicAlphaType>(1);
1942 ASSERT_EQ(tmpBq->SetAlphaType(alphaType), OHOS::GSERROR_OK);
1943
1944 alphaType = static_cast<GraphicAlphaType>(2);
1945 ASSERT_EQ(tmpBq->SetAlphaType(alphaType), OHOS::GSERROR_OK);
1946
1947 alphaType = static_cast<GraphicAlphaType>(3);
1948 ASSERT_EQ(tmpBq->SetAlphaType(alphaType), OHOS::GSERROR_OK);
1949
1950 alphaType = static_cast<GraphicAlphaType>(4);
1951 ASSERT_EQ(tmpBq->SetAlphaType(alphaType), OHOS::GSERROR_INVALID_ARGUMENTS);
1952 }
1953
1954 /*
1955 * Function: GetAlphaType
1956 * Type: Function
1957 * Rank: Important(2)
1958 * EnvConditions: N/A
1959 * CaseDescription: call GetAlphaType
1960 */
1961 HWTEST_F(BufferQueueTest, GetAlphaTypeTest, TestSize.Level0)
1962 {
1963 sptr<BufferQueue> tmpBq = new BufferQueue("test");
1964 GraphicAlphaType tmpAlphaType = static_cast<GraphicAlphaType>(1);
1965 ASSERT_EQ(tmpBq->SetAlphaType(tmpAlphaType), OHOS::GSERROR_OK);
1966
1967 GraphicAlphaType alphaType;
1968 ASSERT_EQ(tmpBq->GetAlphaType(alphaType), OHOS::GSERROR_OK);
1969 ASSERT_EQ(alphaType, GraphicAlphaType::GRAPHIC_ALPHATYPE_OPAQUE);
1970 }
1971
1972 /*
1973 * Function: SetIsPriorityAlloc
1974 * Type: Function
1975 * Rank: Important(2)
1976 * EnvConditions: N/A
1977 * CaseDescription: 1. call SetIsPriorityAlloc and check value
1978 */
1979 HWTEST_F(BufferQueueTest, SetIsPriorityAlloc001, TestSize.Level0)
1980 {
1981 BufferQueue *bqTmp = new BufferQueue("testTmp");
1982 ASSERT_EQ(bqTmp->SetQueueSize(1), GSERROR_OK);
1983
1984 bqTmp->SetIsPriorityAlloc(true);
1985 ASSERT_EQ(bqTmp->isPriorityAlloc_, true);
1986 bqTmp->SetIsPriorityAlloc(false);
1987 bqTmp = nullptr;
1988 }
1989
1990 /*
1991 * Function: SetIsPriorityAlloc
1992 * Type: Function
1993 * Rank: Important(2)
1994 * EnvConditions: N/A
1995 * CaseDescription: 1. call SetIsPriorityAlloc and check value
1996 */
1997 HWTEST_F(BufferQueueTest, SetIsPriorityAlloc002, TestSize.Level0)
1998 {
1999 sptr<BufferQueue> bqTest = new BufferQueue("test");
2000 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
2001 bqTest->RegisterConsumerListener(listener);
2002
2003 IBufferProducer::RequestBufferReturnValue retval;
2004 IBufferProducer::RequestBufferReturnValue retval1;
2005 IBufferProducer::RequestBufferReturnValue retval2;
2006 IBufferProducer::RequestBufferReturnValue retval3;
2007
2008 BufferRequestConfig requestConfigTest = {
2009 .width = 0x100,
2010 .height = 0x100,
2011 .strideAlignment = 0x8,
2012 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
2013 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
2014 .timeout = 5000,
2015 };
2016 bqTest->SetQueueSize(3);
2017 bqTest->SetIsPriorityAlloc(true);
2018 // fisrt request buffer
2019 GSError ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval);
2020 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2021 ASSERT_GE(retval.sequence, 0);
2022 ASSERT_NE(retval.buffer, nullptr);
2023 ASSERT_EQ(bqTest->GetUsedSize(), 1);
2024
2025 ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval1);
2026 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2027 ASSERT_GE(retval1.sequence, 0);
2028 ASSERT_NE(retval1.buffer, nullptr);
2029 ASSERT_EQ(bqTest->GetUsedSize(), 2);
2030 // used buffer queue size is max
2031 ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval2);
2032 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2033 ASSERT_GE(retval2.sequence, 0);
2034 ASSERT_NE(retval2.buffer, nullptr);
2035 ASSERT_EQ(bqTest->GetUsedSize(), 3);
2036
2037 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
2038 ret = bqTest->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
2039 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2040 ASSERT_EQ(bqTest->GetUsedSize(), 3);
2041
2042 ret = bqTest->FlushBuffer(retval1.sequence, bedata, acquireFence, flushConfig);
2043 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2044 ASSERT_EQ(bqTest->GetUsedSize(), 3);
2045
2046 ret = bqTest->FlushBuffer(retval2.sequence, bedata, acquireFence, flushConfig);
2047 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2048 ASSERT_EQ(bqTest->GetUsedSize(), 3);
2049
2050 ret = bqTest->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
2051 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2052 ASSERT_NE(retval.buffer, nullptr);
2053
2054 uint8_t *addr2 = reinterpret_cast<uint8_t*>(retval.buffer->GetVirAddr());
2055 ASSERT_NE(addr2, nullptr);
2056
2057 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
2058 ret = bqTest->ReleaseBuffer(retval.buffer, releaseFence);
2059 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2060 // reuse
2061 ret = bqTest->RequestBuffer(requestConfigTest, bedata, retval);
2062 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2063 ASSERT_GE(retval.sequence, 0);
2064 ASSERT_EQ(retval.buffer, nullptr);
2065 ASSERT_EQ(bqTest->GetUsedSize(), 3);
2066
2067 ret = bqTest->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
2068 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2069 ASSERT_EQ(bqTest->GetUsedSize(), 3);
2070 }
2071 }