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 <securec.h>
16 #include <gtest/gtest.h>
17 #include <surface.h>
18 #include <consumer_surface.h>
19 #include <producer_surface.h>
20 #include "buffer_consumer_listener.h"
21 #include <native_window.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 ProducerSurfaceTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp() override;
34 void TearDown() override;
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 BufferFlushConfig flushConfig = {
45 .damage = {
46 .w = 0x100,
47 .h = 0x100,
48 },
49 };
50 static inline int64_t timestamp = 0;
51 static inline Rect damage = {};
52 static inline sptr<IConsumerSurface> csurf = nullptr;
53 static inline sptr<IBufferProducer> producer = nullptr;
54 static inline sptr<Surface> pSurface = nullptr;
55 static inline sptr<ProducerSurfaceDelegator> surfaceDelegator = nullptr;
56 static inline uint32_t firstSeqnum = 0;
57
OnBufferRelease(sptr<SurfaceBuffer> & buffer)58 static inline GSError OnBufferRelease(sptr<SurfaceBuffer> &buffer)
59 {
60 return GSERROR_OK;
61 }
62 sptr<ProducerSurface> surface_ = nullptr;
63 };
64
SetUpTestCase()65 void ProducerSurfaceTest::SetUpTestCase()
66 {
67 csurf = IConsumerSurface::Create();
68 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
69 csurf->RegisterConsumerListener(listener);
70 producer = csurf->GetProducer();
71 pSurface = Surface::CreateSurfaceAsProducer(producer);
72 pSurface->RegisterReleaseListener(OnBufferRelease);
73 }
74
TearDownTestCase()75 void ProducerSurfaceTest::TearDownTestCase()
76 {
77 pSurface->UnRegisterReleaseListener();
78 csurf = nullptr;
79 producer = nullptr;
80 pSurface = nullptr;
81 }
82
SetUp()83 void ProducerSurfaceTest::SetUp()
84 {
85 surface_ = new ProducerSurface(producer);
86 ASSERT_NE(surface_, nullptr);
87 surface_->producer_ = nullptr;
88 }
89
TearDown()90 void ProducerSurfaceTest::TearDown()
91 {
92 surface_ = nullptr;
93 }
94
95 /*
96 * Function: ProducerSurface
97 * Type: Function
98 * Rank: Important(2)
99 * EnvConditions: N/A
100 * CaseDescription: 1. check pSurface
101 */
102 HWTEST_F(ProducerSurfaceTest, ProducerSurface001, Function | MediumTest | Level2)
103 {
104 ASSERT_NE(pSurface, nullptr);
105 }
106
107 /*
108 * Function: GetProducerInitInfo
109 * Type: Function
110 * Rank: Important(2)
111 * EnvConditions: N/A
112 * CaseDescription: 1. check pSurface
113 */
114 HWTEST_F(ProducerSurfaceTest, GetProducerInitInfo001, Function | MediumTest | Level2)
115 {
116 ProducerInitInfo info;
117 GSError ret = surface_->GetProducerInitInfo(info);
118 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
119 }
120
121 /*
122 * Function: RequestBuffer
123 * Type: Function
124 * Rank: Important(2)
125 * EnvConditions: N/A
126 * CaseDescription: 1. call RequestBuffer with producer_ is nullptr
127 * 2. check ret
128 */
129 HWTEST_F(ProducerSurfaceTest, RequestBuffer001, Function | MediumTest | Level2)
130 {
131 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
132 int releaseFence = -1;
133 GSError ret = surface_->RequestBuffer(buffer, releaseFence, requestConfig);
134 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
135 }
136
137 /*
138 * Function: RequestBuffer
139 * Type: Function
140 * Rank: Important(2)
141 * EnvConditions: N/A
142 * CaseDescription: 1. call RequestBuffer with nullptr params
143 * 2. check ret
144 */
145 HWTEST_F(ProducerSurfaceTest, RequestBuffer002, Function | MediumTest | Level2)
146 {
147 sptr<SurfaceBuffer> buffer = nullptr;
148 int releaseFence = -1;
149 GSError ret = surface_->RequestBuffer(buffer, releaseFence, requestConfig);
150 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
151 }
152
153 /*
154 * Function: RequestBuffer
155 * Type: Function
156 * Rank: Important(2)
157 * EnvConditions: N/A
158 * CaseDescription: 1. call RequestBuffer with nullptr params
159 * 2. check ret
160 */
161 HWTEST_F(ProducerSurfaceTest, RequestBuffer003, Function | MediumTest | Level2)
162 {
163 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
164 sptr<SyncFence> releaseFence = nullptr;
165 GSError ret = surface_->RequestBuffer(buffer, releaseFence, requestConfig);
166 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
167 }
168
169 /*
170 * Function: RequestBuffer
171 * Type: Function
172 * Rank: Important(2)
173 * EnvConditions: N/A
174 * CaseDescription: 1. call RequestBuffer with nullptr params
175 * 2. check ret
176 */
177 HWTEST_F(ProducerSurfaceTest, RequestBuffer004, Function | MediumTest | Level2)
178 {
179 sptr<SurfaceBuffer> buffer = nullptr;
180 sptr<SyncFence> releaseFence = nullptr;
181 GSError ret = surface_->RequestBuffer(buffer, releaseFence, requestConfig);
182 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
183 }
184
185 /*
186 * Function: RequestBuffers
187 * Type: Function
188 * Rank: Important(2)
189 * EnvConditions: N/A
190 * CaseDescription: 1. call RequestBuffers with producer_ is nullptr
191 * 2. check ret
192 */
193 HWTEST_F(ProducerSurfaceTest, RequestBuffers001, Function | MediumTest | Level2)
194 {
195 std::vector<sptr<SurfaceBuffer>> sfbuffers;
196 std::vector<sptr<SyncFence>> releaseFences;
197 GSError ret = surface_->RequestBuffers(sfbuffers, releaseFences, requestConfig);
198 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
199 }
200
201 /*
202 * Function: FlushBuffer
203 * Type: Function
204 * Rank: Important(2)
205 * EnvConditions: N/A
206 * CaseDescription: 1. call FlushBuffer with producer_ is nullptr
207 * 2. check ret
208 */
209 HWTEST_F(ProducerSurfaceTest, FlushBuffer001, Function | MediumTest | Level2)
210 {
211 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
212 GSError ret = surface_->FlushBuffer(buffer, SyncFence::INVALID_FENCE, flushConfig);
213 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
214 }
215
216 /*
217 * Function: FlushBuffer
218 * Type: Function
219 * Rank: Important(2)
220 * EnvConditions: N/A
221 * CaseDescription: 1. call FlushBuffer with nullptr params
222 * 2. check ret
223 */
224 HWTEST_F(ProducerSurfaceTest, FlushBuffer002, Function | MediumTest | Level2)
225 {
226 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
227 GSError ret = surface_->FlushBuffer(buffer, nullptr, flushConfig);
228 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
229 }
230
231 /*
232 * Function: FlushBuffer
233 * Type: Function
234 * Rank: Important(2)
235 * EnvConditions: N/A
236 * CaseDescription: 1. call FlushBuffer with nullptr params
237 * 2. check ret
238 */
239 HWTEST_F(ProducerSurfaceTest, FlushBuffer003, Function | MediumTest | Level2)
240 {
241 sptr<SurfaceBuffer> buffer = nullptr;
242 GSError ret = surface_->FlushBuffer(buffer, SyncFence::INVALID_FENCE, flushConfig);
243 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
244 }
245
246 /*
247 * Function: FlushBuffers
248 * Type: Function
249 * Rank: Important(2)
250 * EnvConditions: N/A
251 * CaseDescription: 1. call FlushBuffers with producer_ is nullptr
252 * 2. check ret
253 */
254 HWTEST_F(ProducerSurfaceTest, FlushBuffers001, Function | MediumTest | Level2)
255 {
256 std::vector<sptr<SurfaceBuffer>> buffers;
257 buffers.push_back(SurfaceBuffer::Create());
258 std::vector<sptr<SyncFence>> flushFences;
259 std::vector<BufferFlushConfigWithDamages> configs;
260 GSError ret = surface_->FlushBuffers(buffers, flushFences, configs);
261 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
262 }
263
264 /*
265 * Function: GetLastFlushedBuffer
266 * Type: Function
267 * Rank: Important(2)
268 * EnvConditions: N/A
269 * CaseDescription: 1. call GetLastFlushedBuffer with producer_ is nullptr
270 * 2. check ret
271 */
272 HWTEST_F(ProducerSurfaceTest, GetLastFlushedBuffer001, Function | MediumTest | Level2)
273 {
274 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
275 sptr<SyncFence> fence;
276 float matrix[16];
277 GSError ret = surface_->GetLastFlushedBuffer(buffer, fence, matrix, false);
278 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
279 }
280
281 /*
282 * Function: CancelBuffer
283 * Type: Function
284 * Rank: Important(2)
285 * EnvConditions: N/A
286 * CaseDescription: 1. call CancelBuffer with producer_ is nullptr
287 * 2. check ret
288 */
289 HWTEST_F(ProducerSurfaceTest, CancelBuffer001, Function | MediumTest | Level2)
290 {
291 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
292 GSError ret = surface_->CancelBuffer(buffer);
293 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
294 }
295
296 /*
297 * Function: AttachBufferToQueue
298 * Type: Function
299 * Rank: Important(2)
300 * EnvConditions: N/A
301 * CaseDescription: 1. call AttachBufferToQueue with producer_ is nullptr
302 * 2. check ret
303 */
304 HWTEST_F(ProducerSurfaceTest, AttachBufferToQueue001, Function | MediumTest | Level2)
305 {
306 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
307 GSError ret = surface_->AttachBufferToQueue(buffer);
308 ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
309 }
310
311 /*
312 * Function: DetachBufferFromQueue
313 * Type: Function
314 * Rank: Important(2)
315 * EnvConditions: N/A
316 * CaseDescription: 1. call DetachBufferFromQueue with producer_ is nullptr
317 * 2. check ret
318 */
319 HWTEST_F(ProducerSurfaceTest, DetachBufferFromQueue001, Function | MediumTest | Level2)
320 {
321 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
322 GSError ret = surface_->DetachBufferFromQueue(buffer);
323 ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
324 }
325
326 /*
327 * Function: DetachBuffer
328 * Type: Function
329 * Rank: Important(2)
330 * EnvConditions: N/A
331 * CaseDescription: 1. call DetachBuffer with producer_ is nullptr
332 * 2. check ret
333 */
334 HWTEST_F(ProducerSurfaceTest, DetachBuffer001, Function | MediumTest | Level2)
335 {
336 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
337 GSError ret = surface_->DetachBuffer(buffer);
338 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
339 }
340
341 /*
342 * Function: SetQueueSize and GetQueueSize
343 * Type: Function
344 * Rank: Important(2)
345 * EnvConditions: N/A
346 * CaseDescription: 1. call GetQueueSize and get default value
347 * 2. call SetQueueSize
348 * 3. call SetQueueSize again with abnormal value
349 * 4. call GetQueueSize
350 * 5. check ret
351 */
352 HWTEST_F(ProducerSurfaceTest, QueueSize001, Function | MediumTest | Level2)
353 {
354 ASSERT_EQ(pSurface->GetQueueSize(), (uint32_t)SURFACE_DEFAULT_QUEUE_SIZE);
355 GSError ret = pSurface->SetQueueSize(2);
356 ASSERT_EQ(ret, OHOS::GSERROR_OK);
357
358 ret = pSurface->SetQueueSize(SURFACE_MAX_QUEUE_SIZE + 1);
359 ASSERT_NE(ret, OHOS::GSERROR_OK);
360
361 ASSERT_EQ(pSurface->GetQueueSize(), 2u);
362 }
363
364 /*
365 * Function: SetQueueSize and GetQueueSize
366 * Type: Function
367 * Rank: Important(2)
368 * EnvConditions: N/A
369 * CaseDescription: 1. call GetQueueSize with producer_ is nullptr and check ret
370 * 2. call SetQueueSize with producer_ is nullptr and check ret
371 */
372 HWTEST_F(ProducerSurfaceTest, QueueSize002, Function | MediumTest | Level2)
373 {
374 uint32_t queueSize = surface_->GetQueueSize();
375 ASSERT_EQ(queueSize, 0);
376 GSError ret = surface_->SetQueueSize(queueSize);
377 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
378 }
379
380 /*
381 * Function: GetDefaultWidth, GetDefaultHeight and SetDefaultWidthAndHeight
382 * Type: Function
383 * Rank: Important(2)
384 * EnvConditions: N/A
385 * CaseDescription: 1. call SetDefaultWidthAndHeight with producer_ is nullptr and check ret
386 * 2. call GetDefaultWidth with producer_ is nullptr and check ret
387 * 3. call GetDefaultHeight with producer_ is nullptr and check ret
388 */
389 HWTEST_F(ProducerSurfaceTest, DefaultWidthAndHeight001, Function | MediumTest | Level2)
390 {
391 GSError ret = surface_->SetDefaultWidthAndHeight(0, 0);
392 ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
393 int32_t width = surface_->GetDefaultWidth();
394 ASSERT_EQ(width, -1); // -1 is default width
395 int32_t height = surface_->GetDefaultHeight();
396 ASSERT_EQ(height, -1); // -1 is default height
397 }
398
399 /*
400 * Function: SetTransformHint and GetTransformHint
401 * Type: Function
402 * Rank: Important(2)
403 * EnvConditions: N/A
404 * CaseDescription: 1. call SetTransformHint with producer_ is nullptr and check ret
405 * 2. call GetTransformHint with producer_ is nullptr and check ret
406 */
407 HWTEST_F(ProducerSurfaceTest, TransformHint001, Function | MediumTest | Level2)
408 {
409 GSError ret = surface_->SetTransformHint(GraphicTransformType::GRAPHIC_ROTATE_NONE);
410 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
411 GraphicTransformType type = surface_->GetTransformHint();
412 ASSERT_EQ(type, GraphicTransformType::GRAPHIC_ROTATE_NONE);
413 }
414
415 /*
416 * Function: SetDefaultUsage and GetDefaultUsage
417 * Type: Function
418 * Rank: Important(2)
419 * EnvConditions: N/A
420 * CaseDescription: 1. call SetDefaultUsage with producer_ is nullptr and check ret
421 * 2. call GetDefaultUsage with producer_ is nullptr and check ret
422 */
423 HWTEST_F(ProducerSurfaceTest, DefaultUsage001, Function | MediumTest | Level2)
424 {
425 GSError ret = surface_->SetDefaultUsage(0);
426 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
427 uint64_t usage = surface_->GetDefaultUsage();
428 ASSERT_EQ(usage, 0);
429 }
430
431 /*
432 * Function: RequestBuffer and FlushBuffer
433 * Type: Function
434 * Rank: Important(2)
435 * EnvConditions: N/A
436 * CaseDescription: 1. call RequestBuffer
437 * 2. call FlushBuffer
438 * 3. check ret
439 */
440 HWTEST_F(ProducerSurfaceTest, ReqCanFluAcqRel001, Function | MediumTest | Level2)
441 {
442 sptr<SurfaceBuffer> buffer;
443
444 int releaseFence = -1;
445 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, requestConfig);
446 ASSERT_EQ(ret, OHOS::GSERROR_OK);
447 ASSERT_NE(buffer, nullptr);
448 firstSeqnum = buffer->GetSeqNum();
449
450 ret = pSurface->FlushBuffer(buffer, -1, flushConfig);
451 ASSERT_EQ(ret, OHOS::GSERROR_OK);
452 }
453
454 /*
455 * Function: RequestBuffer and FlushBuffer
456 * Type: Function
457 * Rank: Important(2)
458 * EnvConditions: N/A
459 * CaseDescription: 1. call RequestBuffer
460 * 2. call FlushBuffer 2 times
461 * 3. check ret
462 */
463 HWTEST_F(ProducerSurfaceTest, ReqCanFluAcqRel002, Function | MediumTest | Level2)
464 {
465 sptr<SurfaceBuffer> buffer;
466 int releaseFence = -1;
467
468 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, requestConfig);
469 ASSERT_EQ(ret, OHOS::GSERROR_OK);
470 ASSERT_NE(buffer, nullptr);
471
472 ret = pSurface->FlushBuffer(buffer, -1, flushConfig);
473 ASSERT_EQ(ret, OHOS::GSERROR_OK);
474
475 ret = pSurface->FlushBuffer(buffer, -1, flushConfig);
476 ASSERT_NE(ret, OHOS::GSERROR_OK);
477 }
478
479 /*
480 * Function: AcquireBuffer and ReleaseBuffer
481 * Type: Function
482 * Rank: Important(2)
483 * EnvConditions: N/A
484 * CaseDescription: 1. call AcquireBuffer and ReleaseBuffer many times
485 * 2. check ret
486 */
487 HWTEST_F(ProducerSurfaceTest, ReqCanFluAcqRel003, Function | MediumTest | Level2)
488 {
489 sptr<SurfaceBuffer> buffer;
490 int32_t flushFence;
491
492 GSError ret = csurf->AcquireBuffer(buffer, flushFence, timestamp, damage);
493 ASSERT_EQ(ret, OHOS::GSERROR_OK);
494
495 ret = csurf->ReleaseBuffer(buffer, -1);
496 ASSERT_EQ(ret, OHOS::GSERROR_OK);
497
498 ret = csurf->AcquireBuffer(buffer, flushFence, timestamp, damage);
499 ASSERT_EQ(ret, OHOS::GSERROR_OK);
500
501 ret = csurf->ReleaseBuffer(buffer, -1);
502 ASSERT_EQ(ret, OHOS::GSERROR_OK);
503 }
504
505 /*
506 * Function: RequestBuffer and CancelBuffer
507 * Type: Function
508 * Rank: Important(2)
509 * EnvConditions: N/A
510 * CaseDescription: 1. call RequestBuffer
511 * 2. call CancelBuffer
512 * 3. check ret
513 */
514 HWTEST_F(ProducerSurfaceTest, ReqCanFluAcqRel004, Function | MediumTest | Level2)
515 {
516 sptr<SurfaceBuffer> buffer;
517
518 int releaseFence = -1;
519 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, requestConfig);
520 ASSERT_EQ(ret, OHOS::GSERROR_OK);
521
522 ret = pSurface->CancelBuffer(buffer);
523 ASSERT_EQ(ret, OHOS::GSERROR_OK);
524 }
525
526 /*
527 * Function: RequestBuffer and CancelBuffer
528 * Type: Function
529 * Rank: Important(2)
530 * EnvConditions: N/A
531 * CaseDescription: 1. call RequestBuffer
532 * 2. call CancelBuffer 2 times
533 * 3. check ret
534 */
535 HWTEST_F(ProducerSurfaceTest, ReqCanFluAcqRel005, Function | MediumTest | Level2)
536 {
537 sptr<SurfaceBuffer> buffer;
538
539 int releaseFence = -1;
540 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, requestConfig);
541 ASSERT_EQ(ret, OHOS::GSERROR_OK);
542
543 ret = pSurface->CancelBuffer(buffer);
544 ASSERT_EQ(ret, OHOS::GSERROR_OK);
545
546 ret = pSurface->CancelBuffer(buffer);
547 ASSERT_NE(ret, OHOS::GSERROR_OK);
548 }
549
550 /*
551 * Function: RequestBuffer and CancelBuffer
552 * Type: Function
553 * Rank: Important(2)
554 * EnvConditions: N/A
555 * CaseDescription: 1. call RequestBuffer and CancelBuffer many times
556 * 2. check ret
557 */
558 HWTEST_F(ProducerSurfaceTest, ReqCanFluAcqRel006, Function | MediumTest | Level2)
559 {
560 sptr<SurfaceBuffer> buffer;
561 sptr<SurfaceBuffer> buffer1;
562 sptr<SurfaceBuffer> buffer2;
563 int releaseFence = -1;
564
565 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, requestConfig);
566 ASSERT_EQ(ret, OHOS::GSERROR_OK);
567
568 ret = pSurface->RequestBuffer(buffer1, releaseFence, requestConfig);
569 ASSERT_EQ(ret, OHOS::GSERROR_OK);
570
571 ret = pSurface->RequestBuffer(buffer2, releaseFence, requestConfig);
572 ASSERT_NE(ret, OHOS::GSERROR_OK);
573
574 ret = pSurface->CancelBuffer(buffer);
575 ASSERT_EQ(ret, OHOS::GSERROR_OK);
576
577 ret = pSurface->CancelBuffer(buffer1);
578 ASSERT_EQ(ret, OHOS::GSERROR_OK);
579
580 ret = pSurface->CancelBuffer(buffer2);
581 ASSERT_NE(ret, OHOS::GSERROR_OK);
582 }
583
584 /*
585 * Function: GetQueueSize and SetQueueSize
586 * Type: Function
587 * Rank: Important(2)
588 * EnvConditions: N/A
589 * CaseDescription: 1. call GetQeueSize
590 * 2. call SetQueueSize 2 times
591 * 3. check ret
592 */
593 HWTEST_F(ProducerSurfaceTest, SetQueueSizeDeleting001, Function | MediumTest | Level2)
594 {
595 sptr<ConsumerSurface> cs = static_cast<ConsumerSurface*>(csurf.GetRefPtr());
596 sptr<BufferQueueProducer> bqp = static_cast<BufferQueueProducer*>(cs->GetProducer().GetRefPtr());
597 ASSERT_EQ(bqp->GetQueueSize(), 2u);
598
599 GSError ret = pSurface->SetQueueSize(1);
600 ASSERT_EQ(ret, OHOS::GSERROR_OK);
601
602 ret = pSurface->SetQueueSize(2);
603 ASSERT_EQ(ret, OHOS::GSERROR_OK);
604 }
605
606 /*
607 * Function: RequestBuffer, ReleaseBuffer and CancelBuffer
608 * Type: Function
609 * Rank: Important(2)
610 * EnvConditions: N/A
611 * CaseDescription: 1. call RequestBuffer
612 * 2. call ReleaseBuffer
613 * 3. call CancelBuffer
614 * 4. check ret
615 */
616 HWTEST_F(ProducerSurfaceTest, ReqCanFluAcqRel007, Function | MediumTest | Level2)
617 {
618 sptr<SurfaceBuffer> buffer;
619
620 int releaseFence = -1;
621 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, requestConfig);
622 ASSERT_EQ(ret, OHOS::GSERROR_OK);
623
624 ret = pSurface->CancelBuffer(buffer);
625 ASSERT_EQ(ret, OHOS::GSERROR_OK);
626 }
627
628 /*
629 * Function: SetUserData and GetUserData
630 * Type: Function
631 * Rank: Important(2)
632 * EnvConditions: N/A
633 * CaseDescription: 1. call SetUserData and GetUserData many times
634 * 2. check ret
635 */
636 HWTEST_F(ProducerSurfaceTest, UserData001, Function | MediumTest | Level2)
637 {
638 GSError ret;
639
640 std::string strs[SURFACE_MAX_USER_DATA_COUNT];
641 constexpr int32_t stringLengthMax = 32;
642 char str[stringLengthMax] = {};
643 for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) {
644 auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%d", i);
645 ASSERT_GT(secRet, 0);
646
647 strs[i] = str;
648 ret = pSurface->SetUserData(strs[i], "magic");
649 ASSERT_EQ(ret, OHOS::GSERROR_OK);
650 }
651
652 ret = pSurface->SetUserData("-1", "error");
653 ASSERT_NE(ret, OHOS::GSERROR_OK);
654
655 std::string retStr;
656 for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) {
657 retStr = pSurface->GetUserData(strs[i]);
658 ASSERT_EQ(retStr, "magic");
659 }
660 }
661
662 /*
663 * Function: UserDataChangeListen
664 * Type: Function
665 * Rank: Important(2)
666 * EnvConditions: N/A
667 * CaseDescription: 1. RegisterUserDataChangeListen
668 * 2. SetUserData
669 * 3. check ret
670 */
671 HWTEST_F(ProducerSurfaceTest, UserDataChangeListen001, Function | MediumTest | Level2)
672 {
673 sptr<IConsumerSurface> csurfTestUserData = IConsumerSurface::Create();
674 sptr<IBufferConsumerListener> listenerTestUserData = new BufferConsumerListener();
675 csurfTestUserData->RegisterConsumerListener(listenerTestUserData);
676 sptr<IBufferProducer> producerTestUserData = csurf->GetProducer();
677 sptr<Surface> pSurfaceTestUserData = Surface::CreateSurfaceAsProducer(producerTestUserData);
678
679 GSError ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
680 GSError ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
__anona16cde430102(const std::string& key, const std::string& value) 681 auto func1 = [&ret1](const std::string& key, const std::string& value) {
682 ret1 = OHOS::GSERROR_OK;
683 };
__anona16cde430202(const std::string& key, const std::string& value) 684 auto func2 = [&ret2](const std::string& key, const std::string& value) {
685 ret2 = OHOS::GSERROR_OK;
686 };
687 pSurfaceTestUserData->RegisterUserDataChangeListener("func1", func1);
688 pSurfaceTestUserData->RegisterUserDataChangeListener("func2", func2);
689 pSurfaceTestUserData->RegisterUserDataChangeListener("func3", nullptr);
690 ASSERT_EQ(pSurfaceTestUserData->RegisterUserDataChangeListener("func2", func2), OHOS::GSERROR_INVALID_ARGUMENTS);
691
692 if (pSurfaceTestUserData->SetUserData("Regist", "OK") == OHOS::GSERROR_OK) {
693 ASSERT_EQ(ret1, OHOS::GSERROR_OK);
694 ASSERT_EQ(ret2, OHOS::GSERROR_OK);
695 }
696
697 ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
698 ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
699 pSurfaceTestUserData->UnRegisterUserDataChangeListener("func1");
700 ASSERT_EQ(pSurfaceTestUserData->UnRegisterUserDataChangeListener("func1"), OHOS::GSERROR_INVALID_ARGUMENTS);
701
702 if (pSurfaceTestUserData->SetUserData("UnRegist", "INVALID") == OHOS::GSERROR_OK) {
703 ASSERT_EQ(ret1, OHOS::GSERROR_INVALID_ARGUMENTS);
704 ASSERT_EQ(ret2, OHOS::GSERROR_OK);
705 }
706
707 ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
708 ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
709 pSurfaceTestUserData->ClearUserDataChangeListener();
710 pSurfaceTestUserData->RegisterUserDataChangeListener("func1", func1);
711 if (pSurfaceTestUserData->SetUserData("Clear", "OK") == OHOS::GSERROR_OK) {
712 ASSERT_EQ(ret1, OHOS::GSERROR_OK);
713 ASSERT_EQ(ret2, OHOS::GSERROR_INVALID_ARGUMENTS);
714 }
715 }
716
717 /*
718 * Function: UserDataChangeListen
719 * Type: Function
720 * Rank: Important(2)
721 * EnvConditions: N/A
722 * CaseDescription: 1. RegisterUserDataChangeListen
723 * 2. SetUserData
724 * 3. check ret
725 */
726 HWTEST_F(ProducerSurfaceTest, UserDataChangeListen002, Function | MediumTest | Level2)
727 {
728 sptr<IConsumerSurface> csurfTestUserData = IConsumerSurface::Create();
729 sptr<IBufferConsumerListener> listenerTestUserData = new BufferConsumerListener();
730 csurfTestUserData->RegisterConsumerListener(listenerTestUserData);
731 sptr<IBufferProducer> producerTestUserData = csurf->GetProducer();
732 sptr<Surface> pSurfaceTestUserData = Surface::CreateSurfaceAsProducer(producerTestUserData);
733
__anona16cde430302(const std::string& FuncName) 734 auto func = [&pSurfaceTestUserData](const std::string& FuncName) {
735 constexpr int32_t RegisterListenerNum = 1000;
736 std::vector<GSError> ret(RegisterListenerNum, OHOS::GSERROR_INVALID_ARGUMENTS);
737 std::string strs[RegisterListenerNum];
738 constexpr int32_t stringLengthMax = 32;
739 char str[stringLengthMax] = {};
740 for (int i = 0; i < RegisterListenerNum; i++) {
741 auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%s%d", FuncName.c_str(), i);
742 ASSERT_GT(secRet, 0);
743 strs[i] = str;
744 ASSERT_EQ(pSurfaceTestUserData->RegisterUserDataChangeListener(strs[i], [i, &ret]
745 (const std::string& key, const std::string& value) {
746 ret[i] = OHOS::GSERROR_OK;
747 }), OHOS::GSERROR_OK);
748 }
749
750 if (pSurfaceTestUserData->SetUserData("Regist", FuncName) == OHOS::GSERROR_OK) {
751 for (int i = 0; i < RegisterListenerNum; i++) {
752 ASSERT_EQ(ret[i], OHOS::GSERROR_OK);
753 }
754 }
755
756 for (int i = 0; i < RegisterListenerNum; i++) {
757 pSurfaceTestUserData->UnRegisterUserDataChangeListener(strs[i]);
758 }
759 };
760
761 std::thread t1(func, "thread1");
762 std::thread t2(func, "thread2");
763 t1.join();
764 t2.join();
765 }
766
767 /*
768 * Function: GetUniqueId
769 * Type: Function
770 * Rank: Important(2)
771 * EnvConditions: N/A
772 * CaseDescription: 1. call GetUniqueId
773 * 2. check ret
774 */
775 HWTEST_F(ProducerSurfaceTest, UniqueId001, Function | MediumTest | Level2)
776 {
777 uint64_t uniqueId = pSurface->GetUniqueId();
778 ASSERT_NE(uniqueId, 0);
779 }
780
781 /*
782 * Function: SetTransform and GetTransform
783 * Type: Function
784 * Rank: Important(2)
785 * EnvConditions: N/A
786 * CaseDescription: 1. call GetTransform with default and check ret
787 */
788 HWTEST_F(ProducerSurfaceTest, transform001, Function | MediumTest | Level2)
789 {
790 GSError ret = pSurface->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_NONE);
791 ASSERT_EQ(ret, OHOS::GSERROR_OK);
792 }
793
794 /*
795 * Function: SetTransform and GetTransform
796 * Type: Function
797 * Rank: Important(1)
798 * EnvConditions: N/A
799 * CaseDescription: 1. call SetTransform with other parameters and check ret
800 */
801 HWTEST_F(ProducerSurfaceTest, transform002, Function | MediumTest | Level1)
802 {
803 GSError ret = pSurface->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_90);
804 ASSERT_EQ(ret, OHOS::GSERROR_OK);
805 }
806
807 /*
808 * Function: SetTransform and GetTransform
809 * Type: Function
810 * Rank: Important(1)
811 * EnvConditions: N/A
812 * CaseDescription: 1. call SetTransform with other parameters and check ret
813 */
814 HWTEST_F(ProducerSurfaceTest, transform003, Function | MediumTest | Level1)
815 {
816 GSError ret = pSurface->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_180);
817 ASSERT_EQ(ret, OHOS::GSERROR_OK);
818 }
819
820 /*
821 * Function: SetTransform and GetTransform
822 * Type: Function
823 * Rank: Important(1)
824 * EnvConditions: N/A
825 * CaseDescription: 1. call SetTransform with other parameters and check ret
826 */
827 HWTEST_F(ProducerSurfaceTest, transform004, Function | MediumTest | Level1)
828 {
829 GSError ret = pSurface->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_270);
830 ASSERT_EQ(ret, OHOS::GSERROR_OK);
831 }
832
833 /*
834 * Function: SetTransform and GetTransform
835 * Type: Function
836 * Rank: Important(1)
837 * EnvConditions: N/A
838 * CaseDescription: 1. call SetTransform with producer_ is nullptr and check ret
839 * 2. call GetTransform with producer_ is nullptr and check ret
840 */
841 HWTEST_F(ProducerSurfaceTest, transform005, Function | MediumTest | Level1)
842 {
843 GSError ret = surface_->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_270);
844 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
845 GraphicTransformType type = surface_->GetTransform();
846 ASSERT_EQ(type, GraphicTransformType::GRAPHIC_ROTATE_BUTT);
847 }
848
849 /*
850 * Function: IsSupportedAlloc
851 * Type: Function
852 * Rank: Important(2)
853 * EnvConditions: N/A
854 * CaseDescription: 1. call IsSupportedAlloc with abnormal parameters and check ret
855 */
856 HWTEST_F(ProducerSurfaceTest, isSupportedAlloc001, Function | MediumTest | Level2)
857 {
858 std::vector<BufferVerifyAllocInfo> infos;
859 std::vector<bool> supporteds;
860 GSError ret = pSurface->IsSupportedAlloc(infos, supporteds);
861 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
862 }
863
864 /*
865 * Function: IsSupportedAlloc
866 * Type: Function
867 * Rank: Important(2)
868 * EnvConditions: N/A
869 * CaseDescription: 1. call IsSupportedAlloc with abnormal parameters and check ret
870 */
871 HWTEST_F(ProducerSurfaceTest, isSupportedAlloc002, Function | MediumTest | Level2)
872 {
873 std::vector<BufferVerifyAllocInfo> infos;
874 std::vector<bool> supporteds;
875 GSError ret = pSurface->IsSupportedAlloc(infos, supporteds);
876 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
877
878 BufferVerifyAllocInfo info = {
879 .width = 0x100,
880 .height = 0x100,
881 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
882 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
883 };
884 infos.push_back(info);
885 info.format = GRAPHIC_PIXEL_FMT_YCRCB_420_SP;
886 infos.push_back(info);
887 info.format = GRAPHIC_PIXEL_FMT_YUV_422_I;
888 infos.push_back(info);
889
890 ret = pSurface->IsSupportedAlloc(infos, supporteds);
891 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
892 }
893
894 /*
895 * Function: IsSupportedAlloc
896 * Type: Function
897 * Rank: Important(1)
898 * EnvConditions: N/A
899 * CaseDescription: 1. call IsSupportedAlloc with normal parameters and check ret
900 */
901 HWTEST_F(ProducerSurfaceTest, isSupportedAlloc003, Function | MediumTest | Level1)
902 {
903 std::vector<BufferVerifyAllocInfo> infos;
904 std::vector<bool> supporteds;
905 BufferVerifyAllocInfo info = {
906 .width = 0x100,
907 .height = 0x100,
908 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
909 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
910 };
911 infos.push_back(info);
912 info.format = GRAPHIC_PIXEL_FMT_YCRCB_420_SP;
913 infos.push_back(info);
914 info.format = GRAPHIC_PIXEL_FMT_YUV_422_I;
915 infos.push_back(info);
916
917 supporteds.push_back(false);
918 supporteds.push_back(false);
919 supporteds.push_back(false);
920
921 GSError ret = pSurface->IsSupportedAlloc(infos, supporteds);
922 ASSERT_EQ(ret, OHOS::GSERROR_OK); // mock data result
923 ASSERT_EQ(supporteds[0], true); // mock data result
924 ASSERT_EQ(supporteds[1], true); // mock data result
925 ASSERT_EQ(supporteds[2], false); // mock data result
926 }
927
928 /*
929 * Function: IsSupportedAlloc
930 * Type: Function
931 * Rank: Important(2)
932 * EnvConditions: N/A
933 * CaseDescription: 1. call IsSupportedAlloc with producer_ is nullptr and check ret
934 */
935 HWTEST_F(ProducerSurfaceTest, isSupportedAlloc004, Function | MediumTest | Level2)
936 {
937 std::vector<BufferVerifyAllocInfo> infos;
938 std::vector<bool> supporteds;
939 GSError ret = surface_->IsSupportedAlloc(infos, supporteds);
940 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
941 }
942
943 /*
944 * Function: SetScalingMode and GetScalingMode
945 * Type: Function
946 * Rank: Important(2)
947 * EnvConditions: N/A
948 * CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret
949 */
950 HWTEST_F(ProducerSurfaceTest, scalingMode001, Function | MediumTest | Level2)
951 {
952 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
953 GSError ret = pSurface->SetScalingMode(-1, scalingMode);
954 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
955 }
956
957 /*
958 * Function: SetScalingMode and GetScalingMode
959 * Type: Function
960 * Rank: Important(1)
961 * EnvConditions: N/A
962 * CaseDescription: 1. call SetScalingMode with normal parameters and check ret
963 * 2. call GetScalingMode and check ret
964 */
965 HWTEST_F(ProducerSurfaceTest, scalingMode002, Function | MediumTest | Level1)
966 {
967 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
968 sptr<SurfaceBuffer> buffer;
969 int releaseFence = -1;
970 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, requestConfig);
971 ASSERT_EQ(ret, OHOS::GSERROR_OK);
972 ASSERT_NE(buffer, nullptr);
973
974 uint32_t sequence = buffer->GetSeqNum();
975 ret = pSurface->SetScalingMode(sequence, scalingMode);
976 ASSERT_EQ(ret, OHOS::GSERROR_OK);
977
978 ret = pSurface->CancelBuffer(buffer);
979 ASSERT_EQ(ret, OHOS::GSERROR_OK);
980 }
981
982 /*
983 * Function: SetScalingMode003
984 * Type: Function
985 * Rank: Important(2)
986 * EnvConditions: N/A
987 * CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret
988 */
989 HWTEST_F(ProducerSurfaceTest, scalingMode003, Function | MediumTest | Level2)
990 {
991 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
992 GSError ret = pSurface->SetScalingMode(scalingMode);
993 ASSERT_EQ(ret, OHOS::GSERROR_OK);
994 }
995
996 /*
997 * Function: SetScalingMode and GetScalingMode
998 * Type: Function
999 * Rank: Important(2)
1000 * EnvConditions: N/A
1001 * CaseDescription: 1. call SetScalingMode with producer_ is nullptr and check ret
1002 * 2. call GetScalingMode and check ret
1003 */
1004 HWTEST_F(ProducerSurfaceTest, scalingMode004, Function | MediumTest | Level2)
1005 {
1006 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1007 GSError ret = surface_->SetScalingMode(scalingMode);
1008 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1009 ret = surface_->SetScalingMode(0, scalingMode);
1010 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1011 ret = surface_->GetScalingMode(0, scalingMode);
1012 ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
1013 }
1014
1015 /*
1016 * Function: SetMetaData and GetMetaData
1017 * Type: Function
1018 * Rank: Important(2)
1019 * EnvConditions: N/A
1020 * CaseDescription: 1. call SetMetaData with abnormal parameters and check ret
1021 */
1022 HWTEST_F(ProducerSurfaceTest, metaData001, Function | MediumTest | Level2)
1023 {
1024 std::vector<GraphicHDRMetaData> metaData;
1025 GSError ret = pSurface->SetMetaData(firstSeqnum, metaData);
1026 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1027 }
1028
1029 /*
1030 * Function: SetMetaData and GetMetaData
1031 * Type: Function
1032 * Rank: Important(2)
1033 * EnvConditions: N/A
1034 * CaseDescription: 1. call SetMetaData with abnormal parameters and check ret
1035 */
1036 HWTEST_F(ProducerSurfaceTest, metaData002, Function | MediumTest | Level2)
1037 {
1038 std::vector<GraphicHDRMetaData> metaData;
1039 GraphicHDRMetaData data = {
1040 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1041 .value = 100, // for test
1042 };
1043 metaData.push_back(data);
1044 GSError ret = pSurface->SetMetaData(-1, metaData);
1045 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1046 }
1047
1048 /*
1049 * Function: SetMetaData and GetMetaData
1050 * Type: Function
1051 * Rank: Important(1)
1052 * EnvConditions: N/A
1053 * CaseDescription: 1. call SetMetaData with normal parameters and check ret
1054 * 2. call GetMetaData and check ret
1055 */
1056 HWTEST_F(ProducerSurfaceTest, metaData003, Function | MediumTest | Level1)
1057 {
1058 std::vector<GraphicHDRMetaData> metaData;
1059 GraphicHDRMetaData data = {
1060 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1061 .value = 100, // for test
1062 };
1063 metaData.push_back(data);
1064 sptr<SurfaceBuffer> buffer;
1065 int releaseFence = -1;
1066 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, requestConfig);
1067 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1068 ASSERT_NE(buffer, nullptr);
1069
1070 uint32_t sequence = buffer->GetSeqNum();
1071 ret = pSurface->SetMetaData(sequence, metaData);
1072 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1073
1074 ret = pSurface->CancelBuffer(buffer);
1075 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1076 }
1077
1078 /*
1079 * Function: SetMetaData and GetMetaData
1080 * Type: Function
1081 * Rank: Important(2)
1082 * EnvConditions: N/A
1083 * CaseDescription: 1. call SetMetaData with producer_ is nullptr and check ret
1084 * 2. call GetMetaData and check ret
1085 */
1086 HWTEST_F(ProducerSurfaceTest, metaData004, Function | MediumTest | Level2)
1087 {
1088 std::vector<GraphicHDRMetaData> metaData;
1089 GSError ret = surface_->SetMetaData(0, metaData);
1090 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1091 GraphicHDRMetaData data = {
1092 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1093 .value = 100, // 100 metaData value for test
1094 };
1095 metaData.push_back(data);
1096 ret = surface_->SetMetaData(0, metaData);
1097 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1098 ret = surface_->GetMetaData(0, metaData);
1099 ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
1100 }
1101
1102 /*
1103 * Function: SetMetaDataSet and GetMetaDataSet
1104 * Type: Function
1105 * Rank: Important(2)
1106 * EnvConditions: N/A
1107 * CaseDescription: 1. call SetMetaDataSet with abnormal parameters and check ret
1108 */
1109 HWTEST_F(ProducerSurfaceTest, metaDataSet001, Function | MediumTest | Level2)
1110 {
1111 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1112 std::vector<uint8_t> metaData;
1113
1114 GSError ret = pSurface->SetMetaDataSet(firstSeqnum, key, metaData);
1115 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1116 }
1117
1118 /*
1119 * Function: SetMetaDataSet and GetMetaDataSet
1120 * Type: Function
1121 * Rank: Important(2)
1122 * EnvConditions: N/A
1123 * CaseDescription: 1. call SetMetaDataSet with abnormal parameters and check ret
1124 */
1125 HWTEST_F(ProducerSurfaceTest, metaDataSet002, Function | MediumTest | Level2)
1126 {
1127 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1128 std::vector<uint8_t> metaData;
1129
1130 uint8_t data = 10; // for test
1131 metaData.push_back(data);
1132 GSError ret = pSurface->SetMetaDataSet(-1, key, metaData);
1133 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1134 }
1135
1136 /*
1137 * Function: SetMetaDataSet and GetMetaDataSet
1138 * Type: Function
1139 * Rank: Important(1)
1140 * EnvConditions: N/A
1141 * CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
1142 * 2. call GetMetaDataSet and check ret
1143 */
1144 HWTEST_F(ProducerSurfaceTest, metaDataSet003, Function | MediumTest | Level1)
1145 {
1146 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1147 std::vector<uint8_t> metaData;
1148 uint8_t data = 10; // for test
1149 metaData.push_back(data);
1150
1151 sptr<SurfaceBuffer> buffer;
1152 int releaseFence = -1;
1153 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, requestConfig);
1154 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1155 ASSERT_NE(buffer, nullptr);
1156
1157 uint32_t sequence = buffer->GetSeqNum();
1158 ret = pSurface->SetMetaDataSet(sequence, key, metaData);
1159 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1160
1161 ret = pSurface->CancelBuffer(buffer);
1162 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1163 }
1164
1165 /*
1166 * Function: SetMetaDataSet and GetMetaDataSet
1167 * Type: Function
1168 * Rank: Important(2)
1169 * EnvConditions: N/A
1170 * CaseDescription: 1. call SetMetaDataSet with producer_ is nullptr and check ret
1171 * 2. call GetMetaDataSet and check ret
1172 */
1173 HWTEST_F(ProducerSurfaceTest, metaDataSet004, Function | MediumTest | Level2)
1174 {
1175 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1176 std::vector<uint8_t> metaData;
1177
1178 uint8_t data = 10; // metaData value for test
1179 metaData.push_back(data);
1180 GSError ret = surface_->SetMetaDataSet(0, key, metaData);
1181 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1182 ret = surface_->GetMetaDataSet(0, key, metaData);
1183 ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
1184 }
1185
1186 /*
1187 * Function: SetTunnelHandle and GetTunnelHandle
1188 * Type: Function
1189 * Rank: Important(2)
1190 * EnvConditions: N/A
1191 * CaseDescription: 1. call SetTunnelhandle with producer_ is nullptr and check ret
1192 */
1193 HWTEST_F(ProducerSurfaceTest, tunnelHandle001, Function | MediumTest | Level2)
1194 {
1195 GraphicExtDataHandle *handle = nullptr;
1196 handle = static_cast<GraphicExtDataHandle *>(malloc(sizeof(GraphicExtDataHandle) + sizeof(int32_t) * 1));
1197 handle->fd = -1;
1198 handle->reserveInts = 1;
1199 handle->reserve[0] = 0;
1200 GSError ret = surface_->SetTunnelHandle(handle);
1201 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1202
1203 sptr<SurfaceTunnelHandle> handleGet = surface_->GetTunnelHandle();
1204 ASSERT_EQ(handleGet, nullptr);
1205 free(handle);
1206 }
1207
1208 /*
1209 * Function: SetTunnelHandle and GetTunnelHandle
1210 * Type: Function
1211 * Rank: Important(2)
1212 * EnvConditions: N/A
1213 * CaseDescription: 1. call SetTunnelhandle with normal parameters and check ret
1214 */
1215 HWTEST_F(ProducerSurfaceTest, tunnelHandle002, Function | MediumTest | Level2)
1216 {
1217 GraphicExtDataHandle *handle = nullptr;
1218 handle = static_cast<GraphicExtDataHandle *>(malloc(sizeof(GraphicExtDataHandle) + sizeof(int32_t) * 1));
1219 handle->fd = -1;
1220 handle->reserveInts = 1;
1221 handle->reserve[0] = 0;
1222 GSError ret = pSurface->SetTunnelHandle(handle);
1223 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1224
1225 ret = pSurface->SetTunnelHandle(handle);
1226 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1227 free(handle);
1228 }
1229
1230 /*
1231 * Function: connect
1232 * Type: Function
1233 * Rank: Important(1)
1234 * EnvConditions: N/A
1235 * CaseDescription: 1. call connect and check ret
1236 */
1237 HWTEST_F(ProducerSurfaceTest, connect001, Function | MediumTest | Level1)
1238 {
1239 GSError ret = pSurface->Connect();
1240 ASSERT_EQ(ret, OHOS::SURFACE_ERROR_CONSUMER_IS_CONNECTED);
1241 }
1242
1243 /*
1244 * Function: disconnect
1245 * Type: Function
1246 * Rank: Important(1)
1247 * EnvConditions: N/A
1248 * CaseDescription: 1. call Disconnect and check ret
1249 */
1250 HWTEST_F(ProducerSurfaceTest, disconnect001, Function | MediumTest | Level1)
1251 {
1252 GSError ret = pSurface->Disconnect();
1253 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1254 }
1255
1256 /*
1257 * Function: connect
1258 * Type: Function
1259 * Rank: Important(1)
1260 * EnvConditions: N/A
1261 * CaseDescription: 1. call connect and check ret
1262 */
1263 HWTEST_F(ProducerSurfaceTest, connect002, Function | MediumTest | Level1)
1264 {
1265 GSError ret = pSurface->Connect();
1266 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1267 }
1268
1269 /*
1270 * Function: disconnect
1271 * Type: Function
1272 * Rank: Important(1)
1273 * EnvConditions: N/A
1274 * CaseDescription: 1. call Disconnect and check ret
1275 */
1276 HWTEST_F(ProducerSurfaceTest, disconnect002, Function | MediumTest | Level1)
1277 {
1278 GSError ret = pSurface->Disconnect();
1279 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1280 }
1281
1282 /*
1283 * Function: connect
1284 * Type: Function
1285 * Rank: Important(1)
1286 * EnvConditions: N/A
1287 * CaseDescription: 1. call connect with producer_ is nullptr and check ret
1288 */
1289 HWTEST_F(ProducerSurfaceTest, connect003, Function | MediumTest | Level1)
1290 {
1291 GSError ret = surface_->Connect();
1292 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1293 }
1294
1295 /*
1296 * Function: disconnect
1297 * Type: Function
1298 * Rank: Important(1)
1299 * EnvConditions: N/A
1300 * CaseDescription: 1. call Disconnect with producer_ is nullptr and check ret
1301 */
1302 HWTEST_F(ProducerSurfaceTest, disconnect003, Function | MediumTest | Level1)
1303 {
1304 GSError ret = surface_->Disconnect();
1305 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1306 }
1307
1308 /*
1309 * Function: SetPresentTimestamp and GetPresentTimestamp
1310 * Type: Function
1311 * Rank: Important(2)
1312 * EnvConditions: N/A
1313 * CaseDescription: 1. call GetPresentTimestamp with producer_ is nullptr and check ret
1314 * 2. call SetPresentTimestamp and check ret
1315 */
1316 HWTEST_F(ProducerSurfaceTest, presentTimestamp001, Function | MediumTest | Level2)
1317 {
1318 GraphicPresentTimestampType type = GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_UNSUPPORTED;
1319 int64_t time = 0;
1320
1321 GSError ret = surface_->GetPresentTimestamp(firstSeqnum, type, time);
1322 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1323 GraphicPresentTimestamp timestamp;
1324 ret = surface_->SetPresentTimestamp(firstSeqnum, timestamp);
1325 ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
1326 }
1327
1328 /*
1329 * Function: SetPresentTimestamp and GetPresentTimestamp
1330 * Type: Function
1331 * Rank: Important(2)
1332 * EnvConditions: N/A
1333 * CaseDescription: 1. call GetPresentTimestamp with normal parameters and check ret
1334 * @tc.require: issueI5I57K
1335 */
1336 HWTEST_F(ProducerSurfaceTest, presentTimestamp002, Function | MediumTest | Level2)
1337 {
1338 GraphicPresentTimestampType type = GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_UNSUPPORTED;
1339 int64_t time = 0;
1340
1341 GSError ret = pSurface->GetPresentTimestamp(firstSeqnum, type, time);
1342 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1343 }
1344
1345 /*
1346 * Function: SetPresentTimestamp and GetPresentTimestamp
1347 * Type: Function
1348 * Rank: Important(2)
1349 * EnvConditions: N/A
1350 * CaseDescription: 1. call SetPresentTimestamp with normal parameters and check ret
1351 * @tc.require: issueI5I57K
1352 */
1353 HWTEST_F(ProducerSurfaceTest, presentTimestamp003, Function | MediumTest | Level2)
1354 {
1355 GraphicPresentTimestampType type = GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_DELAY;
1356 int64_t time = 0;
1357 GSError ret = pSurface->GetPresentTimestamp(-1, type, time);
1358 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1359 }
1360
1361 /*
1362 * Function: SetPresentTimestamp and GetPresentTimestamp
1363 * Type: Function
1364 * Rank: Important(1)
1365 * EnvConditions: N/A
1366 * CaseDescription: 1. call SetPresentTimestamp and check ret
1367 * @tc.require: issueI5I57K
1368 */
1369 HWTEST_F(ProducerSurfaceTest, presentTimestamp004, Function | MediumTest | Level1)
1370 {
1371 sptr<SurfaceBuffer> buffer;
1372 int releaseFence = -1;
1373 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, requestConfig);
1374 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1375 ASSERT_NE(buffer, nullptr);
1376
1377 uint32_t sequence = buffer->GetSeqNum();
1378 GraphicPresentTimestampType type = GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_DELAY;
1379 int64_t time = 0;
1380 ret = pSurface->GetPresentTimestamp(sequence, type, time);
1381 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1382
1383 ret = pSurface->CancelBuffer(buffer);
1384 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1385 }
1386
1387 /*
1388 * Function: SetWptrNativeWindowToPSurface
1389 * Type: Function
1390 * Rank: Important(1)
1391 * EnvConditions: N/A
1392 * CaseDescription: 1. SetWptrNativeWindowToPSurface and check ret
1393 * @tc.require: issueI7WYIY
1394 */
1395 HWTEST_F(ProducerSurfaceTest, SetWptrNativeWindowToPSurface001, Function | MediumTest | Level1)
1396 {
1397 struct NativeWindow nativeWindow;
1398 GSError ret = pSurface->SetWptrNativeWindowToPSurface(&nativeWindow);
1399 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1400 }
1401
1402 /*
1403 * Function: AttachBuffer
1404 * Type: Function
1405 * Rank: Important(1)
1406 * EnvConditions: N/A
1407 * CaseDescription: 1. AttachBuffer and check ret
1408 * @tc.require: issueI7WYIY
1409 */
1410 HWTEST_F(ProducerSurfaceTest, AttachBuffer001, Function | MediumTest | Level1)
1411 {
1412 GSError ret = pSurface->CleanCache();
1413 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1414 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1415 ASSERT_NE(buffer, nullptr);
1416 sptr<SyncFence> fence = SyncFence::INVALID_FENCE;
1417 int32_t timeOut = 5;
1418 ret = pSurface->AttachBuffer(buffer, timeOut);
1419 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1420 }
1421
1422 /*
1423 * Function: AttachBuffer
1424 * Type: Function
1425 * Rank: Important(2)
1426 * EnvConditions: N/A
1427 * CaseDescription: 1. call AttachBuffer with producer_ is nullptr
1428 * 2. check ret
1429 */
1430 HWTEST_F(ProducerSurfaceTest, AttachBuffer002, Function | MediumTest | Level2)
1431 {
1432 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1433 GSError ret = surface_->AttachBuffer(buffer);
1434 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1435 ret = surface_->AttachBuffer(buffer, 0);
1436 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1437 }
1438
1439 /*
1440 * Function: RegisterSurfaceDelegator000
1441 * Type: Function
1442 * Rank: Important(1)
1443 * EnvConditions: N/A
1444 * CaseDescription: 1. RegisterSurfaceDelegator and check ret
1445 * @tc.require: issueI7WYIY
1446 */
1447 HWTEST_F(ProducerSurfaceTest, RegisterSurfaceDelegator001, Function | MediumTest | Level1)
1448 {
1449 GSError ret = pSurface->CleanCache();
1450 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1451 ret = pSurface->RegisterSurfaceDelegator(nullptr);
1452 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1453 }
1454
1455 /*
1456 * Function: CleanCache001
1457 * Type: Function
1458 * Rank: Important(1)
1459 * EnvConditions: N/A
1460 * CaseDescription: 1. CleanCache and check ret
1461 */
1462 HWTEST_F(ProducerSurfaceTest, CleanCache001, Function | MediumTest | Level2)
1463 {
1464 GSError ret = pSurface->CleanCache(true);
1465 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1466 }
1467
1468 /*
1469 * Function: CleanCache
1470 * Type: Function
1471 * Rank: Important(1)
1472 * EnvConditions: N/A
1473 * CaseDescription: 1. CleanCache with producer_ is nullptr and check ret
1474 */
1475 HWTEST_F(ProducerSurfaceTest, CleanCache002, Function | MediumTest | Level2)
1476 {
1477 GSError ret = surface_->CleanCache(true);
1478 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1479 }
1480
1481 /*
1482 * Function: GoBackground
1483 * Type: Function
1484 * Rank: Important(1)
1485 * EnvConditions: N/A
1486 * CaseDescription: 1. GoBackground with producer_ is nullptr and check ret
1487 */
1488 HWTEST_F(ProducerSurfaceTest, GoBackground001, Function | MediumTest | Level2)
1489 {
1490 GSError ret = surface_->GoBackground();
1491 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1492 }
1493
1494 /*
1495 * Function: SetSurfaceSourceType and GetSurfaceSourceType
1496 * Type: Function
1497 * Rank: Important(2)
1498 * EnvConditions: N/A
1499 * CaseDescription: 1. call SetSurfaceSourceType and check ret
1500 * 2. call GetSurfaceSourceType and check ret
1501 */
1502 HWTEST_F(ProducerSurfaceTest, SurfaceSourceType001, Function | MediumTest | Level2)
1503 {
1504 OHSurfaceSource sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
1505 GSError ret = pSurface->SetSurfaceSourceType(sourceType);
1506 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1507 ASSERT_EQ(pSurface->GetSurfaceSourceType(), OH_SURFACE_SOURCE_VIDEO);
1508 }
1509
1510 /*
1511 * Function: SetSurfaceSourceType and GetSurfaceSourceType
1512 * Type: Function
1513 * Rank: Important(2)
1514 * EnvConditions: N/A
1515 * CaseDescription: 1. call SetSurfaceSourceType with producer_ is nullptr and check ret
1516 * 2. call GetSurfaceSourceType with producer_ is nullptr and check ret
1517 */
1518 HWTEST_F(ProducerSurfaceTest, SurfaceSourceType002, Function | MediumTest | Level2)
1519 {
1520 OHSurfaceSource sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
1521 GSError ret = surface_->SetSurfaceSourceType(sourceType);
1522 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1523 ASSERT_EQ(surface_->GetSurfaceSourceType(), OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT);
1524 }
1525
1526 /*
1527 * Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
1528 * Type: Function
1529 * Rank: Important(2)
1530 * EnvConditions: N/A
1531 * CaseDescription: 1. call SetSurfaceAppFrameworkType and check ret
1532 * 2. call GetSurfaceAppFrameworkType and check ret
1533 */
1534 HWTEST_F(ProducerSurfaceTest, SurfaceAppFrameworkType001, Function | MediumTest | Level2)
1535 {
1536 std::string type = "test";
1537 GSError ret = pSurface->SetSurfaceAppFrameworkType(type);
1538 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1539 ASSERT_EQ(pSurface->GetSurfaceAppFrameworkType(), "test");
1540 }
1541
1542 /*
1543 * Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
1544 * Type: Function
1545 * Rank: Important(2)
1546 * EnvConditions: N/A
1547 * CaseDescription: 1. call SetSurfaceAppFrameworkType with producer_ is nullptr and check ret
1548 * 2. call GetSurfaceAppFrameworkType with producer_ is nullptr and check ret
1549 */
1550 HWTEST_F(ProducerSurfaceTest, SurfaceAppFrameworkType002, Function | MediumTest | Level2)
1551 {
1552 std::string type = "test";
1553 GSError ret = surface_->SetSurfaceAppFrameworkType(type);
1554 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1555 ASSERT_EQ(surface_->GetSurfaceAppFrameworkType(), "");
1556 }
1557
1558 /*
1559 * Function: RegisterReleaseListener and UnRegisterReleaseListener
1560 * Type: Function
1561 * Rank: Important(2)
1562 * EnvConditions: N/A
1563 * CaseDescription: 1. call RegisterReleaseListener with producer_ is nullptr and check ret
1564 * 2. call UnRegisterReleaseListener with producer_ is nullptr and check ret
1565 */
1566 HWTEST_F(ProducerSurfaceTest, ReleaseListener001, Function | MediumTest | Level2)
1567 {
1568 GSError ret = surface_->RegisterReleaseListener(OnBufferRelease);
1569 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1570 OnReleaseFuncWithFence releaseFuncWithFence;
1571 ret = surface_->RegisterReleaseListener(releaseFuncWithFence);
1572 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1573 ret = surface_->UnRegisterReleaseListener();
1574 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1575 }
1576
1577 /*
1578 * Function: RegisterUserDataChangeListener
1579 * Type: Function
1580 * Rank: Important(2)
1581 * EnvConditions: N/A
1582 * CaseDescription: 1. call RegisterUserDataChangeListener with nullptr param
1583 * 2. check ret
1584 */
1585 HWTEST_F(ProducerSurfaceTest, RegisterUserDataChangeListener001, Function | MediumTest | Level2)
1586 {
1587 GSError ret = surface_->RegisterUserDataChangeListener("test", nullptr);
1588 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1589 }
1590
1591 /*
1592 * Function: RequestBuffersAndFlushBuffers
1593 * Type: Function
1594 * Rank: Important(1)
1595 * EnvConditions: N/A
1596 * CaseDescription: 1. call RequestBuffers and FlushBuffers
1597 * @tc.require: issueI5GMZN issueI5IWHW
1598 */
1599 HWTEST_F(ProducerSurfaceTest, RequestBuffersAndFlushBuffers, Function | MediumTest | Level1)
1600 {
1601 pSurface->SetQueueSize(12);
1602 std::vector<sptr<SurfaceBuffer>> sfbuffers;
1603 std::vector<sptr<SyncFence>> releaseFences;
1604 EXPECT_EQ(OHOS::GSERROR_OK, pSurface->RequestBuffers(sfbuffers, releaseFences, requestConfig));
1605 for (size_t i = 0; i < sfbuffers.size(); ++i) {
1606 EXPECT_NE(nullptr, sfbuffers[i]);
1607 }
1608 std::cout << sfbuffers.size() << std::endl;
1609 uint32_t num = static_cast<uint32_t>(sfbuffers.size());
1610 std::vector<sptr<SyncFence>> flushFences;
1611 std::vector<BufferFlushConfigWithDamages> configs;
1612 flushFences.resize(num);
1613 configs.reserve(num);
__anona16cde430502(BufferFlushConfigWithDamages &config) 1614 auto handleConfig = [](BufferFlushConfigWithDamages &config) -> void {
1615 config.damages.reserve(1);
1616 OHOS::Rect damage = {
1617 .x = 0,
1618 .y = 0,
1619 .w = 0x100,
1620 .h = 0x100
1621 };
1622 config.damages.emplace_back(damage);
1623 config.timestamp = 0;
1624 };
1625 for (uint32_t i = 0; i < num; ++i) {
1626 flushFences[i] = new SyncFence(-1);
1627 BufferFlushConfigWithDamages config;
1628 handleConfig(config);
1629 configs.emplace_back(config);
1630 }
1631 flushFences[0] = nullptr;
1632 EXPECT_EQ(OHOS::GSERROR_INVALID_ARGUMENTS, pSurface->FlushBuffers(sfbuffers, flushFences, configs));
1633 flushFences[0] = new SyncFence(-1);
1634 EXPECT_EQ(OHOS::GSERROR_OK, pSurface->FlushBuffers(sfbuffers, flushFences, configs));
1635 sptr<SurfaceBuffer> buffer;
1636 int32_t flushFence;
1637 for (uint32_t i = 0; i < num; ++i) {
1638 GSError ret = csurf->AcquireBuffer(buffer, flushFence, timestamp, damage);
1639 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1640 ret = csurf->ReleaseBuffer(buffer, -1);
1641 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1642 }
1643 EXPECT_EQ(OHOS::GSERROR_NO_BUFFER, csurf->AcquireBuffer(buffer, flushFence, timestamp, damage));
1644 pSurface->SetQueueSize(2);
1645 }
1646
1647 /*
1648 * Function: AcquireLastFlushedBuffer and ReleaseLastFlushedBuffer
1649 * Type: Function
1650 * Rank: Important(1)
1651 * EnvConditions: N/A
1652 * CaseDescription: 1. call AcquireLastFlushedBuffer OK
1653 * 2. call AcquireLastFlushedBuffer FAIL
1654 * 3. call ReleaseLastFlushedBuffer
1655 */
1656 HWTEST_F(ProducerSurfaceTest, AcquireLastFlushedBuffer001, Function | MediumTest | Level2)
1657 {
1658 sptr<SurfaceBuffer> buffer;
1659 int releaseFence = -1;
1660 EXPECT_EQ(producer->SetQueueSize(3), OHOS::GSERROR_OK);
1661 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, requestConfig);
1662 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1663
1664 ret = pSurface->FlushBuffer(buffer, -1, flushConfig);
1665 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1666
1667 int32_t flushFence;
1668 ret = csurf->AcquireBuffer(buffer, flushFence, timestamp, damage);
1669 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1670 ret = csurf->ReleaseBuffer(buffer, -1);
1671 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1672
1673 sptr<SurfaceBuffer> buffer1 = nullptr;
1674 sptr<SyncFence> fence = nullptr;
1675 float matrix[16];
1676
1677 ret = pSurface->AcquireLastFlushedBuffer(buffer1, fence, matrix, 16, false);
1678 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1679 EXPECT_EQ(buffer->GetSeqNum(), buffer1->GetSeqNum());
1680
1681 ret = pSurface->AcquireLastFlushedBuffer(buffer1, fence, matrix, 16, false);
1682 EXPECT_EQ(ret, OHOS::SURFACE_ERROR_BUFFER_STATE_INVALID);
1683
1684 sptr<SurfaceBuffer> buffer2;
1685 ret = pSurface->RequestBuffer(buffer2, releaseFence, requestConfig);
1686 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1687
1688 sptr<SurfaceBuffer> buffer3;
1689 ret = pSurface->RequestBuffer(buffer3, releaseFence, requestConfig);
1690 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1691
1692 sptr<SurfaceBuffer> buffer4;
1693 ret = pSurface->RequestBuffer(buffer4, releaseFence, requestConfig);
1694 EXPECT_EQ(ret, OHOS::GSERROR_NO_BUFFER);
1695
1696 ret = pSurface->ReleaseLastFlushedBuffer(buffer1);
1697 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1698
1699 ret = pSurface->RequestBuffer(buffer4, releaseFence, requestConfig);
1700 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1701
1702 ret = pSurface->FlushBuffer(buffer2, -1, flushConfig);
1703 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1704
1705 ret = pSurface->FlushBuffer(buffer3, -1, flushConfig);
1706 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1707
1708 ret = pSurface->FlushBuffer(buffer4, -1, flushConfig);
1709 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1710
1711 ret = pSurface->ReleaseLastFlushedBuffer(buffer2);
1712 EXPECT_EQ(ret, OHOS::SURFACE_ERROR_BUFFER_STATE_INVALID);
1713
1714 EXPECT_EQ(pSurface->CleanCache(), OHOS::GSERROR_OK);
1715 }
1716
1717 /*
1718 * Function: AcquireLastFlushedBuffer and ReleaseLastFlushedBuffer
1719 * Type: Function
1720 * Rank: Important(1)
1721 * EnvConditions: N/A
1722 * CaseDescription: 1. call AcquireLastFlushedBuffer FAIL
1723 * 3. call ReleaseLastFlushedBuffer FAIL
1724 */
1725 HWTEST_F(ProducerSurfaceTest, AcquireLastFlushedBuffer002, Function | MediumTest | Level2)
1726 {
1727 sptr<SurfaceBuffer> buffer1 = nullptr;
1728 sptr<SyncFence> fence = nullptr;
1729 float matrix[16];
1730 GSError ret = surface_->AcquireLastFlushedBuffer(buffer1, fence, matrix, 16, false);
1731 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1732 ret = surface_->ReleaseLastFlushedBuffer(buffer1);
1733 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1734 ret = pSurface->ReleaseLastFlushedBuffer(nullptr);
1735 EXPECT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1736 }
1737
1738 /*
1739 * Function: SetHdrWhitePointBrightness and SetSdrWhitePointBrightness
1740 * Type: Function
1741 * Rank: Important(2)
1742 * EnvConditions: N/A
1743 * CaseDescription: 1. call SetHdrWhitePointBrightness with producer_ is nullptr and check ret
1744 * 2. call SetSdrWhitePointBrightness with producer_ is nullptr and check ret
1745 */
1746 HWTEST_F(ProducerSurfaceTest, WhitePointBrightness001, Function | MediumTest | Level2)
1747 {
1748 GSError ret = surface_->SetHdrWhitePointBrightness(0);
1749 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1750 ret = surface_->SetSdrWhitePointBrightness(0);
1751 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1752 }
1753
1754 /*
1755 * Function: ReleaseLastFlushedBuffer
1756 * Type: Function
1757 * Rank: Important(2)
1758 * EnvConditions: N/A
1759 * CaseDescription: 1. call ReleaseLastFlushedBuffer with buffer is nullptr and check ret
1760 * 2. call ReleaseLastFlushedBuffer with producer_ is nullptr and check ret
1761 */
1762 HWTEST_F(ProducerSurfaceTest, ReleaseLastFlushedBuffer001, Function | MediumTest | Level2)
1763 {
1764 sptr<SurfaceBuffer> buffer = nullptr;
1765 GSError ret = surface_->ReleaseLastFlushedBuffer(buffer);
1766 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1767 buffer = SurfaceBuffer::Create();
1768 ret = surface_->ReleaseLastFlushedBuffer(buffer);
1769 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1770 }
1771
1772 /*
1773 * Function: RequestBufferNoListener
1774 * Type: Function
1775 * Rank: Important(2)
1776 * EnvConditions: N/A
1777 * CaseDescription: 1. call RequestBuffer and check ret
1778 */
1779 HWTEST_F(ProducerSurfaceTest, RequestBufferNoListener, Function | MediumTest | Level2)
1780 {
1781 sptr<IConsumerSurface> cSurfTmp = IConsumerSurface::Create();
1782 sptr<IBufferProducer> producerTmp = cSurfTmp->GetProducer();
1783 sptr<Surface> pSurfaceTmp = Surface::CreateSurfaceAsProducer(producerTmp);
1784
1785 BufferRequestConfig requestConfigTmp = {
1786 .width = 0x100,
1787 .height = 0x100,
1788 .strideAlignment = 0x8,
1789 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1790 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1791 .timeout = 0,
1792 };
1793 sptr<SurfaceBuffer> buffer = nullptr;
1794 int releaseFence = -1;
1795 GSError ret = pSurfaceTmp->RequestBuffer(buffer, releaseFence, requestConfigTmp);
1796 ASSERT_EQ(ret, OHOS::SURFACE_ERROR_CONSUMER_UNREGISTER_LISTENER);
1797
1798 ret = pSurfaceTmp->Disconnect();
1799 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1800
1801 ret = pSurfaceTmp->Connect();
1802 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1803
1804 ret = pSurfaceTmp->Disconnect();
1805 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1806
1807 pSurfaceTmp = nullptr;
1808 producerTmp = nullptr;
1809 cSurfTmp = nullptr;
1810 }
1811
1812 /*
1813 * Function: RequestBuffersNoListener
1814 * Type: Function
1815 * Rank: Important(2)
1816 * EnvConditions: N/A
1817 * CaseDescription: 1. call RequestBuffer and check ret
1818 */
1819 HWTEST_F(ProducerSurfaceTest, RequestBuffersNoListener, Function | MediumTest | Level2)
1820 {
1821 sptr<IConsumerSurface> cSurfTmp = IConsumerSurface::Create();
1822 sptr<IBufferProducer> producerTmp = cSurfTmp->GetProducer();
1823 sptr<Surface> pSurfaceTmp = Surface::CreateSurfaceAsProducer(producerTmp);
1824
1825 BufferRequestConfig requestConfigTmp = {
1826 .width = 0x100,
1827 .height = 0x100,
1828 .strideAlignment = 0x8,
1829 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1830 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1831 .timeout = 0,
1832 .transform = GraphicTransformType::GRAPHIC_ROTATE_BUTT,
1833 };
1834
1835 std::vector<sptr<SurfaceBuffer>> sfbuffers;
1836 std::vector<sptr<SyncFence>> releaseFences;
1837 GSError ret = pSurfaceTmp->RequestBuffers(sfbuffers, releaseFences, requestConfigTmp);
1838 ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
1839
1840 ret = pSurfaceTmp->Disconnect();
1841 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1842
1843 ret = pSurfaceTmp->Connect();
1844 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1845
1846 ret = pSurfaceTmp->Disconnect();
1847 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1848
1849 pSurfaceTmp = nullptr;
1850 producerTmp = nullptr;
1851 cSurfTmp = nullptr;
1852 }
1853 }
1854