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 <gtest/gtest.h>
16 #include <surface.h>
17 #include <buffer_extra_data_impl.h>
18 #include <buffer_queue_producer.h>
19 #include "buffer_consumer_listener.h"
20 #include "consumer_surface.h"
21 #include "frame_report.h"
22 #include "sync_fence.h"
23 #include "producer_surface_delegator.h"
24 
25 using namespace testing;
26 using namespace testing::ext;
27 
28 namespace OHOS::Rosen {
29 class BufferQueueProducerTest : public testing::Test {
30 public:
SetUpTestCase()31     static void SetUpTestCase() {}
TearDownTestCase()32     static void TearDownTestCase() {}
33     void SetUp();
34     void TearDown();
35 
36     static inline BufferRequestConfig requestConfig = {
37         .width = 0x100,
38         .height = 0x100,
39         .strideAlignment = 0x8,
40         .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
41         .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
42         .timeout = 0,
43     };
44     static inline BufferFlushConfigWithDamages flushConfig = {
45         .damages = {
46             {
47                 .w = 0x100,
48                 .h = 0x100,
49             }
50         },
51     };
52 protected:
53     int64_t timestamp_ = 0;
54     std::vector<Rect> damages_ = {};
55     sptr<BufferQueueProducer> bqp_ = nullptr;
56     sptr<BufferQueue> bq_ = nullptr;
57     sptr<BufferExtraData> bedata_ = nullptr;
58 };
59 
60 
SetUp()61 void BufferQueueProducerTest::SetUp()
62 {
63     bq_ = new BufferQueue("test");
64     sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
65     bq_->RegisterConsumerListener(listener);
66     if (bqp_ == nullptr) {
67         bqp_ = new BufferQueueProducer(bq_);
68     }
69     if (bedata_ == nullptr) {
70         bedata_ = new OHOS::BufferExtraDataImpl;
71     }
72 }
73 
TearDown()74 void BufferQueueProducerTest::TearDown()
75 {
76     damages_.clear();
77     std::vector<Rect> tmp;
78     std::swap(damages_, tmp);
79     if (bqp_ != nullptr) {
80         bqp_->SetStatus(false);
81         bqp_ = nullptr;
82     }
83     bq_ = nullptr;
84     if (bedata_ != nullptr) {
85         bedata_ = nullptr;
86     }
87 }
88 
89 /*
90 * Function: SetQueueSize and GetQueueSize
91 * Type: Function
92 * Rank: Important(2)
93 * EnvConditions: N/A
94 * CaseDescription: 1. call GetQueueSize and get default value
95 *                  2. call SetQueueSize
96 *                  3. call SetQueueSize again with abnormal value
97 *                  4. call GetQueueSize for BufferQueueProducer and BufferQueue
98 *                  5. check ret
99  */
100 HWTEST_F(BufferQueueProducerTest, QueueSize001, Function | MediumTest | Level2)
101 {
102     ASSERT_EQ(bqp_->GetQueueSize(), (uint32_t)SURFACE_DEFAULT_QUEUE_SIZE);
103 
104     GSError ret = bqp_->SetQueueSize(2);
105     ASSERT_EQ(ret, OHOS::GSERROR_OK);
106 
107     ret = bqp_->SetQueueSize(SURFACE_MAX_QUEUE_SIZE + 1);
108     EXPECT_NE(ret, OHOS::GSERROR_OK);
109 
110     EXPECT_EQ(bqp_->GetQueueSize(), 2u);
111     EXPECT_EQ(bq_->GetQueueSize(), 2u);
112 }
113 
114 /*
115 * Function: SetStatus and GetStatus
116 * Type: Function
117 * Rank: Important(2)
118 * EnvConditions: N/A
119 * CaseDescription: 1. call SetStatus with false and check get status value
120 *                  2. call SetStatus with true and check get status value
121  */
122 HWTEST_F(BufferQueueProducerTest, Status001, Function | MediumTest | Level2)
123 {
124     bqp_->SetStatus(false);
125     EXPECT_EQ(bqp_->GetStatus(), false);
126     bqp_->SetStatus(true);
127     EXPECT_EQ(bqp_->GetStatus(), true);
128 }
129 
130 /*
131 * Function: RequestBuffer and CancelBuffer
132 * Type: Function
133 * Rank: Important(2)
134 * EnvConditions: N/A
135 * CaseDescription: 1. call RequestBuffer
136 *                  2. call CancelBuffer
137 *                  3. check ret
138  */
139 HWTEST_F(BufferQueueProducerTest, ReqCan001, Function | MediumTest | Level2)
140 {
141     IBufferProducer::RequestBufferReturnValue retval;
142     GSError ret = bqp_->RequestBuffer(requestConfig, bedata_, retval);
143     ASSERT_EQ(ret, OHOS::GSERROR_OK);
144 
145     ret = bqp_->CancelBuffer(retval.sequence, bedata_);
146     ASSERT_EQ(ret, OHOS::GSERROR_OK);
147 }
148 
149 /*
150 * Function: RequestBuffer and CancelBuffer
151 * Type: Function
152 * Rank: Important(2)
153 * EnvConditions: N/A
154 * CaseDescription: 1. call RequestBuffer
155 *                  2. call CancelBuffer 2 times
156 *                  3. check ret
157  */
158 HWTEST_F(BufferQueueProducerTest, ReqCan002, Function | MediumTest | Level2)
159 {
160     IBufferProducer::RequestBufferReturnValue retval;
161     GSError ret = bqp_->RequestBuffer(requestConfig, bedata_, retval);
162     ASSERT_EQ(ret, OHOS::GSERROR_OK);
163 
164     ret = bqp_->CancelBuffer(retval.sequence, bedata_);
165     ASSERT_EQ(ret, OHOS::GSERROR_OK);
166 
167     ret = bqp_->CancelBuffer(retval.sequence, bedata_);
168     ASSERT_NE(ret, OHOS::GSERROR_OK);
169 }
170 
171 /*
172 * Function: RequestBuffer, and CancelBuffer
173 * Type: Function
174 * Rank: Important(2)
175 * EnvConditions: N/A
176 * CaseDescription: 1. call RequestBuffer and CancelBuffer by different retval
177 *                  2. check ret
178  */
179 HWTEST_F(BufferQueueProducerTest, ReqCan003, Function | MediumTest | Level2)
180 {
181     IBufferProducer::RequestBufferReturnValue retval1;
182     IBufferProducer::RequestBufferReturnValue retval2;
183     IBufferProducer::RequestBufferReturnValue retval3;
184 
185     auto ret = bqp_->RequestBuffer(requestConfig, bedata_, retval1);
186     ASSERT_EQ(ret, OHOS::GSERROR_OK);
187     EXPECT_NE(retval1.buffer, nullptr);
188 
189     ret = bqp_->RequestBuffer(requestConfig, bedata_, retval2);
190     EXPECT_EQ(ret, OHOS::GSERROR_OK);
191     EXPECT_NE(retval2.buffer, nullptr);
192 
193     ret = bqp_->RequestBuffer(requestConfig, bedata_, retval3);
194     EXPECT_EQ(ret, OHOS::GSERROR_OK);
195     EXPECT_NE(retval3.buffer, nullptr);
196 
197     ret = bqp_->CancelBuffer(retval1.sequence, bedata_);
198     EXPECT_EQ(ret, OHOS::GSERROR_OK);
199 
200     ret = bqp_->CancelBuffer(retval2.sequence, bedata_);
201     EXPECT_EQ(ret, OHOS::GSERROR_OK);
202 
203     ret = bqp_->CancelBuffer(retval3.sequence, bedata_);
204     EXPECT_EQ(ret, OHOS::GSERROR_OK);
205 }
206 
207 /*
208 * Function: RequestBuffer, FlushBuffer, AcquireBuffer and ReleaseBuffer
209 * Type: Function
210 * Rank: Important(2)
211 * EnvConditions: N/A
212 * CaseDescription: 1. call RequestBuffer and FlushBuffer
213 *                  2. call AcquireBuffer and ReleaseBuffer
214 *                  3. check ret
215  */
216 HWTEST_F(BufferQueueProducerTest, ReqFlu001, Function | MediumTest | Level2)
217 {
218     Rosen::FrameReport::GetInstance().SetGameScene(1, 1);
219     IBufferProducer::RequestBufferReturnValue retval;
220     GSError ret = bqp_->RequestBuffer(requestConfig, bedata_, retval);
221     EXPECT_EQ(ret, OHOS::GSERROR_OK);
222 
223     sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
224     ret = bqp_->FlushBuffer(retval.sequence, bedata_, acquireFence, flushConfig);
225     EXPECT_EQ(ret, OHOS::GSERROR_OK);
226 
227     ret = bq_->AcquireBuffer(retval.buffer, retval.fence, timestamp_, damages_);
228     ASSERT_EQ(ret, OHOS::GSERROR_OK);
229 
230     sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
231     ret = bq_->ReleaseBuffer(retval.buffer, releaseFence);
232     ASSERT_EQ(ret, OHOS::GSERROR_OK);
233 }
234 
235 /*
236 * Function: RequestBuffer, FlushBuffer, AcquireBuffer and ReleaseBuffer
237 * Type: Function
238 * Rank: Important(2)
239 * EnvConditions: N/A
240 * CaseDescription: 1. call RequestBuffer and FlushBuffer
241 *                  2. call FlushBuffer again
242 *                  3. call AcquireBuffer and ReleaseBuffer
243 *                  4. check ret
244  */
245 HWTEST_F(BufferQueueProducerTest, ReqFlu002, Function | MediumTest | Level2)
246 {
247     IBufferProducer::RequestBufferReturnValue retval;
248     GSError ret = bqp_->RequestBuffer(requestConfig, bedata_, retval);
249     ASSERT_EQ(ret, OHOS::GSERROR_OK);
250 
251     sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
252     ret = bqp_->FlushBuffer(retval.sequence, bedata_, acquireFence, flushConfig);
253     ASSERT_EQ(ret, OHOS::GSERROR_OK);
254 
255     ret = bqp_->FlushBuffer(retval.sequence, bedata_, acquireFence, flushConfig);
256     ASSERT_NE(ret, OHOS::GSERROR_OK);
257 
258     ret = bq_->AcquireBuffer(retval.buffer, retval.fence, timestamp_, damages_);
259     ASSERT_EQ(ret, OHOS::GSERROR_OK);
260 
261     sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
262     ret = bq_->ReleaseBuffer(retval.buffer, releaseFence);
263     ASSERT_EQ(ret, OHOS::GSERROR_OK);
264 
265     int32_t timeOut = 1;
266     ret = bqp_->AttachBuffer(retval.buffer, timeOut);
267     ASSERT_EQ(ret, OHOS::GSERROR_OK);
268 }
269 
270 /*
271 * Function: AttachBuffer and DetachBuffer
272 * Type: Function
273 * Rank: Important(2)
274 * EnvConditions: N/A
275 * CaseDescription: 1. call AttachBuffer and DetachBuffer
276 * 4. check ret
277 */
278 HWTEST_F(BufferQueueProducerTest, AttachAndDetachBuffer001, Function | MediumTest | Level2)
279 {
280     IBufferProducer::RequestBufferReturnValue retVal;
281     sptr<SurfaceBuffer> &buffer = retVal.buffer;
282 
283     sptr<BufferQueue> bufferQueue = nullptr;
284     sptr<BufferQueueProducer> bqpTmp = new BufferQueueProducer(bufferQueue);
285 
286     GSError ret = bqpTmp->AttachBuffer(buffer);
287     ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
288     ret = bqpTmp->DetachBuffer(buffer);
289     ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
290     bqpTmp = nullptr;
291 }
292 
293 /*
294 * Function: AttachAndDetachBufferRemote
295 * Type: Function
296 * Rank: Important(2)
297 * EnvConditions: N/A
298 * CaseDescription: 1. call AttachBufferRemote, DetachBufferRemote
299 * 4. check ret
300 */
301 HWTEST_F(BufferQueueProducerTest, AttachAndDetachBufferRemote, Function | MediumTest | Level2)
302 {
303     MessageParcel arguments;
304     arguments.WriteInt32(5);
305     MessageParcel reply;
306     reply.WriteInt32(6);
307     MessageOption option;
308     int32_t ret = bqp_->AttachBufferRemote(arguments, reply, option);
309     ASSERT_EQ(ret, 0);
310     ret = bqp_->DetachBufferRemote(arguments, reply, option);
311     ASSERT_EQ(ret, 0);
312 }
313 
314 /*
315 * Function: SetTunnelHandle
316 * Type: Function
317 * Rank: Important(2)
318 * EnvConditions: N/A
319 * CaseDescription: 1. call SetTunnelHandle
320 * 4. check ret
321 */
322 HWTEST_F(BufferQueueProducerTest, SetTunnelHandle, Function | MediumTest | Level2)
323 {
324     EXPECT_EQ(bqp_->SetTunnelHandle(nullptr), GSERROR_OK);
325     GraphicExtDataHandle *handle = static_cast<GraphicExtDataHandle *>(
326         malloc(sizeof(GraphicExtDataHandle) + sizeof(int32_t)));
327     handle->fd = -1;
328     handle->reserveInts = 1;
329     handle->reserve[0] = 0;
330     GSError ret = bqp_->SetTunnelHandle(handle);
331     EXPECT_EQ(ret, GSERROR_NO_ENTRY);
332     free(handle);
333 }
334 
335 /*
336 * Function: SetTunnelHandleRemote
337 * Type: Function
338 * Rank: Important(2)
339 * EnvConditions: N/A
340 * CaseDescription: 1. call SetTunnelHandleRemote
341 * 4. check ret
342 */
343 HWTEST_F(BufferQueueProducerTest, SetTunnelHandleRemote, Function | MediumTest | Level2)
344 {
345     MessageParcel arguments;
346     arguments.WriteInt32(5);
347     MessageParcel reply;
348     reply.WriteInt32(6);
349     MessageOption option;
350     int32_t ret = bqp_->SetTunnelHandleRemote(arguments, reply, option);
351     EXPECT_EQ(ret, 0);
352 }
353 
354 /*
355 * Function: GetPresentTimestampRemote
356 * Type: Function
357 * Rank: Important(2)
358 * EnvConditions: N/A
359 * CaseDescription: 1. call GetPresentTimestampRemote
360 * 4. check ret
361 */
362 HWTEST_F(BufferQueueProducerTest, GetPresentTimestampRemote, Function | MediumTest | Level2)
363 {
364     MessageParcel arguments;
365     arguments.WriteInt32(5);
366     MessageParcel reply;
367     reply.WriteInt32(6);
368     MessageOption option;
369     int32_t ret = bqp_->GetPresentTimestampRemote(arguments, reply, option);
370     EXPECT_EQ(ret, 0);
371 }
372 
373 /*
374 * Function: SetSurfaceSourceType and GetSurfaceSourceType
375 * Type: Function
376 * Rank: Important(2)
377 * EnvConditions: N/A
378 * CaseDescription: 1. call GetSurfaceSourceType for default
379 *                  2. call SetSurfaceSourceType and check the ret
380 */
381 HWTEST_F(BufferQueueProducerTest, SurfaceSourceType001, Function | MediumTest | Level2)
382 {
383     OHSurfaceSource sourceType;
384     GSError ret = bqp_->GetSurfaceSourceType(sourceType);
385     ASSERT_EQ(ret, OHOS::GSERROR_OK);
386     ASSERT_EQ(sourceType, OH_SURFACE_SOURCE_DEFAULT);
387 
388     ret = bqp_->SetSurfaceSourceType(OH_SURFACE_SOURCE_VIDEO);
389     ASSERT_EQ(ret, OHOS::GSERROR_OK);
390     bqp_->GetSurfaceSourceType(sourceType);
391     ASSERT_EQ(sourceType, OH_SURFACE_SOURCE_VIDEO);
392 }
393 
394 /*
395 * Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
396 * Type: Function
397 * Rank: Important(2)
398 * EnvConditions: N/A
399 * CaseDescription: 1. call GetSurfaceAppFrameworkType for default
400 *                  2. call SetSurfaceAppFrameworkType and check the ret
401 */
402 HWTEST_F(BufferQueueProducerTest, SurfaceAppFrameworkType001, Function | MediumTest | Level2)
403 {
404     std::string appFrameworkType;
405     bqp_->GetSurfaceAppFrameworkType(appFrameworkType);
406     ASSERT_EQ(appFrameworkType, "");
407 
408     GSError ret = bqp_->SetSurfaceAppFrameworkType("test");
409     ASSERT_EQ(ret, OHOS::GSERROR_OK);
410     bqp_->GetSurfaceAppFrameworkType(appFrameworkType);
411     ASSERT_EQ(appFrameworkType, "test");
412 }
413 
414 /*
415 * Function: SetSurfaceSourceTypeRemote
416 * Type: Function
417 * Rank: Important(2)
418 * EnvConditions: N/A
419 * CaseDescription: 1. call SetSurfaceSourceTypeRemote
420 * 4. check ret
421 */
422 HWTEST_F(BufferQueueProducerTest, SetSurfaceSourceTypeRemote001, Function | MediumTest | Level2)
423 {
424     MessageParcel arguments;
425     arguments.WriteInt32(1);
426     MessageParcel reply;
427     reply.WriteInt32(6);
428     MessageOption option;
429     int32_t ret = bqp_->SetSurfaceSourceTypeRemote(arguments, reply, option);
430     EXPECT_EQ(ret, 0);
431 }
432 
433 /*
434 * Function: GetSurfaceSourceTypeRemote
435 * Type: Function
436 * Rank: Important(2)
437 * EnvConditions: N/A
438 * CaseDescription: 1. call GetSurfaceSourceTypeRemote
439 * 4. check ret
440 */
441 HWTEST_F(BufferQueueProducerTest, GetSurfaceSourceTypeRemote001, Function | MediumTest | Level2)
442 {
443     MessageParcel arguments;
444     arguments.WriteInt32(5);
445     MessageParcel reply;
446     reply.WriteInt32(6);
447     MessageOption option;
448     int32_t ret = bqp_->GetSurfaceSourceTypeRemote(arguments, reply, option);
449     EXPECT_EQ(ret, 0);
450 }
451 
452 /*
453 * Function: SetSurfaceAppFrameworkTypeRemote
454 * Type: Function
455 * Rank: Important(2)
456 * EnvConditions: N/A
457 * CaseDescription: 1. call SetSurfaceAppFrameworkTypeRemote
458 * 4. check ret
459 */
460 HWTEST_F(BufferQueueProducerTest, SetSurfaceAppFrameworkTypeRemote001, Function | MediumTest | Level2)
461 {
462     MessageParcel arguments;
463     arguments.WriteString("test");
464     MessageParcel reply;
465     reply.WriteInt32(6);
466     MessageOption option;
467     int32_t ret = bqp_->SetSurfaceAppFrameworkTypeRemote(arguments, reply, option);
468     EXPECT_EQ(ret, 0);
469 }
470 
471 /*
472 * Function: GetSurfaceAppFrameworkTypeRemote
473 * Type: Function
474 * Rank: Important(2)
475 * EnvConditions: N/A
476 * CaseDescription: 1. call GetSurfaceAppFrameworkTypeRemote
477 * 4. check ret
478 */
479 HWTEST_F(BufferQueueProducerTest, GetSurfaceAppFrameworkTypeRemote001, Function | MediumTest | Level2)
480 {
481     MessageParcel arguments;
482     arguments.WriteInt32(5);
483     MessageParcel reply;
484     reply.WriteInt32(6);
485     MessageOption option;
486     int32_t ret = bqp_->GetSurfaceAppFrameworkTypeRemote(arguments, reply, option);
487     EXPECT_EQ(ret, 0);
488 }
489 
490 /*
491 * Function: SetWhitePointBrightness
492 * Type: Function
493 * Rank: Important(2)
494 * EnvConditions: N/A
495 * CaseDescription: 1. call SetHdrWhitePointBrightness, SetSdrWhitePointBrightness
496 *                  2. check ret
497 */
498 HWTEST_F(BufferQueueProducerTest, SetWhitePointBrightness001, Function | MediumTest | Level2)
499 {
500     MessageParcel arguments;
501     arguments.WriteFloat(1);
502     MessageParcel reply;
503     MessageOption option;
504     int32_t ret = bqp_->SetHdrWhitePointBrightnessRemote(arguments, reply, option);
505     EXPECT_EQ(ret, 0);
506     ret = bqp_->SetSdrWhitePointBrightnessRemote(arguments, reply, option);
507     EXPECT_EQ(ret, 0);
508 }
509 
510 /*
511 * Function: SetDefaultUsage
512 * Type: Function
513 * Rank: Important(2)
514 * EnvConditions: N/A
515 * CaseDescription: 1. call SetDefaultUsage
516 *                  2. check ret
517 */
518 HWTEST_F(BufferQueueProducerTest, SetDefaultUsage001, Function | MediumTest | Level2)
519 {
520     MessageParcel arguments;
521     arguments.WriteUint64(0);
522     MessageParcel reply;
523     MessageOption option;
524     int32_t ret = bqp_->SetDefaultUsageRemote(arguments, reply, option);
525     EXPECT_EQ(ret, 0);
526 }
527 
528 /*
529 * Function: SetBufferHold
530 * Type: Function
531 * Rank: Important(2)
532 * EnvConditions: N/A
533 * CaseDescription: 1. call SetBufferHold
534 *                  2. check ret
535 */
536 HWTEST_F(BufferQueueProducerTest, SetBufferHold001, Function | MediumTest | Level2)
537 {
538     MessageParcel arguments;
539     arguments.WriteBool(false);
540     MessageParcel reply;
541     MessageOption option;
542     int32_t ret = bqp_->SetBufferHoldRemote(arguments, reply, option);
543     EXPECT_EQ(ret, 0);
544 }
545 
546 /*
547 * Function: TransformHint
548 * Type: Function
549 * Rank: Important(2)
550 * EnvConditions: N/A
551 * CaseDescription: 1. call TransformHint
552 *                  2. check ret
553 */
554 HWTEST_F(BufferQueueProducerTest, TransformHint001, Function | MediumTest | Level2)
555 {
556     GraphicTransformType transform = GraphicTransformType::GRAPHIC_FLIP_H;
557 
558     MessageParcel arguments;
559     arguments.WriteUint32(transform);
560     MessageParcel reply;
561     MessageOption option;
562     int32_t ret = bqp_->SetBufferHoldRemote(arguments, reply, option);
563     EXPECT_EQ(ret, 0);
564     int32_t err = reply.ReadInt32();
565     EXPECT_EQ(err, OHOS::GSERROR_OK);
566 
567     ret = bqp_->GetTransformHintRemote(arguments, reply, option);
568     EXPECT_EQ(ret, 0);
569     err = reply.ReadInt32();
570     EXPECT_EQ(err, OHOS::GSERROR_OK);
571 }
572 
573 
574 /*
575 * Function: BufferQueueProducer member function nullptr test
576 * Type: Function
577 * Rank: Important(2)
578 * EnvConditions: N/A
579 * CaseDescription: BufferQueueProducer member function nullptr test
580  */
581 HWTEST_F(BufferQueueProducerTest, NullTest, Function | MediumTest | Level2)
582 {
583     sptr<BufferQueue> bqTmp = nullptr;
584     sptr<BufferQueueProducer> bqpTmp = new BufferQueueProducer(bqTmp);
585     IBufferProducer::RequestBufferReturnValue retval;
586     GSError ret = bqpTmp->RequestBuffer(requestConfig, bedata_, retval);
587     EXPECT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
588     ret = bqpTmp->RequestAndDetachBuffer(requestConfig, bedata_, retval);
589     EXPECT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
590     ret = bqpTmp->CancelBuffer(retval.sequence, bedata_);
591     EXPECT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
592     sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
593     ret = bqpTmp->FlushBuffer(retval.sequence, bedata_, acquireFence, flushConfig);
594     EXPECT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
595     ret = bqpTmp->AttachAndFlushBuffer(retval.buffer, bedata_, acquireFence, flushConfig, true);
596     EXPECT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
597     ret = bqpTmp->GetLastFlushedBuffer(retval.buffer, acquireFence, nullptr, false);
598     EXPECT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
599     EXPECT_EQ(bqpTmp->AttachBuffer(retval.buffer), OHOS::GSERROR_INVALID_ARGUMENTS);
600     EXPECT_EQ(bqpTmp->DetachBuffer(retval.buffer), OHOS::GSERROR_INVALID_ARGUMENTS);
601     EXPECT_EQ(bqpTmp->GetQueueSize(), 0);
602     EXPECT_EQ(bqpTmp->SetQueueSize(0), OHOS::GSERROR_INVALID_ARGUMENTS);
603     std::string name = "test";
604     EXPECT_EQ(bqpTmp->GetName(name), OHOS::GSERROR_INVALID_ARGUMENTS);
605     EXPECT_EQ(bqpTmp->GetDefaultWidth(), 0);
606     EXPECT_EQ(bqpTmp->GetDefaultHeight(), 0);
607     EXPECT_EQ(bqpTmp->GetDefaultUsage(), 0);
608     EXPECT_EQ(bqpTmp->GetUniqueId(), 0);
609     sptr<IProducerListener> listener = nullptr;
610     EXPECT_EQ(bqpTmp->RegisterReleaseListener(listener), OHOS::GSERROR_INVALID_ARGUMENTS);
611     EXPECT_EQ(bqpTmp->UnRegisterReleaseListener(), OHOS::GSERROR_INVALID_ARGUMENTS);
612     EXPECT_EQ(bqpTmp->SetTransform(GraphicTransformType::GRAPHIC_FLIP_H), OHOS::GSERROR_INVALID_ARGUMENTS);
613     std::vector<BufferVerifyAllocInfo> infos;
614     std::vector<bool> supporteds;
615     EXPECT_EQ(bqpTmp->IsSupportedAlloc(infos, supporteds), OHOS::GSERROR_INVALID_ARGUMENTS);
616     uint64_t uniqueId;
617     EXPECT_EQ(bqpTmp->GetNameAndUniqueId(name, uniqueId), OHOS::GSERROR_INVALID_ARGUMENTS);
618     EXPECT_EQ(bqpTmp->Disconnect(), OHOS::SURFACE_ERROR_UNKOWN);
619     EXPECT_EQ(bqpTmp->SetScalingMode(0, ScalingMode::SCALING_MODE_FREEZE), OHOS::GSERROR_INVALID_ARGUMENTS);
620     EXPECT_EQ(bqpTmp->SetScalingMode(ScalingMode::SCALING_MODE_FREEZE), OHOS::GSERROR_INVALID_ARGUMENTS);
621     std::vector<GraphicHDRMetaData> meta;
622     EXPECT_EQ(bqpTmp->SetMetaData(0, meta), OHOS::GSERROR_INVALID_ARGUMENTS);
623     std::vector<uint8_t> metaData;
624     EXPECT_EQ(bqpTmp->SetMetaDataSet(0, GraphicHDRMetadataKey::GRAPHIC_MATAKEY_BLUE_PRIMARY_X,
625         metaData), OHOS::GSERROR_INVALID_ARGUMENTS);
626     sptr<SurfaceTunnelHandle> handle = nullptr;
627     EXPECT_EQ(bqpTmp->SetTunnelHandle(handle), OHOS::GSERROR_INVALID_ARGUMENTS);
628     int64_t time = 0;
629     EXPECT_EQ(bqpTmp->GetPresentTimestamp(0, GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_DELAY,
630         time), OHOS::GSERROR_INVALID_ARGUMENTS);
631     EXPECT_EQ(bqpTmp->GetStatus(), false);
632     bqpTmp->SetStatus(false);
633     EXPECT_EQ(bqpTmp->AcquireLastFlushedBuffer(retval.buffer, acquireFence, nullptr, 0, false),
634         OHOS::SURFACE_ERROR_UNKOWN);
635     EXPECT_EQ(bqpTmp->ReleaseLastFlushedBuffer(0), OHOS::SURFACE_ERROR_UNKOWN);
636     bqpTmp->OnBufferProducerRemoteDied();
637     EXPECT_EQ(bqpTmp->SetBufferHold(false), OHOS::GSERROR_INVALID_ARGUMENTS);
638     EXPECT_EQ(bqpTmp->SetSdrWhitePointBrightness(1), OHOS::SURFACE_ERROR_UNKOWN);
639     EXPECT_EQ(bqpTmp->SetHdrWhitePointBrightness(1), OHOS::SURFACE_ERROR_UNKOWN);
640     EXPECT_EQ(bqpTmp->SetSurfaceAppFrameworkType(name), OHOS::GSERROR_INVALID_ARGUMENTS);
641     EXPECT_EQ(bqpTmp->GetSurfaceAppFrameworkType(name), OHOS::GSERROR_INVALID_ARGUMENTS);
642     OHSurfaceSource sourceType = OH_SURFACE_SOURCE_DEFAULT;
643     EXPECT_EQ(bqpTmp->SetSurfaceSourceType(sourceType), OHOS::GSERROR_INVALID_ARGUMENTS);
644     EXPECT_EQ(bqpTmp->GetSurfaceSourceType(sourceType), OHOS::GSERROR_INVALID_ARGUMENTS);
645     GraphicTransformType transform = GraphicTransformType::GRAPHIC_FLIP_H;
646     EXPECT_EQ(bqpTmp->SetTransformHint(transform), OHOS::GSERROR_INVALID_ARGUMENTS);
647     EXPECT_EQ(bqpTmp->GetTransformHint(transform), OHOS::GSERROR_INVALID_ARGUMENTS);
648     EXPECT_EQ(bqpTmp->GoBackground(), OHOS::GSERROR_INVALID_ARGUMENTS);
649     EXPECT_EQ(bqpTmp->CleanCache(true), OHOS::GSERROR_INVALID_ARGUMENTS);
650     EXPECT_EQ(bqpTmp->SetDefaultUsage(0), OHOS::GSERROR_INVALID_ARGUMENTS);
651     EXPECT_EQ(bqpTmp->AttachBufferToQueue(nullptr), OHOS::SURFACE_ERROR_UNKOWN);
652     EXPECT_EQ(bqpTmp->DetachBufferFromQueue(nullptr), OHOS::SURFACE_ERROR_UNKOWN);
653     ProducerInitInfo info;
654     EXPECT_EQ(bqpTmp->GetProducerInitInfo(info), OHOS::SURFACE_ERROR_UNKOWN);
655     vector<uint32_t> sequences;
656     vector<sptr<SyncFence>> fences;
657     vector<sptr<BufferExtraData>> bedata;
658     vector<BufferFlushConfigWithDamages> damages;
659     vector<BufferQueueProducer::RequestBufferReturnValue> retvalues;
660     BufferRequestConfig config;
661     EXPECT_EQ(bqpTmp->RequestBuffers(config, bedata, retvalues), OHOS::SURFACE_ERROR_UNKOWN);
662     EXPECT_EQ(bqpTmp->FlushBuffers(sequences, bedata, fences, damages), OHOS::SURFACE_ERROR_UNKOWN);
663     bqTmp = nullptr;
664     bqpTmp = nullptr;
665 }
666 }
667