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  */
HWTEST_F(BufferQueueProducerTest, QueueSize001, Function | MediumTest | Level2)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  */
HWTEST_F(BufferQueueProducerTest, Status001, Function | MediumTest | Level2)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  */
HWTEST_F(BufferQueueProducerTest, ReqCan001, Function | MediumTest | Level2)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  */
HWTEST_F(BufferQueueProducerTest, ReqCan002, Function | MediumTest | Level2)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  */
HWTEST_F(BufferQueueProducerTest, ReqCan003, Function | MediumTest | Level2)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  */
HWTEST_F(BufferQueueProducerTest, ReqFlu001, Function | MediumTest | Level2)216 HWTEST_F(BufferQueueProducerTest, ReqFlu001, Function | MediumTest | Level2)
217 {
218     IBufferProducer::RequestBufferReturnValue retval;
219     GSError ret = bqp_->RequestBuffer(requestConfig, bedata_, retval);
220     EXPECT_EQ(ret, OHOS::GSERROR_OK);
221 
222     sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
223     ret = bqp_->FlushBuffer(retval.sequence, bedata_, acquireFence, flushConfig);
224     EXPECT_EQ(ret, OHOS::GSERROR_OK);
225 
226     ret = bq_->AcquireBuffer(retval.buffer, retval.fence, timestamp_, damages_);
227     ASSERT_EQ(ret, OHOS::GSERROR_OK);
228 
229     sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
230     ret = bq_->ReleaseBuffer(retval.buffer, releaseFence);
231     ASSERT_EQ(ret, OHOS::GSERROR_OK);
232 }
233 
234 /*
235 * Function: RequestBuffer, FlushBuffer, AcquireBuffer and ReleaseBuffer
236 * Type: Function
237 * Rank: Important(2)
238 * EnvConditions: N/A
239 * CaseDescription: 1. call RequestBuffer and FlushBuffer
240 *                  2. call FlushBuffer again
241 *                  3. call AcquireBuffer and ReleaseBuffer
242 *                  4. check ret
243  */
HWTEST_F(BufferQueueProducerTest, ReqFlu002, Function | MediumTest | Level2)244 HWTEST_F(BufferQueueProducerTest, ReqFlu002, Function | MediumTest | Level2)
245 {
246     IBufferProducer::RequestBufferReturnValue retval;
247     GSError ret = bqp_->RequestBuffer(requestConfig, bedata_, retval);
248     ASSERT_EQ(ret, OHOS::GSERROR_OK);
249 
250     sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
251     ret = bqp_->FlushBuffer(retval.sequence, bedata_, acquireFence, flushConfig);
252     ASSERT_EQ(ret, OHOS::GSERROR_OK);
253 
254     ret = bqp_->FlushBuffer(retval.sequence, bedata_, acquireFence, flushConfig);
255     ASSERT_NE(ret, OHOS::GSERROR_OK);
256 
257     ret = bq_->AcquireBuffer(retval.buffer, retval.fence, timestamp_, damages_);
258     ASSERT_EQ(ret, OHOS::GSERROR_OK);
259 
260     sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
261     ret = bq_->ReleaseBuffer(retval.buffer, releaseFence);
262     ASSERT_EQ(ret, OHOS::GSERROR_OK);
263 
264     int32_t timeOut = 1;
265     ret = bqp_->AttachBuffer(retval.buffer, timeOut);
266     ASSERT_EQ(ret, OHOS::GSERROR_OK);
267 }
268 
269 /*
270 * Function: AttachBuffer and DetachBuffer
271 * Type: Function
272 * Rank: Important(2)
273 * EnvConditions: N/A
274 * CaseDescription: 1. call AttachBuffer and DetachBuffer
275 * 4. check ret
276 */
HWTEST_F(BufferQueueProducerTest, AttachAndDetachBuffer001, Function | MediumTest | Level2)277 HWTEST_F(BufferQueueProducerTest, AttachAndDetachBuffer001, Function | MediumTest | Level2)
278 {
279     IBufferProducer::RequestBufferReturnValue retVal;
280     sptr<SurfaceBuffer> &buffer = retVal.buffer;
281 
282     sptr<BufferQueue> bufferQueue = nullptr;
283     sptr<BufferQueueProducer> bqpTmp = new BufferQueueProducer(bufferQueue);
284 
285     GSError ret = bqpTmp->AttachBuffer(buffer);
286     ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
287     ret = bqpTmp->DetachBuffer(buffer);
288     ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
289     bqpTmp = nullptr;
290 }
291 
292 /*
293 * Function: AttachAndDetachBufferRemote
294 * Type: Function
295 * Rank: Important(2)
296 * EnvConditions: N/A
297 * CaseDescription: 1. call AttachBufferRemote, DetachBufferRemote
298 * 4. check ret
299 */
HWTEST_F(BufferQueueProducerTest, AttachAndDetachBufferRemote, Function | MediumTest | Level2)300 HWTEST_F(BufferQueueProducerTest, AttachAndDetachBufferRemote, Function | MediumTest | Level2)
301 {
302     MessageParcel arguments;
303     arguments.WriteInt32(5); // write sequence
304     MessageParcel reply;
305     reply.WriteInt32(6);
306     MessageOption option;
307     int32_t ret = bqp_->AttachBufferRemote(arguments, reply, option);
308     ASSERT_EQ(ret, ERR_INVALID_DATA);
309     ret = bqp_->DetachBufferRemote(arguments, reply, option);
310     ASSERT_EQ(ret, ERR_NONE);
311 }
312 
313 /*
314 * Function: SetTunnelHandle
315 * Type: Function
316 * Rank: Important(2)
317 * EnvConditions: N/A
318 * CaseDescription: 1. call SetTunnelHandle
319 * 4. check ret
320 */
HWTEST_F(BufferQueueProducerTest, SetTunnelHandle, Function | MediumTest | Level2)321 HWTEST_F(BufferQueueProducerTest, SetTunnelHandle, Function | MediumTest | Level2)
322 {
323     EXPECT_EQ(bqp_->SetTunnelHandle(nullptr), GSERROR_OK);
324     GraphicExtDataHandle *handle = static_cast<GraphicExtDataHandle *>(
325         malloc(sizeof(GraphicExtDataHandle) + sizeof(int32_t)));
326     handle->fd = -1;
327     handle->reserveInts = 1;
328     handle->reserve[0] = 0;
329     GSError ret = bqp_->SetTunnelHandle(handle);
330     EXPECT_EQ(ret, GSERROR_NO_ENTRY);
331     free(handle);
332 }
333 
334 /*
335 * Function: SetTunnelHandleRemote
336 * Type: Function
337 * Rank: Important(2)
338 * EnvConditions: N/A
339 * CaseDescription: 1. call SetTunnelHandleRemote
340 * 4. check ret
341 */
HWTEST_F(BufferQueueProducerTest, SetTunnelHandleRemote, Function | MediumTest | Level2)342 HWTEST_F(BufferQueueProducerTest, SetTunnelHandleRemote, Function | MediumTest | Level2)
343 {
344     MessageParcel arguments;
345     arguments.WriteInt32(5);
346     MessageParcel reply;
347     reply.WriteInt32(6);
348     MessageOption option;
349     int32_t ret = bqp_->SetTunnelHandleRemote(arguments, reply, option);
350     EXPECT_EQ(ret, ERR_NONE);
351 }
352 
353 /*
354 * Function: GetPresentTimestampRemote
355 * Type: Function
356 * Rank: Important(2)
357 * EnvConditions: N/A
358 * CaseDescription: 1. call GetPresentTimestampRemote
359 * 4. check ret
360 */
HWTEST_F(BufferQueueProducerTest, GetPresentTimestampRemote, Function | MediumTest | Level2)361 HWTEST_F(BufferQueueProducerTest, GetPresentTimestampRemote, Function | MediumTest | Level2)
362 {
363     MessageParcel arguments;
364     arguments.WriteInt32(5);
365     MessageParcel reply;
366     reply.WriteInt32(6);
367     MessageOption option;
368     int32_t ret = bqp_->GetPresentTimestampRemote(arguments, reply, option);
369     EXPECT_EQ(ret, ERR_NONE);
370 }
371 
372 /*
373 * Function: SetSurfaceSourceType and GetSurfaceSourceType
374 * Type: Function
375 * Rank: Important(2)
376 * EnvConditions: N/A
377 * CaseDescription: 1. call GetSurfaceSourceType for default
378 *                  2. call SetSurfaceSourceType and check the ret
379 */
HWTEST_F(BufferQueueProducerTest, SurfaceSourceType001, Function | MediumTest | Level2)380 HWTEST_F(BufferQueueProducerTest, SurfaceSourceType001, Function | MediumTest | Level2)
381 {
382     OHSurfaceSource sourceType;
383     GSError ret = bqp_->GetSurfaceSourceType(sourceType);
384     ASSERT_EQ(ret, OHOS::GSERROR_OK);
385     ASSERT_EQ(sourceType, OH_SURFACE_SOURCE_DEFAULT);
386 
387     ret = bqp_->SetSurfaceSourceType(OH_SURFACE_SOURCE_VIDEO);
388     ASSERT_EQ(ret, OHOS::GSERROR_OK);
389     bqp_->GetSurfaceSourceType(sourceType);
390     ASSERT_EQ(sourceType, OH_SURFACE_SOURCE_VIDEO);
391 }
392 
393 /*
394 * Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
395 * Type: Function
396 * Rank: Important(2)
397 * EnvConditions: N/A
398 * CaseDescription: 1. call GetSurfaceAppFrameworkType for default
399 *                  2. call SetSurfaceAppFrameworkType and check the ret
400 */
HWTEST_F(BufferQueueProducerTest, SurfaceAppFrameworkType001, Function | MediumTest | Level2)401 HWTEST_F(BufferQueueProducerTest, SurfaceAppFrameworkType001, Function | MediumTest | Level2)
402 {
403     std::string appFrameworkType;
404     bqp_->GetSurfaceAppFrameworkType(appFrameworkType);
405     ASSERT_EQ(appFrameworkType, "");
406 
407     GSError ret = bqp_->SetSurfaceAppFrameworkType("test");
408     ASSERT_EQ(ret, OHOS::GSERROR_OK);
409     bqp_->GetSurfaceAppFrameworkType(appFrameworkType);
410     ASSERT_EQ(appFrameworkType, "test");
411 }
412 
413 /*
414 * Function: SetSurfaceSourceTypeRemote
415 * Type: Function
416 * Rank: Important(2)
417 * EnvConditions: N/A
418 * CaseDescription: 1. call SetSurfaceSourceTypeRemote
419 * 4. check ret
420 */
HWTEST_F(BufferQueueProducerTest, SetSurfaceSourceTypeRemote001, Function | MediumTest | Level2)421 HWTEST_F(BufferQueueProducerTest, SetSurfaceSourceTypeRemote001, Function | MediumTest | Level2)
422 {
423     MessageParcel arguments;
424     arguments.WriteInt32(1);
425     MessageParcel reply;
426     reply.WriteInt32(6);
427     MessageOption option;
428     int32_t ret = bqp_->SetSurfaceSourceTypeRemote(arguments, reply, option);
429     EXPECT_EQ(ret, ERR_NONE);
430 }
431 
432 /*
433 * Function: GetSurfaceSourceTypeRemote
434 * Type: Function
435 * Rank: Important(2)
436 * EnvConditions: N/A
437 * CaseDescription: 1. call GetSurfaceSourceTypeRemote
438 * 4. check ret
439 */
HWTEST_F(BufferQueueProducerTest, GetSurfaceSourceTypeRemote001, Function | MediumTest | Level2)440 HWTEST_F(BufferQueueProducerTest, GetSurfaceSourceTypeRemote001, Function | MediumTest | Level2)
441 {
442     MessageParcel arguments;
443     arguments.WriteInt32(5);
444     MessageParcel reply;
445     reply.WriteInt32(6);
446     MessageOption option;
447     int32_t ret = bqp_->GetSurfaceSourceTypeRemote(arguments, reply, option);
448     EXPECT_EQ(ret, ERR_NONE);
449 }
450 
451 /*
452 * Function: SetSurfaceAppFrameworkTypeRemote
453 * Type: Function
454 * Rank: Important(2)
455 * EnvConditions: N/A
456 * CaseDescription: 1. call SetSurfaceAppFrameworkTypeRemote
457 * 4. check ret
458 */
HWTEST_F(BufferQueueProducerTest, SetSurfaceAppFrameworkTypeRemote001, Function | MediumTest | Level2)459 HWTEST_F(BufferQueueProducerTest, SetSurfaceAppFrameworkTypeRemote001, Function | MediumTest | Level2)
460 {
461     MessageParcel arguments;
462     arguments.WriteString("test");
463     MessageParcel reply;
464     reply.WriteInt32(6);
465     MessageOption option;
466     int32_t ret = bqp_->SetSurfaceAppFrameworkTypeRemote(arguments, reply, option);
467     EXPECT_EQ(ret, ERR_NONE);
468 }
469 
470 /*
471 * Function: GetSurfaceAppFrameworkTypeRemote
472 * Type: Function
473 * Rank: Important(2)
474 * EnvConditions: N/A
475 * CaseDescription: 1. call GetSurfaceAppFrameworkTypeRemote
476 * 4. check ret
477 */
HWTEST_F(BufferQueueProducerTest, GetSurfaceAppFrameworkTypeRemote001, Function | MediumTest | Level2)478 HWTEST_F(BufferQueueProducerTest, GetSurfaceAppFrameworkTypeRemote001, Function | MediumTest | Level2)
479 {
480     MessageParcel arguments;
481     arguments.WriteInt32(5);
482     MessageParcel reply;
483     reply.WriteInt32(6);
484     MessageOption option;
485     int32_t ret = bqp_->GetSurfaceAppFrameworkTypeRemote(arguments, reply, option);
486     EXPECT_EQ(ret, ERR_NONE);
487 }
488 
489 /*
490 * Function: SetWhitePointBrightness
491 * Type: Function
492 * Rank: Important(2)
493 * EnvConditions: N/A
494 * CaseDescription: 1. call SetHdrWhitePointBrightness, SetSdrWhitePointBrightness
495 *                  2. check ret
496 */
HWTEST_F(BufferQueueProducerTest, SetWhitePointBrightness001, Function | MediumTest | Level2)497 HWTEST_F(BufferQueueProducerTest, SetWhitePointBrightness001, Function | MediumTest | Level2)
498 {
499     MessageParcel arguments;
500     arguments.WriteFloat(1);
501     MessageParcel reply;
502     MessageOption option;
503     int32_t ret = bqp_->SetHdrWhitePointBrightnessRemote(arguments, reply, option);
504     EXPECT_EQ(ret, ERR_NONE);
505     ret = bqp_->SetSdrWhitePointBrightnessRemote(arguments, reply, option);
506     EXPECT_EQ(ret, ERR_NONE);
507 }
508 
509 /*
510 * Function: SetDefaultUsage
511 * Type: Function
512 * Rank: Important(2)
513 * EnvConditions: N/A
514 * CaseDescription: 1. call SetDefaultUsage
515 *                  2. check ret
516 */
HWTEST_F(BufferQueueProducerTest, SetDefaultUsage001, Function | MediumTest | Level2)517 HWTEST_F(BufferQueueProducerTest, SetDefaultUsage001, Function | MediumTest | Level2)
518 {
519     MessageParcel arguments;
520     arguments.WriteUint64(0);
521     MessageParcel reply;
522     MessageOption option;
523     int32_t ret = bqp_->SetDefaultUsageRemote(arguments, reply, option);
524     EXPECT_EQ(ret, ERR_NONE);
525 }
526 
527 /*
528 * Function: SetBufferHold
529 * Type: Function
530 * Rank: Important(2)
531 * EnvConditions: N/A
532 * CaseDescription: 1. call SetBufferHold
533 *                  2. check ret
534 */
HWTEST_F(BufferQueueProducerTest, SetBufferHold001, Function | MediumTest | Level2)535 HWTEST_F(BufferQueueProducerTest, SetBufferHold001, Function | MediumTest | Level2)
536 {
537     MessageParcel arguments;
538     arguments.WriteBool(false);
539     MessageParcel reply;
540     MessageOption option;
541     int32_t ret = bqp_->SetBufferHoldRemote(arguments, reply, option);
542     EXPECT_EQ(ret, ERR_NONE);
543 }
544 
545 /*
546 * Function: TransformHint
547 * Type: Function
548 * Rank: Important(2)
549 * EnvConditions: N/A
550 * CaseDescription: 1. call TransformHint
551 *                  2. check ret
552 */
HWTEST_F(BufferQueueProducerTest, TransformHint001, Function | MediumTest | Level2)553 HWTEST_F(BufferQueueProducerTest, TransformHint001, Function | MediumTest | Level2)
554 {
555     GraphicTransformType transform = GraphicTransformType::GRAPHIC_FLIP_H;
556 
557     MessageParcel arguments;
558     arguments.WriteUint32(transform);
559     MessageParcel reply;
560     MessageOption option;
561     int32_t ret = bqp_->SetBufferHoldRemote(arguments, reply, option);
562     EXPECT_EQ(ret, ERR_NONE);
563     int32_t err = reply.ReadInt32();
564     EXPECT_EQ(err, OHOS::GSERROR_OK);
565 
566     ret = bqp_->GetTransformHintRemote(arguments, reply, option);
567     EXPECT_EQ(ret, ERR_NONE);
568     err = reply.ReadInt32();
569     EXPECT_EQ(err, OHOS::GSERROR_OK);
570 }
571 
572 
573 /*
574 * Function: BufferQueueProducer member function nullptr test
575 * Type: Function
576 * Rank: Important(2)
577 * EnvConditions: N/A
578 * CaseDescription: BufferQueueProducer member function nullptr test
579  */
HWTEST_F(BufferQueueProducerTest, NullTest, Function | MediumTest | Level2)580 HWTEST_F(BufferQueueProducerTest, NullTest, Function | MediumTest | Level2)
581 {
582     sptr<BufferQueue> bqTmp = nullptr;
583     sptr<BufferQueueProducer> bqpTmp = new BufferQueueProducer(bqTmp);
584     IBufferProducer::RequestBufferReturnValue retval;
585     GSError ret = bqpTmp->RequestBuffer(requestConfig, bedata_, retval);
586     EXPECT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
587     ret = bqpTmp->CancelBuffer(retval.sequence, bedata_);
588     EXPECT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
589     sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
590     ret = bqpTmp->FlushBuffer(retval.sequence, bedata_, acquireFence, flushConfig);
591     EXPECT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
592     ret = bqpTmp->GetLastFlushedBuffer(retval.buffer, acquireFence, nullptr, false);
593     EXPECT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
594     EXPECT_EQ(bqpTmp->AttachBuffer(retval.buffer), OHOS::GSERROR_INVALID_ARGUMENTS);
595     EXPECT_EQ(bqpTmp->DetachBuffer(retval.buffer), OHOS::GSERROR_INVALID_ARGUMENTS);
596     EXPECT_EQ(bqpTmp->GetQueueSize(), 0);
597     EXPECT_EQ(bqpTmp->SetQueueSize(0), OHOS::GSERROR_INVALID_ARGUMENTS);
598     std::string name = "test";
599     EXPECT_EQ(bqpTmp->GetName(name), OHOS::GSERROR_INVALID_ARGUMENTS);
600     EXPECT_EQ(bqpTmp->GetDefaultWidth(), 0);
601     EXPECT_EQ(bqpTmp->GetDefaultHeight(), 0);
602     EXPECT_EQ(bqpTmp->GetDefaultUsage(), 0);
603     EXPECT_EQ(bqpTmp->GetUniqueId(), 0);
604     sptr<IProducerListener> listener = nullptr;
605     EXPECT_EQ(bqpTmp->RegisterReleaseListener(listener), OHOS::GSERROR_INVALID_ARGUMENTS);
606     EXPECT_EQ(bqpTmp->UnRegisterReleaseListener(), OHOS::GSERROR_INVALID_ARGUMENTS);
607     EXPECT_EQ(bqpTmp->SetTransform(GraphicTransformType::GRAPHIC_FLIP_H), OHOS::GSERROR_INVALID_ARGUMENTS);
608     std::vector<BufferVerifyAllocInfo> infos;
609     std::vector<bool> supporteds;
610     EXPECT_EQ(bqpTmp->IsSupportedAlloc(infos, supporteds), OHOS::GSERROR_INVALID_ARGUMENTS);
611     uint64_t uniqueId;
612     EXPECT_EQ(bqpTmp->GetNameAndUniqueId(name, uniqueId), OHOS::GSERROR_INVALID_ARGUMENTS);
613     EXPECT_EQ(bqpTmp->Disconnect(), OHOS::SURFACE_ERROR_UNKOWN);
614     EXPECT_EQ(bqpTmp->SetScalingMode(0, ScalingMode::SCALING_MODE_FREEZE), OHOS::GSERROR_INVALID_ARGUMENTS);
615     EXPECT_EQ(bqpTmp->SetScalingMode(ScalingMode::SCALING_MODE_FREEZE), OHOS::GSERROR_INVALID_ARGUMENTS);
616     std::vector<GraphicHDRMetaData> meta;
617     EXPECT_EQ(bqpTmp->SetMetaData(0, meta), OHOS::GSERROR_INVALID_ARGUMENTS);
618     std::vector<uint8_t> metaData;
619     EXPECT_EQ(bqpTmp->SetMetaDataSet(0, GraphicHDRMetadataKey::GRAPHIC_MATAKEY_BLUE_PRIMARY_X,
620         metaData), OHOS::GSERROR_INVALID_ARGUMENTS);
621     sptr<SurfaceTunnelHandle> handle = nullptr;
622     EXPECT_EQ(bqpTmp->SetTunnelHandle(handle), OHOS::GSERROR_INVALID_ARGUMENTS);
623     int64_t time = 0;
624     EXPECT_EQ(bqpTmp->GetPresentTimestamp(0, GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_DELAY,
625         time), OHOS::GSERROR_INVALID_ARGUMENTS);
626     EXPECT_EQ(bqpTmp->GetStatus(), false);
627     bqpTmp->SetStatus(false);
628     EXPECT_EQ(bqpTmp->AcquireLastFlushedBuffer(retval.buffer, acquireFence, nullptr, 0, false),
629         OHOS::SURFACE_ERROR_UNKOWN);
630     EXPECT_EQ(bqpTmp->ReleaseLastFlushedBuffer(0), OHOS::SURFACE_ERROR_UNKOWN);
631     bqpTmp->OnBufferProducerRemoteDied();
632     EXPECT_EQ(bqpTmp->SetBufferHold(false), OHOS::GSERROR_INVALID_ARGUMENTS);
633     EXPECT_EQ(bqpTmp->SetSdrWhitePointBrightness(1), OHOS::SURFACE_ERROR_UNKOWN);
634     EXPECT_EQ(bqpTmp->SetHdrWhitePointBrightness(1), OHOS::SURFACE_ERROR_UNKOWN);
635     EXPECT_EQ(bqpTmp->SetSurfaceAppFrameworkType(name), OHOS::GSERROR_INVALID_ARGUMENTS);
636     EXPECT_EQ(bqpTmp->GetSurfaceAppFrameworkType(name), OHOS::GSERROR_INVALID_ARGUMENTS);
637     OHSurfaceSource sourceType = OH_SURFACE_SOURCE_DEFAULT;
638     EXPECT_EQ(bqpTmp->SetSurfaceSourceType(sourceType), OHOS::GSERROR_INVALID_ARGUMENTS);
639     EXPECT_EQ(bqpTmp->GetSurfaceSourceType(sourceType), OHOS::GSERROR_INVALID_ARGUMENTS);
640     GraphicTransformType transform = GraphicTransformType::GRAPHIC_FLIP_H;
641     EXPECT_EQ(bqpTmp->SetTransformHint(transform), OHOS::GSERROR_INVALID_ARGUMENTS);
642     EXPECT_EQ(bqpTmp->GetTransformHint(transform), OHOS::GSERROR_INVALID_ARGUMENTS);
643     EXPECT_EQ(bqpTmp->GoBackground(), OHOS::GSERROR_INVALID_ARGUMENTS);
644     EXPECT_EQ(bqpTmp->CleanCache(true), OHOS::GSERROR_INVALID_ARGUMENTS);
645     EXPECT_EQ(bqpTmp->SetDefaultUsage(0), OHOS::GSERROR_INVALID_ARGUMENTS);
646     EXPECT_EQ(bqpTmp->AttachBufferToQueue(nullptr), OHOS::SURFACE_ERROR_UNKOWN);
647     EXPECT_EQ(bqpTmp->DetachBufferFromQueue(nullptr), OHOS::SURFACE_ERROR_UNKOWN);
648     ProducerInitInfo info;
649     EXPECT_EQ(bqpTmp->GetProducerInitInfo(info), OHOS::SURFACE_ERROR_UNKOWN);
650     vector<uint32_t> sequences;
651     vector<sptr<SyncFence>> fences;
652     vector<sptr<BufferExtraData>> bedata;
653     vector<BufferFlushConfigWithDamages> damages;
654     vector<BufferQueueProducer::RequestBufferReturnValue> retvalues;
655     BufferRequestConfig config;
656     EXPECT_EQ(bqpTmp->RequestBuffers(config, bedata, retvalues), OHOS::SURFACE_ERROR_UNKOWN);
657     EXPECT_EQ(bqpTmp->FlushBuffers(sequences, bedata, fences, damages), OHOS::SURFACE_ERROR_UNKOWN);
658     EXPECT_EQ(bqpTmp->SetGlobalAlpha(-1), OHOS::SURFACE_ERROR_UNKOWN);
659     bqTmp = nullptr;
660     bqpTmp = nullptr;
661 }
662 }
663