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_manager.h>
21 #include "buffer_consumer_listener.h"
22 #include "sync_fence.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS::Rosen {
28 class BufferQueueTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32
33 static inline BufferRequestConfig requestConfig = {
34 .width = 0x100,
35 .height = 0x100,
36 .strideAlignment = 0x8,
37 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
38 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
39 .timeout = 0,
40 };
41 static inline BufferFlushConfigWithDamages flushConfig = {
42 .damages = {
43 {
44 .w = 0x100,
45 .h = 0x100,
46 }
47 },
48 };
49 static inline int64_t timestamp = 0;
50 static inline std::vector<Rect> damages = {};
51 static inline sptr<BufferQueue> bq = nullptr;
52 static inline std::map<int32_t, sptr<SurfaceBuffer>> cache;
53 static inline sptr<BufferExtraData> bedata = nullptr;
54 };
55
SetUpTestCase()56 void BufferQueueTest::SetUpTestCase()
57 {
58 bq = new BufferQueue("test");
59 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
60 bq->RegisterConsumerListener(listener);
61 bedata = new OHOS::BufferExtraDataImpl;
62 }
63
TearDownTestCase()64 void BufferQueueTest::TearDownTestCase()
65 {
66 bq = nullptr;
67 }
68
69 /*
70 * Function: Init
71 * Type: Function
72 * Rank: Important(2)
73 * EnvConditions: N/A
74 * CaseDescription: 1. call Init and check ret
75 */
76 HWTEST_F(BufferQueueTest, Init001, Function | MediumTest | Level2)
77 {
78 GSError ret = bq->Init();
79 ASSERT_EQ(ret, OHOS::GSERROR_OK);
80 }
81
82 /*
83 * Function: GetUsedSize
84 * Type: Function
85 * Rank: Important(2)
86 * EnvConditions: N/A
87 * CaseDescription: 1. call GetUsedSize and check ret
88 */
89 HWTEST_F(BufferQueueTest, GetUsedSize001, Function | MediumTest | Level2)
90 {
91 uint32_t usedSize = bq->GetUsedSize();
92 ASSERT_NE(usedSize, -1);
93 }
94
95 /*
96 * Function: SetQueueSize and GetQueueSize
97 * Type: Function
98 * Rank: Important(2)
99 * EnvConditions: N/A
100 * CaseDescription: 1. call GetQueueSize for default
101 * 2. call SetQueueSize
102 * 3. call SetQueueSize again with abnormal input
103 * 4. check ret and call GetQueueSize
104 */
105 HWTEST_F(BufferQueueTest, QueueSize001, Function | MediumTest | Level2)
106 {
107 ASSERT_EQ(bq->GetQueueSize(), (uint32_t)SURFACE_DEFAULT_QUEUE_SIZE);
108
109 GSError ret = bq->SetQueueSize(2);
110 ASSERT_EQ(ret, OHOS::GSERROR_OK);
111
112 ret = bq->SetQueueSize(SURFACE_MAX_QUEUE_SIZE + 1);
113 ASSERT_NE(ret, OHOS::GSERROR_OK);
114
115 ASSERT_EQ(bq->GetQueueSize(), 2u);
116 }
117
118 /*
119 * Function: SetQueueSize and GetQueueSize
120 * Type: Function
121 * Rank: Important(2)
122 * EnvConditions: N/A
123 * CaseDescription: 1. call SetQueueSize 2 times both with abnormal input
124 * 2. call GetQueueSize
125 * 3. check ret
126 */
127 HWTEST_F(BufferQueueTest, QueueSize002, Function | MediumTest | Level2)
128 {
129 GSError ret = bq->SetQueueSize(-1);
130 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
131 ASSERT_EQ(bq->GetQueueSize(), 2u);
132
133 ret = bq->SetQueueSize(0);
134 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
135 ASSERT_EQ(bq->GetQueueSize(), 2u);
136 }
137
138 /*
139 * Function: RequestBuffer, FlushBuffer, AcquireBuffer and ReleaseBuffer
140 * Type: Function
141 * Rank: Important(2)
142 * EnvConditions: N/A
143 * CaseDescription: 1. call RequestBuffer and FlushBuffer
144 * 2. call AcquireBuffer and ReleaseBuffer
145 * 3. check ret
146 */
147 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel001, Function | MediumTest | Level2)
148 {
149 IBufferProducer::RequestBufferReturnValue retval;
150
151 // first request
152 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
153 ASSERT_EQ(ret, OHOS::GSERROR_OK);
154 ASSERT_NE(retval.buffer, nullptr);
155 ASSERT_GE(retval.sequence, 0);
156
157 // add cache
158 cache[retval.sequence] = retval.buffer;
159
160 // buffer queue will map
161 uint8_t *addr1 = reinterpret_cast<uint8_t*>(retval.buffer->GetVirAddr());
162 ASSERT_NE(addr1, nullptr);
163 addr1[0] = 5;
164
165 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
166 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
167 ASSERT_EQ(ret, OHOS::GSERROR_OK);
168
169 ret = bq->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
170 ASSERT_EQ(ret, OHOS::GSERROR_OK);
171 ASSERT_NE(retval.buffer, nullptr);
172
173 uint8_t *addr2 = reinterpret_cast<uint8_t*>(retval.buffer->GetVirAddr());
174 ASSERT_NE(addr2, nullptr);
175 if (addr2 != nullptr) {
176 ASSERT_EQ(addr2[0], 5u);
177 }
178
179 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
180 ret = bq->ReleaseBuffer(retval.buffer, releaseFence);
181 ASSERT_EQ(ret, OHOS::GSERROR_OK);
182 }
183
184 /*
185 * Function: RequestBuffer and CancelBuffer
186 * Type: Function
187 * Rank: Important(2)
188 * EnvConditions: N/A
189 * CaseDescription: 1. call RequestBuffer
190 * 2. call CancelBuffer
191 * 3. check ret
192 */
193 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel002, Function | MediumTest | Level2)
194 {
195 IBufferProducer::RequestBufferReturnValue retval;
196
197 // not first request
198 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
199 ASSERT_EQ(ret, OHOS::GSERROR_OK);
200 ASSERT_GE(retval.sequence, 0);
201 ASSERT_EQ(retval.buffer, nullptr);
202
203 ret = bq->CancelBuffer(retval.sequence, bedata);
204 ASSERT_EQ(ret, OHOS::GSERROR_OK);
205 }
206
207 /*
208 * Function: RequestBuffer and CancelBuffer
209 * Type: Function
210 * Rank: Important(2)
211 * EnvConditions: N/A
212 * CaseDescription: 1. call RequestBuffer
213 * 2. call CancelBuffer 2 times
214 * 3. check ret
215 */
216 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel003, Function | MediumTest | Level2)
217 {
218 IBufferProducer::RequestBufferReturnValue retval;
219
220 // not first request
221 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
222 ASSERT_EQ(ret, OHOS::GSERROR_OK);
223 ASSERT_GE(retval.sequence, 0);
224 ASSERT_EQ(retval.buffer, nullptr);
225
226 ret = bq->CancelBuffer(retval.sequence, bedata);
227 ASSERT_EQ(ret, OHOS::GSERROR_OK);
228
229 ret = bq->CancelBuffer(retval.sequence, bedata);
230 ASSERT_NE(ret, OHOS::GSERROR_OK);
231 }
232
233 /*
234 * Function: RequestBuffer and FlushBuffer
235 * Type: Function
236 * Rank: Important(2)
237 * EnvConditions: N/A
238 * CaseDescription: 1. call RequestBuffer
239 * 2. call FlushBuffer 2 times
240 * 3. check ret
241 */
242 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel004, Function | MediumTest | Level2)
243 {
244 IBufferProducer::RequestBufferReturnValue retval;
245
246 // not first request
247 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
248 ASSERT_EQ(ret, OHOS::GSERROR_OK);
249 ASSERT_GE(retval.sequence, 0);
250 ASSERT_EQ(retval.buffer, nullptr);
251
252 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
253 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
254 ASSERT_EQ(ret, OHOS::GSERROR_OK);
255
256 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
257 ASSERT_NE(ret, OHOS::GSERROR_OK);
258 }
259
260 /*
261 * Function: AcquireBuffer and ReleaseBuffer
262 * Type: Function
263 * Rank: Important(2)
264 * EnvConditions: N/A
265 * CaseDescription: 1. call AcquireBuffer
266 * 2. call ReleaseBuffer 2 times
267 * 3. check ret
268 */
269 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel005, Function | MediumTest | Level2)
270 {
271 sptr<SurfaceBuffer> buffer;
272
273 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
274 GSError ret = bq->AcquireBuffer(buffer, acquireFence, timestamp, damages);
275 ASSERT_EQ(ret, OHOS::GSERROR_OK);
276
277 sptr<SyncFence> ReleaseFence = SyncFence::INVALID_FENCE;
278 ret = bq->ReleaseBuffer(buffer, ReleaseFence);
279 ASSERT_EQ(ret, OHOS::GSERROR_OK);
280
281 ret = bq->ReleaseBuffer(buffer, ReleaseFence);
282 ASSERT_NE(ret, OHOS::GSERROR_OK);
283 }
284
285 /*
286 * Function: RequestBuffer, and CancelBuffer
287 * Type: Function
288 * Rank: Important(2)
289 * EnvConditions: N/A
290 * CaseDescription: 1. call RequestBuffer and CancelBuffer by different retval
291 * 2. check ret
292 */
293 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel006, Function | MediumTest | Level2)
294 {
295 IBufferProducer::RequestBufferReturnValue retval1;
296 IBufferProducer::RequestBufferReturnValue retval2;
297 IBufferProducer::RequestBufferReturnValue retval3;
298 GSError ret;
299
300 // not alloc
301 ret = bq->RequestBuffer(requestConfig, bedata, retval1);
302 ASSERT_EQ(ret, OHOS::GSERROR_OK);
303 ASSERT_GE(retval1.sequence, 0);
304 ASSERT_EQ(retval1.buffer, nullptr);
305
306 // alloc
307 ret = bq->RequestBuffer(requestConfig, bedata, retval2);
308 ASSERT_EQ(ret, OHOS::GSERROR_OK);
309 ASSERT_GE(retval2.sequence, 0);
310 ASSERT_NE(retval2.buffer, nullptr);
311
312 cache[retval2.sequence] = retval2.buffer;
313
314 // no buffer
315 ret = bq->RequestBuffer(requestConfig, bedata, retval3);
316 ASSERT_NE(ret, OHOS::GSERROR_OK);
317 ASSERT_EQ(retval3.buffer, nullptr);
318
319 ret = bq->CancelBuffer(retval1.sequence, bedata);
320 ASSERT_EQ(ret, OHOS::GSERROR_OK);
321
322 ret = bq->CancelBuffer(retval2.sequence, bedata);
323 ASSERT_EQ(ret, OHOS::GSERROR_OK);
324
325 ret = bq->CancelBuffer(retval3.sequence, bedata);
326 ASSERT_NE(ret, OHOS::GSERROR_OK);
327 }
328
329 /*
330 * Function: RequestBuffer, ReleaseBuffer and FlushBuffer
331 * Type: Function
332 * Rank: Important(2)
333 * EnvConditions: N/A
334 * CaseDescription: 1. call RequestBuffer
335 * 2. call ReleaseBuffer
336 * 3. call FlushBuffer
337 * 4. check ret
338 */
339 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel007, Function | MediumTest | Level2)
340 {
341 IBufferProducer::RequestBufferReturnValue retval;
342
343 // not alloc
344 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
345 ASSERT_EQ(ret, OHOS::GSERROR_OK);
346 ASSERT_GE(retval.sequence, 0);
347 ASSERT_EQ(retval.buffer, nullptr);
348
349 retval.buffer = cache[retval.sequence];
350
351 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
352 ret = bq->ReleaseBuffer(retval.buffer, releaseFence);
353 ASSERT_NE(ret, OHOS::GSERROR_OK);
354
355 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
356 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
357 ASSERT_EQ(ret, OHOS::GSERROR_OK);
358 }
359
360 /*
361 * Function: AcquireBuffer, FlushBuffer and ReleaseBuffer
362 * Type: Function
363 * Rank: Important(2)
364 * EnvConditions: N/A
365 * CaseDescription: 1. call AcquireBuffer
366 * 2. call FlushBuffer
367 * 3. call ReleaseBuffer
368 * 4. check ret
369 */
370 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel008, Function | MediumTest | Level2)
371 {
372 sptr<SurfaceBuffer> buffer;
373 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
374
375 // acq from last test
376 GSError ret = bq->AcquireBuffer(buffer, acquireFence, timestamp, damages);
377 ASSERT_EQ(ret, OHOS::GSERROR_OK);
378
379 uint32_t sequence;
380 for (auto it = cache.begin(); it != cache.end(); it++) {
381 if (it->second.GetRefPtr() == buffer.GetRefPtr()) {
382 sequence = it->first;
383 }
384 }
385 ASSERT_GE(sequence, 0);
386
387 ret = bq->FlushBuffer(sequence, bedata, acquireFence, flushConfig);
388 ASSERT_NE(ret, OHOS::GSERROR_OK);
389
390 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
391 ret = bq->ReleaseBuffer(buffer, releaseFence);
392 ASSERT_EQ(ret, OHOS::GSERROR_OK);
393 }
394
395 /*
396 * Function: RequestBuffer and CancelBuffer
397 * Type: Function
398 * Rank: Important(2)
399 * EnvConditions: N/A
400 * CaseDescription: 1. call RequestBuffer
401 * 2. call CancelBuffer
402 * 3. check retval and ret
403 */
404 HWTEST_F(BufferQueueTest, ReqCanFluAcqRel009, Function | MediumTest | Level2)
405 {
406 IBufferProducer::RequestBufferReturnValue retval;
407 BufferRequestConfig deleteconfig = requestConfig;
408 deleteconfig.width = 1921;
409
410 GSError ret = bq->RequestBuffer(deleteconfig, bedata, retval);
411 ASSERT_EQ(ret, OHOS::GSERROR_OK);
412 ASSERT_EQ(retval.deletingBuffers.size(), 1u);
413 ASSERT_GE(retval.sequence, 0);
414 ASSERT_NE(retval.buffer, nullptr);
415
416 ret = bq->CancelBuffer(retval.sequence, bedata);
417 ASSERT_EQ(ret, OHOS::GSERROR_OK);
418 }
419
420 /*
421 * Function: RequestBuffer
422 * Type: Function
423 * Rank: Important(2)
424 * EnvConditions: N/A
425 * CaseDescription: 1. set BufferRequestConfig with abnormal value
426 * 2. call RequestBuffer
427 * 3. check ret
428 */
429 HWTEST_F(BufferQueueTest, RequestBuffer001, Function | MediumTest | Level2)
430 {
431 IBufferProducer::RequestBufferReturnValue retval;
432 BufferRequestConfig config = requestConfig;
433 config.width = -1;
434
435 GSError ret = bq->RequestBuffer(config, bedata, retval);
436 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
437 }
438
439 /*
440 * Function: RequestBuffer
441 * Type: Function
442 * Rank: Important(2)
443 * EnvConditions: N/A
444 * CaseDescription: 1. set BufferRequestConfig with abnormal value
445 * 2. call RequestBuffer
446 * 3. check ret
447 */
448 HWTEST_F(BufferQueueTest, RequestBuffer002, Function | MediumTest | Level2)
449 {
450 IBufferProducer::RequestBufferReturnValue retval;
451 BufferRequestConfig config = requestConfig;
452 config.height = -1;
453
454 GSError ret = bq->RequestBuffer(config, bedata, retval);
455 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
456 }
457
458
459 /*
460 * Function: RequestBuffer
461 * Type: Function
462 * Rank: Important(2)
463 * EnvConditions: N/A
464 * CaseDescription: 1. set BufferRequestConfig with abnormal value
465 * 2. call RequestBuffer
466 * 3. check ret
467 */
468 HWTEST_F(BufferQueueTest, RequestBuffer003, Function | MediumTest | Level2)
469 {
470 IBufferProducer::RequestBufferReturnValue retval;
471 BufferRequestConfig config = requestConfig;
472 config.strideAlignment = SURFACE_MIN_STRIDE_ALIGNMENT - 1;
473
474 GSError ret = bq->RequestBuffer(config, bedata, retval);
475 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
476 }
477
478 /*
479 * Function: RequestBuffer
480 * Type: Function
481 * Rank: Important(2)
482 * EnvConditions: N/A
483 * CaseDescription: 1. set BufferRequestConfig with abnormal value
484 * 2. call RequestBuffer
485 * 3. check ret
486 */
487 HWTEST_F(BufferQueueTest, RequestBuffer004, Function | MediumTest | Level2)
488 {
489 IBufferProducer::RequestBufferReturnValue retval;
490 BufferRequestConfig config = requestConfig;
491 config.strideAlignment = SURFACE_MAX_STRIDE_ALIGNMENT + 1;
492
493 GSError ret = bq->RequestBuffer(config, bedata, retval);
494 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
495 }
496
497 /*
498 * Function: RequestBuffer
499 * Type: Function
500 * Rank: Important(2)
501 * EnvConditions: N/A
502 * CaseDescription: 1. set BufferRequestConfig with abnormal value
503 * 2. call RequestBuffer
504 * 3. check ret
505 */
506 HWTEST_F(BufferQueueTest, RequestBuffer005, Function | MediumTest | Level2)
507 {
508 IBufferProducer::RequestBufferReturnValue retval;
509 BufferRequestConfig config = requestConfig;
510 config.strideAlignment = 3;
511
512 GSError ret = bq->RequestBuffer(config, bedata, retval);
513 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
514 }
515
516 /*
517 * Function: RequestBuffer
518 * Type: Function
519 * Rank: Important(2)
520 * EnvConditions: N/A
521 * CaseDescription: 1. set BufferRequestConfig with abnormal value
522 * 2. call RequestBuffer
523 * 3. check ret
524 */
525 HWTEST_F(BufferQueueTest, RequestBuffer006, Function | MediumTest | Level2)
526 {
527 IBufferProducer::RequestBufferReturnValue retval;
528 BufferRequestConfig config = requestConfig;
529 config.format = -1;
530
531 GSError ret = bq->RequestBuffer(config, bedata, retval);
532 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
533 }
534
535 /*
536 * Function: QueryIfBufferAvailable
537 * Type: Function
538 * Rank: Important(2)
539 * EnvConditions: N/A
540 * CaseDescription: 1. call QueryIfBufferAvailable and check ret
541 */
542 HWTEST_F(BufferQueueTest, QueryIfBufferAvailable001, Function | MediumTest | Level2)
543 {
544 bq->CleanCache();
545 bool ret = bq->QueryIfBufferAvailable();
546 ASSERT_EQ(ret, true);
547
548 GSError reqRet = OHOS::GSERROR_OK;
549 IBufferProducer::RequestBufferReturnValue retval;
550 BufferRequestConfig config = requestConfig;
551 while (reqRet != OHOS::GSERROR_NO_BUFFER) {
552 reqRet = bq->RequestBuffer(config, bedata, retval);
553 }
554
555 ret = bq->QueryIfBufferAvailable();
556 ASSERT_EQ(ret, false);
557 }
558
559 /*
560 * Function: GetName
561 * Type: Function
562 * Rank: Important(2)
563 * EnvConditions: N/A
564 * CaseDescription: 1. call GetName and check ret
565 */
566 HWTEST_F(BufferQueueTest, GetName001, Function | MediumTest | Level2)
567 {
568 std::string name("na");
569 GSError ret = bq->GetName(name);
570 ASSERT_EQ(ret, GSERROR_OK);
571 ASSERT_NE(name, "na");
572 }
573
574 /*
575 * Function: RegisterConsumerListener
576 * Type: Function
577 * Rank: Important(2)
578 * EnvConditions: N/A
579 * CaseDescription: 1. call RegisterConsumerListener and check ret
580 */
581 HWTEST_F(BufferQueueTest, RegisterConsumerListener001, Function | MediumTest | Level2)
582 {
583 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
584 GSError ret = bq->RegisterConsumerListener(listener);
585 ASSERT_EQ(ret, GSERROR_OK);
586 }
587
588 /*
589 * Function: SetDefaultWidthAndHeight
590 * Type: Function
591 * Rank: Important(2)
592 * EnvConditions: N/A
593 * CaseDescription: 1. call SetDefaultWidthAndHeight and check ret
594 */
595 HWTEST_F(BufferQueueTest, SetDefaultWidthAndHeight001, Function | MediumTest | Level2)
596 {
597 int width = 0;
598 int height = 0;
599 GSError ret = bq->SetDefaultWidthAndHeight(width, height);
600 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
601
602 width = 1;
603 ret = bq->SetDefaultWidthAndHeight(width, height);
604 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
605
606 width = 80;
607 height = 80;
608 ret = bq->SetDefaultWidthAndHeight(width, height);
609 ASSERT_EQ(ret, GSERROR_OK);
610 }
611
612 /*
613 * Function: GetDefaultWidth and GetDefaultHeight
614 * Type: Function
615 * Rank: Important(2)
616 * EnvConditions: N/A
617 * CaseDescription: 1. call GetDefaultWidth and check ret
618 */
619 HWTEST_F(BufferQueueTest, GetDefaultWidth001, Function | MediumTest | Level2)
620 {
621 int32_t width = 80;
622 int32_t height = 80;
623 GSError ret = bq->SetDefaultWidthAndHeight(width, height);
624 ASSERT_EQ(ret, GSERROR_OK);
625
626 ASSERT_EQ(width, bq->GetDefaultWidth());
627 ASSERT_EQ(height, bq->GetDefaultHeight());
628 }
629
630 /*
631 * Function: SetDefaultUsage and GetDefaultUsage
632 * Type: Function
633 * Rank: Important(2)
634 * EnvConditions: N/A
635 * CaseDescription: 1. call SetDefaultUsage and check ret
636 */
637 HWTEST_F(BufferQueueTest, SetDefaultUsage001, Function | MediumTest | Level2)
638 {
639 uint64_t usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA;
640 GSError ret = bq->SetDefaultUsage(usage);
641 ASSERT_EQ(ret, GSERROR_OK);
642 ASSERT_EQ(usage, bq->GetDefaultUsage());
643 }
644
645 /*
646 * Function: CleanCache
647 * Type: Function
648 * Rank: Important(2)
649 * EnvConditions: N/A
650 * CaseDescription: 1. call CleanCache and check ret
651 */
652 HWTEST_F(BufferQueueTest, CleanCache001, Function | MediumTest | Level2)
653 {
654 GSError ret = bq->CleanCache();
655 ASSERT_EQ(ret, GSERROR_OK);
656 }
657 }
658