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 <buffer_queue_producer.h>
19 #include <consumer_surface.h>
20 #include "buffer_consumer_listener.h"
21 #include "sync_fence.h"
22 #include "producer_surface_delegator.h"
23 #include "buffer_queue_consumer.h"
24 #include "buffer_queue.h"
25 #include "v1_1/buffer_handle_meta_key_type.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS::Rosen {
31 class ConsumerSurfaceTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 static void deleteBuffer(int32_t bufferId);
36 void SetUp() override;
37 void TearDown() override;
38
39 static inline BufferRequestConfig requestConfig = {
40 .width = 0x100,
41 .height = 0x100,
42 .strideAlignment = 0x8,
43 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
44 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
45 .timeout = 0,
46 };
47 static inline BufferFlushConfig flushConfig = {
48 .damage = {
49 .w = 0x100,
50 .h = 0x100,
51 },
52 };
53 static inline BufferFlushConfigWithDamages flushConfigWithDamages = {
54 .damages = {
55 { .x = 0x100, .y = 0x100, .w = 0x100, .h = 0x100, },
56 { .x = 0x200, .y = 0x200, .w = 0x200, .h = 0x200, },
57 },
58 .timestamp = 0x300,
59 };
60 static inline int64_t timestamp = 0;
61 static inline Rect damage = {};
62 static inline std::vector<Rect> damages = {};
63 static inline sptr<IConsumerSurface> cs = nullptr;
64 static inline sptr<Surface> ps = nullptr;
65 static inline sptr<BufferQueue> bq = nullptr;
66 static inline sptr<ProducerSurfaceDelegator> surfaceDelegator = nullptr;
67 static inline sptr<BufferQueueConsumer> consumer_ = nullptr;
68 static inline uint32_t firstSeqnum = 0;
69 sptr<ConsumerSurface> surface_ = nullptr;
70 };
71
SetUpTestCase()72 void ConsumerSurfaceTest::SetUpTestCase()
73 {
74 cs = IConsumerSurface::Create();
75 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
76 cs->RegisterConsumerListener(listener);
77 auto p = cs->GetProducer();
78 bq = new BufferQueue("test");
79 ps = Surface::CreateSurfaceAsProducer(p);
80 surfaceDelegator = ProducerSurfaceDelegator::Create();
81 }
82
TearDownTestCase()83 void ConsumerSurfaceTest::TearDownTestCase()
84 {
85 surfaceDelegator = nullptr;
86 ps = nullptr;
87 bq = nullptr;
88 cs = nullptr;
89 }
90
deleteBuffer(int32_t bufferId)91 void ConsumerSurfaceTest::deleteBuffer(int32_t bufferId)
92 {
93 }
94
SetUp()95 void ConsumerSurfaceTest::SetUp()
96 {
97 surface_ = new ConsumerSurface("test");
98 ASSERT_NE(surface_, nullptr);
99 ASSERT_EQ(surface_->producer_, nullptr);
100 ASSERT_EQ(surface_->consumer_, nullptr);
101 }
102
TearDown()103 void ConsumerSurfaceTest::TearDown()
104 {
105 surface_ = nullptr;
106 }
107
108 class TestConsumerListenerClazz : public IBufferConsumerListenerClazz {
109 public:
OnBufferAvailable()110 void OnBufferAvailable() override
111 {
112 }
113 };
114
115 /*
116 * Function: GetProducer
117 * Type: Function
118 * Rank: Important(2)
119 * EnvConditions: N/A
120 * CaseDescription: 1. get ConsumerSurface and GetProducer
121 * 2. check ret
122 */
123 HWTEST_F(ConsumerSurfaceTest, ConsumerSurface001, TestSize.Level0)
124 {
125 ASSERT_NE(cs, nullptr);
126
127 sptr<ConsumerSurface> qs = static_cast<ConsumerSurface*>(cs.GetRefPtr());
128 ASSERT_NE(qs, nullptr);
129 ASSERT_NE(qs->GetProducer(), nullptr);
130 }
131
132 /*
133 * Function: ConsumerSurface dtor
134 * Type: Function
135 * Rank: Important(2)
136 * EnvConditions: N/A
137 * CaseDescription: 1. new ConsumerSurface, only one nullptr for consumer_ and producer_
138 * 2. dtor and check ret
139 */
140 HWTEST_F(ConsumerSurfaceTest, ConsumerSurfaceDtor001, TestSize.Level0)
141 {
142 sptr<BufferQueue> queue = new BufferQueue("test");
143 surface_->producer_ = new BufferQueueProducer(queue);
144 ASSERT_NE(surface_->producer_, nullptr);
145 ASSERT_EQ(surface_->consumer_, nullptr);
146 }
147
148 /*
149 * Function: ConsumerSurface dtor
150 * Type: Function
151 * Rank: Important(2)
152 * EnvConditions: N/A
153 * CaseDescription: 1. new ConsumerSurface, only one nullptr for consumer_ and producer_
154 * 2. dtor and check ret
155 */
156 HWTEST_F(ConsumerSurfaceTest, ConsumerSurfaceDtor002, TestSize.Level0)
157 {
158 sptr<BufferQueue> queue = new BufferQueue("test");
159 surface_->consumer_ = new BufferQueueConsumer(queue);
160 ASSERT_NE(surface_->consumer_, nullptr);
161 }
162
163 /*
164 * Function: SetQueueSize and GetQueueSize
165 * Type: Function
166 * Rank: Important(2)
167 * EnvConditions: N/A
168 * CaseDescription: 1. call GetQueueSize and get default value
169 * 2. call SetQueueSize
170 * 3. call SetQueueSize again with abnormal value
171 * 4. call GetQueueSize for BufferQueueProducer and BufferQueue
172 * 5. check ret
173 */
174 HWTEST_F(ConsumerSurfaceTest, QueueSize001, TestSize.Level0)
175 {
176 ASSERT_EQ(cs->GetQueueSize(), (uint32_t)SURFACE_DEFAULT_QUEUE_SIZE);
177 GSError ret = cs->SetQueueSize(2);
178 ASSERT_EQ(ret, OHOS::GSERROR_OK);
179
180 ret = cs->SetQueueSize(SURFACE_MAX_QUEUE_SIZE + 1);
181 ASSERT_NE(ret, OHOS::GSERROR_OK);
182
183 ASSERT_EQ(cs->GetQueueSize(), 2u);
184 }
185
186 /*
187 * Function: SetQueueSize and GetQueueSize
188 * Type: Function
189 * Rank: Important(2)
190 * EnvConditions: N/A
191 * CaseDescription: 1. call GetQueueSize
192 * 2. call SetQueueSize 2 times
193 * 3. check ret
194 */
195 HWTEST_F(ConsumerSurfaceTest, QueueSize002, TestSize.Level0)
196 {
197 sptr<ConsumerSurface> qs = static_cast<ConsumerSurface*>(cs.GetRefPtr());
198 sptr<BufferQueueProducer> bqp = static_cast<BufferQueueProducer*>(qs->GetProducer().GetRefPtr());
199 ASSERT_EQ(bqp->GetQueueSize(), 2u);
200
201 GSError ret = cs->SetQueueSize(1);
202 ASSERT_EQ(ret, OHOS::GSERROR_OK);
203
204 ret = cs->SetQueueSize(2);
205 ASSERT_EQ(ret, OHOS::GSERROR_OK);
206 }
207
208 /*
209 * Function: SetQueueSize and GetQueueSize
210 * Type: Function
211 * Rank: Important(2)
212 * EnvConditions: N/A
213 * CaseDescription: 1. call GetQueueSize with producer_ is nullptr
214 * 2. call SetQueueSize with producer_ is nullptr
215 * 3. check ret
216 */
217 HWTEST_F(ConsumerSurfaceTest, QueueSize003, TestSize.Level0)
218 {
219 uint32_t size = surface_->GetQueueSize();
220 ASSERT_EQ(size, 0);
221 GSError ret = surface_->SetQueueSize(1);
222 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
223 }
224
225 /*
226 * Function: SetDefaultWidthAndHeight, GetDefaultWidth and GetDefaultHeight
227 * Type: Function
228 * Rank: Important(2)
229 * EnvConditions: N/A
230 * CaseDescription: 1. call SetDefaultWidthAndHeight with consumer_ is nullptr
231 * 2. call GetDefaultWidth with producer_ is nullptr
232 * 3. call GetDefaultHeight with producer_ is nullptr
233 * 4. check ret
234 */
235 HWTEST_F(ConsumerSurfaceTest, DefaultWidthAndHeight001, TestSize.Level0)
236 {
237 int32_t width = 0;
238 int32_t height = 0;
239 GSError ret = surface_->SetDefaultWidthAndHeight(width, height);
240 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
241 width = surface_->GetDefaultWidth();
242 ASSERT_EQ(width, -1);
243 height = surface_->GetDefaultHeight();
244 ASSERT_EQ(height, -1);
245 }
246
247 /*
248 * Function: SetDefaultWidthAndHeight, GetDefaultWidth and GetDefaultHeight
249 * Type: Function
250 * Rank: Important(2)
251 * EnvConditions: N/A
252 * CaseDescription: 1. call SetDefaultWidthAndHeight with noraml value
253 * 2. call GetDefaultWidth
254 * 3. call GetDefaultHeight
255 * 4. check ret
256 */
257 HWTEST_F(ConsumerSurfaceTest, DefaultWidthAndHeight002, TestSize.Level0)
258 {
259 ASSERT_NE(cs, nullptr);
260 int32_t width = 100; // 100 test value for width
261 int32_t height = 100; // 100 test value for height
262 GSError ret = cs->SetDefaultWidthAndHeight(width, height);
263 ASSERT_EQ(ret, OHOS::GSERROR_OK);
264 int32_t value = cs->GetDefaultWidth();
265 ASSERT_EQ(value, width);
266 value = cs->GetDefaultHeight();
267 ASSERT_EQ(value, height);
268 }
269
270 /*
271 * Function: SetDefaultUsage and GetDefaultUsage
272 * Type: Function
273 * Rank: Important(2)
274 * EnvConditions: N/A
275 * CaseDescription: 1. call SetDefaultUsage with consumer_ is nullptr
276 * 2. call GetDefaultUsage with producer_ is nullptr
277 * 3. check ret
278 */
279 HWTEST_F(ConsumerSurfaceTest, DefaultUsage001, TestSize.Level0)
280 {
281 GSError ret = surface_->SetDefaultUsage(0);
282 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
283 uint64_t value = surface_->GetDefaultUsage();
284 ASSERT_EQ(value, 0);
285 }
286
287 /*
288 * Function: SetDefaultUsage and GetDefaultUsage
289 * Type: Function
290 * Rank: Important(2)
291 * EnvConditions: N/A
292 * CaseDescription: 1. call GetDefaultUsage with normal
293 * 2. call SetDefaultUsage with normal
294 * 3. call GetDefaultUsage agagin
295 * 4. check ret
296 */
297 HWTEST_F(ConsumerSurfaceTest, DefaultUsage002, TestSize.Level0)
298 {
299 ASSERT_NE(cs, nullptr);
300 int32_t usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA;
301 uint32_t value = cs->GetDefaultUsage();
302 ASSERT_EQ(value, 0);
303 GSError ret = cs->SetDefaultUsage(usage);
304 ASSERT_EQ(ret, OHOS::GSERROR_OK);
305 value = cs->GetDefaultUsage();
306 ASSERT_EQ(value, usage);
307 }
308
309 /*
310 * Function: AcquireBuffer
311 * Type: Function
312 * Rank: Important(2)
313 * EnvConditions: N/A
314 * CaseDescription: 1. call AcquireBuffer with consumer_ is nullptr
315 * 2. check ret
316 */
317 HWTEST_F(ConsumerSurfaceTest, AcquireBuffer001, TestSize.Level0)
318 {
319 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
320 sptr<OHOS::SyncFence> fence;
321 GSError ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage);
322 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
323 }
324
325 /*
326 * Function: AcquireBuffer
327 * Type: Function
328 * Rank: Important(2)
329 * EnvConditions: N/A
330 * CaseDescription: 1. call AcquireBuffer with nullptr params
331 * 2. check ret
332 */
333 HWTEST_F(ConsumerSurfaceTest, AcquireBuffer002, TestSize.Level0)
334 {
335 sptr<SurfaceBuffer> buffer = nullptr;
336 sptr<OHOS::SyncFence> fence;
337 GSError ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage);
338 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
339 buffer = SurfaceBuffer::Create();
340 fence = nullptr;
341 ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage);
342 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
343 }
344
345 /*
346 * Function: ReleaseBuffer
347 * Type: Function
348 * Rank: Important(2)
349 * EnvConditions: N/A
350 * CaseDescription: 1. call ReleaseBuffer with consumer_ is nullptr
351 * 2. check ret
352 */
353 HWTEST_F(ConsumerSurfaceTest, ReleaseBuffer001, TestSize.Level0)
354 {
355 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
356 sptr<OHOS::SyncFence> fence;
357 GSError ret = surface_->ReleaseBuffer(buffer, fence);
358 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
359 }
360
361 /*
362 * Function: ReleaseBuffer
363 * Type: Function
364 * Rank: Important(2)
365 * EnvConditions: N/A
366 * CaseDescription: 1. call ReleaseBuffer with nullptr params
367 * 2. check ret
368 */
369 HWTEST_F(ConsumerSurfaceTest, ReleaseBuffer002, TestSize.Level0)
370 {
371 sptr<SurfaceBuffer> buffer = nullptr;
372 sptr<OHOS::SyncFence> fence;
373 GSError ret = surface_->ReleaseBuffer(buffer, fence);
374 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
375 }
376
377 /*
378 * Function: DetachBuffer
379 * Type: Function
380 * Rank: Important(2)
381 * EnvConditions: N/A
382 * CaseDescription: 1. call DetachBuffer with consumer_ is nullptr
383 * 2. check ret
384 */
385 HWTEST_F(ConsumerSurfaceTest, DetachBuffer001, TestSize.Level0)
386 {
387 sptr<SurfaceBuffer> buffer;
388 GSError ret = surface_->DetachBuffer(buffer);
389 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
390 }
391
392 /*
393 * Function: DetachBuffer
394 * Type: Function
395 * Rank: Important(2)
396 * EnvConditions: N/A
397 * CaseDescription: 1. call DetachBuffer with nullptr params
398 * 2. check ret
399 */
400 HWTEST_F(ConsumerSurfaceTest, DetachBuffer002, TestSize.Level0)
401 {
402 sptr<SurfaceBuffer> buffer = nullptr;
403 GSError ret = surface_->DetachBuffer(buffer);
404 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
405 }
406
407 /*
408 * Function: QueryIfBufferAvailable
409 * Type: Function
410 * Rank: Important(2)
411 * EnvConditions: N/A
412 * CaseDescription: 1. call QueryIfBufferAvailable with consumer_ is nullptr
413 * 2. check ret
414 */
415 HWTEST_F(ConsumerSurfaceTest, QueryIfBufferAvailable001, TestSize.Level0)
416 {
417 bool ret = surface_->QueryIfBufferAvailable();
418 ASSERT_EQ(ret, false);
419 }
420
421 /*
422 * Function: QueryIfBufferAvailable
423 * Type: Function
424 * Rank: Important(2)
425 * EnvConditions: N/A
426 * CaseDescription: 1. call QueryIfBufferAvailable with normal
427 * 2. check ret
428 */
429 HWTEST_F(ConsumerSurfaceTest, QueryIfBufferAvailable002, TestSize.Level0)
430 {
431 ASSERT_NE(cs, nullptr);
432 bool ret = cs->QueryIfBufferAvailable();
433 ASSERT_EQ(ret, true);
434 }
435
436 /*
437 * Function: RequestBuffer and FlushBuffer
438 * Type: Function
439 * Rank: Important(2)
440 * EnvConditions: N/A
441 * CaseDescription: 1. call RequestBuffer by cs and ps
442 * 2. call FlushBuffer both
443 * 3. check ret
444 */
445 HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel001, TestSize.Level0)
446 {
447 sptr<SurfaceBuffer> buffer;
448 int releaseFence = -1;
449
450 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
451 ASSERT_EQ(ret, OHOS::GSERROR_OK);
452 ASSERT_NE(buffer, nullptr);
453 firstSeqnum = buffer->GetSeqNum();
454
455 ret = ps->FlushBuffer(buffer, -1, flushConfig);
456 ASSERT_EQ(ret, OHOS::GSERROR_OK);
457
458 ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
459 ASSERT_EQ(ret, OHOS::GSERROR_OK);
460 ret = ps->FlushBuffer(buffer, -1, flushConfig);
461 ASSERT_EQ(ret, OHOS::GSERROR_OK);
462 }
463
464 /*
465 * Function: AcquireBuffer and ReleaseBuffer
466 * Type: Function
467 * Rank: Important(2)
468 * EnvConditions: N/A
469 * CaseDescription: 1. call AcquireBuffer
470 * 2. call ReleaseBuffer
471 * 3. check ret
472 */
473 HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel002, TestSize.Level0)
474 {
475 sptr<SurfaceBuffer> buffer;
476 int32_t flushFence;
477
478 GSError ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
479 ASSERT_EQ(ret, OHOS::GSERROR_OK);
480 ASSERT_NE(buffer, nullptr);
481
482 ret = cs->ReleaseBuffer(buffer, -1);
483 ASSERT_EQ(ret, OHOS::GSERROR_OK);
484 }
485
486 /*
487 * Function: AcquireBuffer and ReleaseBuffer
488 * Type: Function
489 * Rank: Important(2)
490 * EnvConditions: N/A
491 * CaseDescription: 1. call AcquireBuffer
492 * 2. call ReleaseBuffer 2 times
493 * 3. check ret
494 */
495 HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel003, TestSize.Level0)
496 {
497 sptr<SurfaceBuffer> buffer;
498 int32_t flushFence;
499
500 GSError ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
501 ASSERT_EQ(ret, OHOS::GSERROR_OK);
502 ASSERT_NE(buffer, nullptr);
503
504 ret = cs->ReleaseBuffer(buffer, -1);
505 ASSERT_EQ(ret, OHOS::GSERROR_OK);
506
507 ret = cs->ReleaseBuffer(buffer, -1);
508 ASSERT_NE(ret, OHOS::GSERROR_OK);
509 }
510
511 /*
512 * Function: GetLastConsumeTime
513 * Type: Function
514 * Rank: Important(2)
515 * EnvConditions: N/A
516 * CaseDescription: 1. call GetLastConsumeTime
517 * 2. check lastConsumeTime
518 */
519 HWTEST_F(ConsumerSurfaceTest, GetLastConsumeTimeTest, TestSize.Level0)
520 {
521 int64_t lastConsumeTime = 0;
522 cs->GetLastConsumeTime(lastConsumeTime);
523 std::cout << "lastConsumeTime = " << lastConsumeTime << std::endl;
524 ASSERT_NE(lastConsumeTime, 0);
525 }
526
527 /*
528 * Function: RequestBuffer and CancelBuffer
529 * Type: Function
530 * Rank: Important(2)
531 * EnvConditions: N/A
532 * CaseDescription: 1. call RequestBuffer by cs and ps
533 * 2. call CancelBuffer both
534 * 3. check ret
535 */
536 HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel004, TestSize.Level0)
537 {
538 sptr<SurfaceBuffer> buffer;
539 int releaseFence = -1;
540
541 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
542 ASSERT_EQ(ret, OHOS::GSERROR_OK);
543
544 ret = ps->CancelBuffer(buffer);
545 ASSERT_EQ(ret, OHOS::GSERROR_OK);
546 }
547
548 /*
549 * Function: SetUserData
550 * Type: Function
551 * Rank: Important(2)
552 * EnvConditions: N/A
553 * CaseDescription: 1. call SetUserData many times
554 * 2. check ret
555 */
556 HWTEST_F(ConsumerSurfaceTest, UserData001, TestSize.Level0)
557 {
558 GSError ret;
559
560 std::string strs[SURFACE_MAX_USER_DATA_COUNT];
561 constexpr int32_t stringLengthMax = 32;
562 char str[stringLengthMax] = {};
563 for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) {
564 auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%d", i);
565 ASSERT_GT(secRet, 0);
566
567 strs[i] = str;
568 ret = cs->SetUserData(strs[i], "magic");
569 ASSERT_EQ(ret, OHOS::GSERROR_OK);
570 }
571
572 ret = cs->SetUserData("-1", "error");
573 ASSERT_NE(ret, OHOS::GSERROR_OK);
574
575 std::string retStr;
576 for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) {
577 retStr = cs->GetUserData(strs[i]);
578 ASSERT_EQ(retStr, "magic");
579 }
580 }
581
582 /*
583 * Function: UserDataChangeListen
584 * Type: Function
585 * Rank: Important(2)
586 * EnvConditions: N/A
587 * CaseDescription: 1. RegisterUserDataChangeListen
588 * 2. SetUserData
589 * 3. check ret
590 */
591 HWTEST_F(ConsumerSurfaceTest, UserDataChangeListen001, TestSize.Level0)
592 {
593 sptr<IConsumerSurface> csTestUserData = IConsumerSurface::Create();
594 GSError ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
595 GSError ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
__anon899964ad0102(const std::string& key, const std::string& value) 596 auto func1 = [&ret1](const std::string& key, const std::string& value) {
597 ret1 = OHOS::GSERROR_OK;
598 };
__anon899964ad0202(const std::string& key, const std::string& value) 599 auto func2 = [&ret2](const std::string& key, const std::string& value) {
600 ret2 = OHOS::GSERROR_OK;
601 };
602 csTestUserData->RegisterUserDataChangeListener("func1", func1);
603 csTestUserData->RegisterUserDataChangeListener("func2", func2);
604 csTestUserData->RegisterUserDataChangeListener("func3", nullptr);
605 ASSERT_EQ(csTestUserData->RegisterUserDataChangeListener("func2", func2), OHOS::GSERROR_INVALID_ARGUMENTS);
606
607 if (csTestUserData->SetUserData("Regist", "OK") == OHOS::GSERROR_OK) {
608 ASSERT_EQ(ret1, OHOS::GSERROR_OK);
609 ASSERT_EQ(ret2, OHOS::GSERROR_OK);
610 }
611
612 ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
613 ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
614 csTestUserData->UnRegisterUserDataChangeListener("func1");
615 ASSERT_EQ(csTestUserData->UnRegisterUserDataChangeListener("func1"), OHOS::GSERROR_INVALID_ARGUMENTS);
616
617 if (csTestUserData->SetUserData("UnRegist", "INVALID") == OHOS::GSERROR_OK) {
618 ASSERT_EQ(ret1, OHOS::GSERROR_INVALID_ARGUMENTS);
619 ASSERT_EQ(ret2, OHOS::GSERROR_OK);
620 }
621
622 ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
623 ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
624 csTestUserData->ClearUserDataChangeListener();
625 csTestUserData->RegisterUserDataChangeListener("func1", func1);
626 if (csTestUserData->SetUserData("Clear", "OK") == OHOS::GSERROR_OK) {
627 ASSERT_EQ(ret1, OHOS::GSERROR_OK);
628 ASSERT_EQ(ret2, OHOS::GSERROR_INVALID_ARGUMENTS);
629 }
630 }
631
632 /*
633 * Function: UserDataChangeListen
634 * Type: Function
635 * Rank: Important(2)
636 * EnvConditions: N/A
637 * CaseDescription: 1. RegisterUserDataChangeListen
638 * 2. SetUserData
639 * 3. check ret
640 */
641 HWTEST_F(ConsumerSurfaceTest, UserDataChangeListen002, TestSize.Level0)
642 {
643 sptr<IConsumerSurface> csTestUserData = IConsumerSurface::Create();
644
__anon899964ad0302(const std::string& FuncName) 645 auto func = [&csTestUserData](const std::string& FuncName) {
646 constexpr int32_t registerListenerNum = 1000;
647 std::vector<GSError> ret(registerListenerNum, OHOS::GSERROR_INVALID_ARGUMENTS);
648 std::string strs[registerListenerNum];
649 constexpr int32_t stringLengthMax = 32;
650 char str[stringLengthMax] = {};
651 for (int i = 0; i < registerListenerNum; i++) {
652 auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%s%d", FuncName.c_str(), i);
653 ASSERT_GT(secRet, 0);
654 strs[i] = str;
655 ASSERT_EQ(csTestUserData->RegisterUserDataChangeListener(strs[i], [i, &ret]
656 (const std::string& key, const std::string& value) {
657 ret[i] = OHOS::GSERROR_OK;
658 }), OHOS::GSERROR_OK);
659 }
660
661 if (csTestUserData->SetUserData("Regist", FuncName) == OHOS::GSERROR_OK) {
662 for (int i = 0; i < registerListenerNum; i++) {
663 ASSERT_EQ(ret[i], OHOS::GSERROR_OK);
664 }
665 }
666
667 for (int i = 0; i < registerListenerNum; i++) {
668 csTestUserData->UnRegisterUserDataChangeListener(strs[i]);
669 }
670 };
671
672 std::thread t1(func, "thread1");
673 std::thread t2(func, "thread2");
674 t1.join();
675 t2.join();
676 }
677
678 /*
679 * Function: SetUserData
680 * Type: Function
681 * Rank: Important(2)
682 * EnvConditions: N/A
683 * CaseDescription: 1. call SetUserData many times
684 * 2. check ret
685 */
686 HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener001, TestSize.Level0)
687 {
688 class TestConsumerListener : public IBufferConsumerListener {
689 public:
OnBufferAvailable()690 void OnBufferAvailable() override
691 {
692 sptr<SurfaceBuffer> buffer;
693 int32_t flushFence;
694
695 cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
696 int32_t *p = (int32_t*)buffer->GetVirAddr();
697 if (p != nullptr) {
698 for (int32_t i = 0; i < 128; i++) {
699 ASSERT_EQ(p[i], i);
700 }
701 }
702
703 cs->ReleaseBuffer(buffer, -1);
704 }
705 };
706
707 sptr<IBufferConsumerListener> listener = new TestConsumerListener();
708 GSError ret = cs->RegisterConsumerListener(listener);
709 ASSERT_EQ(ret, OHOS::GSERROR_OK);
710
711 sptr<SurfaceBuffer> buffer;
712 int releaseFence = -1;
713 ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
714 ASSERT_EQ(ret, OHOS::GSERROR_OK);
715 ASSERT_NE(buffer, nullptr);
716
717 int32_t *p = (int32_t*)buffer->GetVirAddr();
718 if (p != nullptr) {
719 for (int32_t i = 0; i < 128; i++) {
720 p[i] = i;
721 }
722 }
723
724 GraphicTransformType tranformType = ps->GetTransform();
725 ret = ps->FlushBuffer(buffer, -1, flushConfig);
726 ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_180), OHOS::GSERROR_OK);
727 GraphicTransformType bufferTranformType = GraphicTransformType::GRAPHIC_ROTATE_NONE;
728 ASSERT_EQ(cs->GetSurfaceBufferTransformType(nullptr, &bufferTranformType), OHOS::SURFACE_ERROR_INVALID_PARAM);
729 ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, nullptr), OHOS::SURFACE_ERROR_INVALID_PARAM);
730 ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, &bufferTranformType), OHOS::GSERROR_OK);
731 ASSERT_EQ(bufferTranformType, tranformType);
732 ASSERT_EQ(ret, OHOS::GSERROR_OK);
733 listener->OnTunnelHandleChange();
734 listener->OnGoBackground();
735 listener->OnCleanCache(nullptr);
736 listener->OnTransformChange();
737 TestConsumerListenerClazz* listenerClazz = new TestConsumerListenerClazz();
738 listenerClazz->OnTunnelHandleChange();
739 listenerClazz->OnGoBackground();
740 listenerClazz->OnCleanCache(nullptr);
741 listenerClazz->OnTransformChange();
742 delete listenerClazz;
743 }
744
745 /*
746 * Function: RegisterConsumerListener, RequestBuffer and FlushBuffer
747 * Type: Function
748 * Rank: Important(2)
749 * EnvConditions: N/A
750 * CaseDescription: 1. call RegisterConsumerListener
751 * 2. call RequestBuffer
752 * 3. call FlushBuffer
753 * 4. check ret
754 */
755 HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener002, TestSize.Level0)
756 {
757 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
758 GSError ret = cs->RegisterConsumerListener(listener);
759 ASSERT_EQ(ret, OHOS::GSERROR_OK);
760
761 sptr<SurfaceBuffer> buffer;
762 int releaseFence = -1;
763 ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
764 ASSERT_EQ(ret, OHOS::GSERROR_OK);
765 ASSERT_NE(buffer, nullptr);
766
767 int32_t *p = (int32_t*)buffer->GetVirAddr();
768 if (p != nullptr) {
769 for (int32_t i = 0; i < requestConfig.width * requestConfig.height; i++) {
770 p[i] = i;
771 }
772 }
773 ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_90), OHOS::GSERROR_OK);
774 ret = ps->FlushBuffer(buffer, -1, flushConfig);
775 GraphicTransformType bufferTranformType = GraphicTransformType::GRAPHIC_ROTATE_NONE;
776 ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, &bufferTranformType), OHOS::GSERROR_OK);
777 ASSERT_EQ(bufferTranformType, GraphicTransformType::GRAPHIC_ROTATE_90);
778 ASSERT_EQ(ret, OHOS::GSERROR_OK);
779 ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_NONE), OHOS::GSERROR_OK);
780 sptr<OHOS::SyncFence> flushFence;
781 ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
782 ASSERT_EQ(ret, OHOS::GSERROR_OK);
783 ASSERT_NE(buffer, nullptr);
784 bool isInCache = false;
785 ASSERT_EQ(cs->IsSurfaceBufferInCache(buffer->GetSeqNum(), isInCache), OHOS::GSERROR_OK);
786 ASSERT_EQ(isInCache, true);
787 ASSERT_EQ(cs->IsSurfaceBufferInCache(0xFFFFFFFF, isInCache), OHOS::GSERROR_OK);
788 ASSERT_EQ(isInCache, false);
789 }
790
791 /*
792 * Function: RegisterConsumerListener
793 * Type: Function
794 * Rank: Important(2)
795 * EnvConditions: N/A
796 * CaseDescription: 1. call RegisterConsumerListener with nullptr params
797 * 2. check ret
798 */
799 HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener003, TestSize.Level0)
800 {
801 GSError ret = surface_->RegisterConsumerListener(nullptr);
802 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
803 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
804 ret = surface_->RegisterConsumerListener(listener);
805 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
806 }
807
808 /*
809 * Function: RegisterConsumerListener
810 * Type: Function
811 * Rank: Important(2)
812 * EnvConditions: N/A
813 * CaseDescription: 1. call RegisterConsumerListener with nullptr params
814 * 2. check ret
815 */
816 HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener004, TestSize.Level0)
817 {
818 GSError ret = surface_->RegisterConsumerListener(nullptr);
819 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
820 TestConsumerListenerClazz* listenerClazz = new TestConsumerListenerClazz();
821 ret = surface_->RegisterConsumerListener(listenerClazz);
822 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
823 delete listenerClazz;
824 }
825
826 /*
827 * Function: RegisterReleaseListener
828 * Type: Function
829 * Rank: Important(2)
830 * EnvConditions: N/A
831 * CaseDescription: 1. call RegisterReleaseListener with nullptr param
832 * 2. check ret
833 */
834 HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener001, TestSize.Level0)
835 {
836 OnReleaseFunc onBufferRelease = nullptr;
837 GSError ret = surface_->RegisterReleaseListener(onBufferRelease);
838 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
839 }
840
841 /*
842 * Function: RegisterReleaseListener
843 * Type: Function
844 * Rank: Important(2)
845 * EnvConditions: N/A
846 * CaseDescription: 1. call RegisterReleaseListener with consumer_ is normal
847 * 2. check ret
848 */
849 HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener002, TestSize.Level0)
850 {
851 sptr<BufferQueue> queue = new BufferQueue("test");
852 surface_->consumer_ = new BufferQueueConsumer(queue);
853 ASSERT_NE(surface_->consumer_, nullptr);
854 OnReleaseFunc onBufferRelease = nullptr;
855 GSError ret = surface_->RegisterReleaseListener(onBufferRelease);
856 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
857 }
858
859 /*
860 * Function: RegisterReleaseListener
861 * Type: Function
862 * Rank: Important(2)
863 * EnvConditions: N/A
864 * CaseDescription: 1. call RegisterReleaseListener
865 * 2. check ret
866 */
867 HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener003, TestSize.Level0)
868 {
869 OnReleaseFuncWithFence func = nullptr;
870 GSError ret = surface_->RegisterReleaseListener(func);
871 ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
872 }
873
874 /*
875 * Function: UnRegisterReleaseListener
876 * Type: Function
877 * Rank: Important(2)
878 * EnvConditions: N/A
879 * CaseDescription: 1. call UnRegisterReleaseListener
880 * 2. check ret
881 */
882 HWTEST_F(ConsumerSurfaceTest, UnRegisterReleaseListener001, TestSize.Level0)
883 {
884 GSError ret = surface_->UnRegisterReleaseListener();
885 ASSERT_EQ(ret, OHOS::GSERROR_OK);
886 }
887
888 /*
889 * Function: RegisterDeleteBufferListener
890 * Type: Function
891 * Rank: Important(2)
892 * EnvConditions: N/A
893 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is nullptr
894 * 2. check ret
895 */
896 HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener001, TestSize.Level0)
897 {
898 OnDeleteBufferFunc func = nullptr;
899 GSError ret = surface_->RegisterDeleteBufferListener(func, false);
900 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
901 }
902
903 /*
904 * Function: RegisterDeleteBufferListener
905 * Type: Function
906 * Rank: Important(2)
907 * EnvConditions: N/A
908 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
909 * 2. check ret
910 */
911 HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener002, TestSize.Level0)
912 {
913 sptr<BufferQueue> queue = new BufferQueue("test");
914 surface_->consumer_ = new BufferQueueConsumer(queue);
915 ASSERT_NE(surface_->consumer_, nullptr);
916 OnDeleteBufferFunc func = nullptr;
917 GSError ret = surface_->RegisterDeleteBufferListener(func, false);
918 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
919 ret = surface_->RegisterDeleteBufferListener(func, true);
920 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
921 }
922
923 /*
924 * Function: RegisterDeleteBufferListener
925 * Type: Function
926 * Rank: Important(2)
927 * EnvConditions: N/A
928 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
929 * 2. check ret
930 */
931 HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener003, TestSize.Level0)
932 {
933 sptr<BufferQueue> queue = new BufferQueue("test");
934 surface_->consumer_ = new BufferQueueConsumer(queue);
935 ASSERT_NE(surface_->consumer_, nullptr);
936 OnDeleteBufferFunc func = deleteBuffer;
937 GSError ret = surface_->RegisterDeleteBufferListener(func, false);
938 ASSERT_EQ(ret, OHOS::GSERROR_OK);
939 ASSERT_EQ(surface_->hasRegistercallBackForRT_, true);
940 }
941
942 /*
943 * Function: RegisterDeleteBufferListener
944 * Type: Function
945 * Rank: Important(2)
946 * EnvConditions: N/A
947 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
948 * 2. check ret
949 */
950 HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener004, TestSize.Level0)
951 {
952 sptr<BufferQueue> queue = new BufferQueue("test");
953 surface_->consumer_ = new BufferQueueConsumer(queue);
954 ASSERT_NE(surface_->consumer_, nullptr);
955 surface_->hasRegistercallBackForRT_ = true;
956 OnDeleteBufferFunc func = deleteBuffer;
957 GSError ret = surface_->RegisterDeleteBufferListener(func, false);
958 ASSERT_EQ(ret, OHOS::GSERROR_OK);
959 }
960
961 /*
962 * Function: RegisterDeleteBufferListener
963 * Type: Function
964 * Rank: Important(2)
965 * EnvConditions: N/A
966 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
967 * 2. check ret
968 */
969 HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener005, TestSize.Level0)
970 {
971 sptr<BufferQueue> queue = new BufferQueue("test");
972 surface_->consumer_ = new BufferQueueConsumer(queue);
973 ASSERT_NE(surface_->consumer_, nullptr);
974 OnDeleteBufferFunc func = deleteBuffer;
975 GSError ret = surface_->RegisterDeleteBufferListener(func, true);
976 ASSERT_EQ(ret, OHOS::GSERROR_OK);
977 ASSERT_EQ(surface_->hasRegistercallBackForRedraw_, true);
978 }
979
980 /*
981 * Function: RegisterDeleteBufferListener
982 * Type: Function
983 * Rank: Important(2)
984 * EnvConditions: N/A
985 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
986 * 2. check ret
987 */
988 HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener006, TestSize.Level0)
989 {
990 sptr<BufferQueue> queue = new BufferQueue("test");
991 surface_->consumer_ = new BufferQueueConsumer(queue);
992 ASSERT_NE(surface_->consumer_, nullptr);
993 surface_->hasRegistercallBackForRedraw_ = true;
994 OnDeleteBufferFunc func = deleteBuffer;
995 GSError ret = surface_->RegisterDeleteBufferListener(func, true);
996 ASSERT_EQ(ret, OHOS::GSERROR_OK);
997 }
998
999 /*
1000 * Function: UnregisterConsumerListener
1001 * Type: Function
1002 * Rank: Important(2)
1003 * EnvConditions: N/A
1004 * CaseDescription: 1. call UnregisterConsumerListener with consumer_ is nullptr
1005 * 2. check ret
1006 */
1007 HWTEST_F(ConsumerSurfaceTest, UnregisterConsumerListener001, TestSize.Level0)
1008 {
1009 GSError ret = surface_->UnregisterConsumerListener();
1010 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1011 }
1012
1013 /*
1014 * Function: UnregisterConsumerListener
1015 * Type: Function
1016 * Rank: Important(2)
1017 * EnvConditions: N/A
1018 * CaseDescription: 1. call UnregisterConsumerListener with consumer_ is normal
1019 * 2. check ret
1020 */
1021 HWTEST_F(ConsumerSurfaceTest, UnregisterConsumerListener002, TestSize.Level0)
1022 {
1023 sptr<BufferQueue> queue = new BufferQueue("test");
1024 surface_->consumer_ = new BufferQueueConsumer(queue);
1025 ASSERT_NE(surface_->consumer_, nullptr);
1026 GSError ret = surface_->UnregisterConsumerListener();
1027 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1028 }
1029
1030 /*
1031 * Function: RegisterUserDataChangeListener
1032 * Type: Function
1033 * Rank: Important(2)
1034 * EnvConditions: N/A
1035 * CaseDescription: 1. call RegisterUserDataChangeListener with nullptr param
1036 * 2. check ret
1037 */
1038 HWTEST_F(ConsumerSurfaceTest, RegisterUserDataChangeListener001, TestSize.Level0)
1039 {
1040 GSError ret = surface_->RegisterUserDataChangeListener("test", nullptr);
1041 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1042 }
1043
1044 /*
1045 * Function: GoBackground
1046 * Type: Function
1047 * Rank: Important(2)
1048 * EnvConditions: N/A
1049 * CaseDescription: 1. call GoBackground with consumer_ is nullptr
1050 * 2. check ret
1051 */
1052 HWTEST_F(ConsumerSurfaceTest, GoBackground001, TestSize.Level0)
1053 {
1054 GSError ret = surface_->GoBackground();
1055 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1056 }
1057
1058 /*
1059 * Function: GoBackground
1060 * Type: Function
1061 * Rank: Important(2)
1062 * EnvConditions: N/A
1063 * CaseDescription: 1. call GoBackground with consumer_ is normal
1064 * 2. check ret
1065 */
1066 HWTEST_F(ConsumerSurfaceTest, GoBackground002, TestSize.Level0)
1067 {
1068 sptr<BufferQueue> queue = new BufferQueue("test");
1069 surface_->consumer_ = new BufferQueueConsumer(queue);
1070 ASSERT_NE(surface_->consumer_, nullptr);
1071 GSError ret = surface_->GoBackground();
1072 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1073 surface_->producer_ = new BufferQueueProducer(queue);
1074 ASSERT_NE(surface_->producer_, nullptr);
1075 ret = surface_->GoBackground();
1076 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1077 }
1078
1079 /*
1080 * Function: GetUniqueId
1081 * Type: Function
1082 * Rank: Important(2)
1083 * EnvConditions: N/A
1084 * CaseDescription: 1. call GetUniqueId with producer_ is nullptr
1085 * 2. check ret
1086 */
1087 HWTEST_F(ConsumerSurfaceTest, GetUniqueId001, TestSize.Level0)
1088 {
1089 uint64_t ret = surface_->GetUniqueId();
1090 ASSERT_EQ(ret, 0);
1091 }
1092
1093 /*
1094 * Function: Dump
1095 * Type: Function
1096 * Rank: Important(2)
1097 * EnvConditions: N/A
1098 * CaseDescription: 1. call Dump
1099 * 2. check ret
1100 */
1101 HWTEST_F(ConsumerSurfaceTest, Dump001, TestSize.Level0)
1102 {
1103 std::string result;
1104 surface_->Dump(result);
1105 sptr<BufferQueue> queue = new BufferQueue("test");
1106 surface_->consumer_ = new BufferQueueConsumer(queue);
1107 ASSERT_NE(surface_->consumer_, nullptr);
1108 surface_->Dump(result);
1109 }
1110
1111 /*
1112 * Function: DumpCurrentFrameLayer
1113 * Type: Function
1114 * Rank: Important(2)
1115 * EnvConditions: N/A
1116 * CaseDescription: 1. call DumpCurrentFrameLayer
1117 * 2. check ret
1118 */
1119 HWTEST_F(ConsumerSurfaceTest, DumpCurrentFrameLayer001, Function | MediumTest | Level2)
1120 {
1121 surface_->DumpCurrentFrameLayer();
1122 sptr<BufferQueue> queue = new BufferQueue("test");
1123 surface_->consumer_ = new BufferQueueConsumer(queue);
1124 ASSERT_NE(surface_->consumer_, nullptr);
1125 }
1126
1127 /*
1128 * Function: SetTransform and GetTransform
1129 * Type: Function
1130 * Rank: Important(2)
1131 * EnvConditions: N/A
1132 * CaseDescription: 1. call GetTransform by default
1133 */
1134 HWTEST_F(ConsumerSurfaceTest, transform001, TestSize.Level0)
1135 {
1136 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_NONE);
1137 }
1138
1139 /*
1140 * Function: SetTransform and GetTransform
1141 * Type: Function
1142 * Rank: Important(1)
1143 * EnvConditions: N/A
1144 * CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
1145 * 2. check ret
1146 */
1147 HWTEST_F(ConsumerSurfaceTest, transform002, TestSize.Level0)
1148 {
1149 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_90;
1150 GSError ret = ps->SetTransform(transform);
1151 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1152 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_90);
1153 }
1154
1155 /*
1156 * Function: SetTransform and GetTransform
1157 * Type: Function
1158 * Rank: Important(1)
1159 * EnvConditions: N/A
1160 * CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
1161 * 2. check ret
1162 */
1163 HWTEST_F(ConsumerSurfaceTest, transform003, TestSize.Level0)
1164 {
1165 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_180;
1166 GSError ret = ps->SetTransform(transform);
1167 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1168 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_180);
1169 }
1170
1171 /*
1172 * Function: SetTransform and GetTransform
1173 * Type: Function
1174 * Rank: Important(1)
1175 * EnvConditions: N/A
1176 * CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
1177 * 2. check ret
1178 */
1179 HWTEST_F(ConsumerSurfaceTest, transform004, TestSize.Level0)
1180 {
1181 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_270;
1182 GSError ret = ps->SetTransform(transform);
1183 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1184 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_270);
1185 }
1186
1187 /*
1188 * Function: SetTransform and GetTransform
1189 * Type: Function
1190 * Rank: Important(1)
1191 * EnvConditions: N/A
1192 * CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
1193 * 2. check ret
1194 */
1195 HWTEST_F(ConsumerSurfaceTest, transform005, TestSize.Level0)
1196 {
1197 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_NONE;
1198 GSError ret = ps->SetTransform(transform);
1199 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1200 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_NONE);
1201 }
1202
1203 /*
1204 * Function: SetTransform and GetTransform
1205 * Type: Function
1206 * Rank: Important(1)
1207 * EnvConditions: N/A
1208 * CaseDescription: 1. call SetTransform GetTransform with nullptr
1209 * 2. check ret
1210 */
1211 HWTEST_F(ConsumerSurfaceTest, transform006, TestSize.Level0)
1212 {
1213 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_NONE;
1214 GSError ret = surface_->SetTransform(transform);
1215 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1216 ASSERT_EQ(surface_->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_BUTT);
1217 }
1218
1219 /*
1220 * Function: SetScalingMode and GetScalingMode
1221 * Type: Function
1222 * Rank: Important(2)
1223 * EnvConditions: N/A
1224 * CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret
1225 */
1226 HWTEST_F(ConsumerSurfaceTest, scalingMode001, TestSize.Level0)
1227 {
1228 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1229 GSError ret = cs->SetScalingMode(-1, scalingMode);
1230 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1231 ret = cs->GetScalingMode(-1, scalingMode);
1232 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1233 }
1234
1235 /*
1236 * Function: SetScalingMode and GetScalingMode
1237 * Type: Function
1238 * Rank: Important(1)
1239 * EnvConditions: N/A
1240 * CaseDescription: 1. call SetScalingMode with normal parameters and check ret
1241 * 2. call GetScalingMode and check ret
1242 */
1243 HWTEST_F(ConsumerSurfaceTest, scalingMode002, TestSize.Level0)
1244 {
1245 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1246 sptr<SurfaceBuffer> buffer;
1247 int releaseFence = -1;
1248 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1249 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1250 ASSERT_NE(buffer, nullptr);
1251
1252 uint32_t sequence = buffer->GetSeqNum();
1253 ret = cs->SetScalingMode(sequence, scalingMode);
1254 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1255
1256 ScalingMode scalingModeGet = ScalingMode::SCALING_MODE_FREEZE;
1257 ret = cs->GetScalingMode(sequence, scalingModeGet);
1258 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1259 ASSERT_EQ(scalingMode, scalingModeGet);
1260
1261 ret = ps->CancelBuffer(buffer);
1262 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1263 }
1264
1265 /*
1266 * Function: SetScalingMode003
1267 * Type: Function
1268 * Rank: Important(2)
1269 * EnvConditions: N/A
1270 * CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret
1271 */
1272 HWTEST_F(ConsumerSurfaceTest, scalingMode003, TestSize.Level0)
1273 {
1274 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1275 GSError ret = cs->SetScalingMode(scalingMode);
1276 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1277 }
1278
1279 /*
1280 * Function: SetScalingMode and GetScalingMode
1281 * Type: Function
1282 * Rank: Important(1)
1283 * EnvConditions: N/A
1284 * CaseDescription: 1. call SetScalingMode with nullptr and check ret
1285 * 2. call GetScalingMode with nullptr and check ret
1286 */
1287 HWTEST_F(ConsumerSurfaceTest, scalingMode004, TestSize.Level0)
1288 {
1289 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1290 GSError ret = surface_->SetScalingMode(firstSeqnum, scalingMode);
1291 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1292 ret = surface_->SetScalingMode(scalingMode);
1293 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1294 ret = surface_->GetScalingMode(firstSeqnum, scalingMode);
1295 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1296 }
1297
1298 /*
1299 * Function: QueryMetaDataType
1300 * Type: Function
1301 * Rank: Important(1)
1302 * EnvConditions: N/A
1303 * CaseDescription: 1. call QueryMetaDataType and check ret
1304 */
1305 HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType001, TestSize.Level0)
1306 {
1307 HDRMetaDataType type = HDRMetaDataType::HDR_META_DATA;
1308 GSError ret = cs->QueryMetaDataType(firstSeqnum, type);
1309 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1310 ASSERT_EQ(type, HDRMetaDataType::HDR_NOT_USED);
1311 }
1312
1313 /*
1314 * Function: QueryMetaDataType
1315 * Type: Function
1316 * Rank: Important(1)
1317 * EnvConditions: N/A
1318 * CaseDescription: 1. call SetMetaData with normal parameters and check ret
1319 * 2. call QueryMetaDataType and check ret
1320 */
1321 HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType002, TestSize.Level0)
1322 {
1323 std::vector<GraphicHDRMetaData> metaData;
1324 GraphicHDRMetaData data = {
1325 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1326 .value = 1,
1327 };
1328 metaData.push_back(data);
1329 GSError ret = cs->SetMetaData(firstSeqnum, metaData);
1330 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1331
1332 HDRMetaDataType type = HDRMetaDataType::HDR_NOT_USED;
1333 ret = cs->QueryMetaDataType(firstSeqnum, type);
1334 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1335 ASSERT_EQ(type, HDRMetaDataType::HDR_META_DATA);
1336 }
1337
1338 /*
1339 * Function: QueryMetaDataType
1340 * Type: Function
1341 * Rank: Important(1)
1342 * EnvConditions: N/A
1343 * CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
1344 * 2. call QueryMetaDataType and check ret
1345 */
1346 HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType003, TestSize.Level0)
1347 {
1348 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1349 std::vector<uint8_t> metaData;
1350 uint8_t data = 1;
1351 metaData.push_back(data);
1352 GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
1353 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1354
1355 HDRMetaDataType type = HDRMetaDataType::HDR_NOT_USED;
1356 ret = cs->QueryMetaDataType(firstSeqnum, type);
1357 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1358 ASSERT_EQ(type, HDRMetaDataType::HDR_META_DATA_SET);
1359 }
1360
1361 /*
1362 * Function: QueryMetaDataType
1363 * Type: Function
1364 * Rank: Important(1)
1365 * EnvConditions: N/A
1366 * CaseDescription: 1. call QueryMetaDataType with nullptr and check ret
1367 */
1368 HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType004, TestSize.Level0)
1369 {
1370 HDRMetaDataType type = HDRMetaDataType::HDR_META_DATA;
1371 GSError ret = surface_->QueryMetaDataType(firstSeqnum, type);
1372 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1373 }
1374
1375 /*
1376 * Function: SetMetaData and GetMetaData
1377 * Type: Function
1378 * Rank: Important(2)
1379 * EnvConditions: N/A
1380 * CaseDescription: 1. call SetMetaData with abnormal parameters and check ret
1381 */
1382 HWTEST_F(ConsumerSurfaceTest, metaData001, TestSize.Level0)
1383 {
1384 std::vector<GraphicHDRMetaData> metaData;
1385 GSError ret = cs->SetMetaData(firstSeqnum, metaData);
1386 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1387 }
1388
1389 /*
1390 * Function: SetMetaData and GetMetaData
1391 * Type: Function
1392 * Rank: Important(1)
1393 * EnvConditions: N/A
1394 * CaseDescription: 1. call SetMetaData with normal parameters and check ret
1395 */
1396 HWTEST_F(ConsumerSurfaceTest, metaData002, TestSize.Level0)
1397 {
1398 std::vector<GraphicHDRMetaData> metaData;
1399 GraphicHDRMetaData data = {
1400 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1401 .value = 100, // for test
1402 };
1403 metaData.push_back(data);
1404 GSError ret = cs->SetMetaData(firstSeqnum, metaData);
1405 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1406 }
1407
1408 /*
1409 * Function: SetMetaData and GetMetaData
1410 * Type: Function
1411 * Rank: Important(1)
1412 * EnvConditions: N/A
1413 * CaseDescription: 1. call SetMetaData with normal parameters and check ret
1414 * 2. call GetMetaData and check ret
1415 */
1416 HWTEST_F(ConsumerSurfaceTest, metaData003, TestSize.Level0)
1417 {
1418 std::vector<GraphicHDRMetaData> metaData;
1419 GraphicHDRMetaData data = {
1420 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1421 .value = 100, // for test
1422 };
1423 metaData.push_back(data);
1424
1425 sptr<SurfaceBuffer> buffer;
1426 int releaseFence = -1;
1427 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1428 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1429 ASSERT_NE(buffer, nullptr);
1430
1431 uint32_t sequence = buffer->GetSeqNum();
1432 ret = cs->SetMetaData(sequence, metaData);
1433 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1434
1435 std::vector<GraphicHDRMetaData> metaDataGet;
1436 ret = cs->GetMetaData(sequence, metaDataGet);
1437 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1438 ASSERT_EQ(metaData[0].key, metaDataGet[0].key);
1439 ASSERT_EQ(metaData[0].value, metaDataGet[0].value);
1440
1441 ret = cs->GetMetaData(sequence + 1, metaDataGet);
1442 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1443
1444 ret = ps->CancelBuffer(buffer);
1445 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1446 }
1447
1448 /*
1449 * Function: SetMetaData and GetMetaData
1450 * Type: Function
1451 * Rank: Important(2)
1452 * EnvConditions: N/A
1453 * CaseDescription: 1. call SetMetaData and GetMetaData with nullptr and check ret
1454 */
1455 HWTEST_F(ConsumerSurfaceTest, metaData004, TestSize.Level0)
1456 {
1457 std::vector<GraphicHDRMetaData> metaData;
1458 GSError ret = surface_->SetMetaData(firstSeqnum, metaData);
1459 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1460 ret = surface_->GetMetaData(firstSeqnum, metaData);
1461 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1462 }
1463
1464 /*
1465 * Function: SetMetaDataSet and GetMetaDataSet
1466 * Type: Function
1467 * Rank: Important(2)
1468 * EnvConditions: N/A
1469 * CaseDescription: 1. call SetMetaDataSet with abnormal parameters and check ret
1470 */
1471 HWTEST_F(ConsumerSurfaceTest, metaDataSet001, TestSize.Level0)
1472 {
1473 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1474 std::vector<uint8_t> metaData;
1475 GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
1476 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1477 }
1478
1479 /*
1480 * Function: SetMetaDataSet and GetMetaDataSet
1481 * Type: Function
1482 * Rank: Important(1)
1483 * EnvConditions: N/A
1484 * CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
1485 */
1486 HWTEST_F(ConsumerSurfaceTest, metaDataSet002, TestSize.Level0)
1487 {
1488 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1489 std::vector<uint8_t> metaData;
1490 uint8_t data = 10; // for test
1491 metaData.push_back(data);
1492 GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
1493 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1494 }
1495
1496 /*
1497 * Function: SetMetaDataSet and GetMetaDataSet
1498 * Type: Function
1499 * Rank: Important(1)
1500 * EnvConditions: N/A
1501 * CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
1502 * 2. call GetMetaDataSet and check ret
1503 */
1504 HWTEST_F(ConsumerSurfaceTest, metaDataSet003, TestSize.Level0)
1505 {
1506 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1507 std::vector<uint8_t> metaData;
1508 uint8_t data = 10; // for test
1509 metaData.push_back(data);
1510
1511 sptr<SurfaceBuffer> buffer;
1512 int releaseFence = -1;
1513 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1514 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1515 ASSERT_NE(buffer, nullptr);
1516
1517 uint32_t sequence = buffer->GetSeqNum();
1518 ret = cs->SetMetaDataSet(sequence, key, metaData);
1519 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1520
1521 GraphicHDRMetadataKey keyGet = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X;
1522 std::vector<uint8_t> metaDataGet;
1523 ret = cs->GetMetaDataSet(sequence, keyGet, metaDataGet);
1524 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1525 ASSERT_EQ(key, keyGet);
1526 ASSERT_EQ(metaData[0], metaDataGet[0]);
1527
1528 ret = cs->GetMetaDataSet(sequence + 1, keyGet, metaDataGet);
1529 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1530
1531 ret = ps->CancelBuffer(buffer);
1532 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1533 }
1534
1535 /*
1536 * Function: SetMetaDataSet and GetMetaDataSet
1537 * Type: Function
1538 * Rank: Important(2)
1539 * EnvConditions: N/A
1540 * CaseDescription: 1. call SetMetaDataSet and GetMetaDataSet with nullptr and check ret
1541 */
1542 HWTEST_F(ConsumerSurfaceTest, metaDataSet004, TestSize.Level0)
1543 {
1544 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1545 std::vector<uint8_t> metaData;
1546 GSError ret = surface_->SetMetaDataSet(firstSeqnum, key, metaData);
1547 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1548 ret = surface_->GetMetaDataSet(firstSeqnum, key, metaData);
1549 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1550 }
1551
1552 /*
1553 * Function: SetTunnelHandle and GetTunnelHandle
1554 * Type: Function
1555 * Rank: Important(2)
1556 * EnvConditions: N/A
1557 * CaseDescription: 1. call SetTunnelHandle with abnormal parameters and check ret
1558 */
1559 HWTEST_F(ConsumerSurfaceTest, TunnelHandle001, TestSize.Level0)
1560 {
1561 GraphicExtDataHandle *handle = nullptr;
1562 GSError ret = cs->SetTunnelHandle(handle);
1563 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1564 }
1565
1566 /*
1567 * Function: SetTunnelHandle and GetTunnelHandle
1568 * Type: Function
1569 * Rank: Important(2)
1570 * EnvConditions: N/A
1571 * CaseDescription: 1. call SetTunnelHandle with abnormal parameters and check ret
1572 */
1573 HWTEST_F(ConsumerSurfaceTest, TunnelHandle002, TestSize.Level0)
1574 {
1575 GraphicExtDataHandle *handle = nullptr;
1576 handle = new GraphicExtDataHandle();
1577 handle->fd = -1;
1578 handle->reserveInts = 0;
1579 GSError ret = cs->SetTunnelHandle(handle);
1580 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1581 }
1582
1583 /*
1584 * Function: SetTunnelHandle and GetTunnelHandle
1585 * Type: Function
1586 * Rank: Important(1)
1587 * EnvConditions: N/A
1588 * CaseDescription: 1. call SetTunnelHandle with normal parameters and check ret
1589 * 2. call GetTunnelHandle and check ret
1590 * @tc.require: issueI5GMZN issueI5IWHW
1591 */
1592 HWTEST_F(ConsumerSurfaceTest, TunnelHandle003, TestSize.Level0)
1593 {
1594 GraphicExtDataHandle *handle = static_cast<GraphicExtDataHandle *>(
1595 malloc(sizeof(GraphicExtDataHandle) + sizeof(int32_t)));
1596 handle->fd = -1;
1597 handle->reserveInts = 1;
1598 handle->reserve[0] = 0;
1599 GSError ret = cs->SetTunnelHandle(handle);
1600 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1601
1602 ret = cs->SetTunnelHandle(handle);
1603 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1604
1605 sptr<SurfaceTunnelHandle> handleGet = nullptr;
1606 handleGet = cs->GetTunnelHandle();
1607 ASSERT_NE(handleGet, nullptr);
1608 ASSERT_EQ(handle->fd, handleGet->GetHandle()->fd);
1609 ASSERT_EQ(handle->reserveInts, handleGet->GetHandle()->reserveInts);
1610 ASSERT_EQ(handle->reserve[0], handleGet->GetHandle()->reserve[0]);
1611 free(handle);
1612 }
1613
1614 /*
1615 * Function: SetTunnelHandle and GetTunnelHandle
1616 * Type: Function
1617 * Rank: Important(2)
1618 * EnvConditions: N/A
1619 * CaseDescription: 1. call SetTunnelHandle and GetTunnelHandle with nullptr and check ret
1620 */
1621 HWTEST_F(ConsumerSurfaceTest, TunnelHandle004, TestSize.Level0)
1622 {
1623 GraphicExtDataHandle *handle = nullptr;
1624 GSError ret = surface_->SetTunnelHandle(handle);
1625 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1626 sptr<SurfaceTunnelHandle> tunnelHandle = surface_->GetTunnelHandle();
1627 ASSERT_EQ(tunnelHandle, nullptr);
1628 }
1629
1630 /*
1631 * Function: SetPresentTimestamp and GetPresentTimestamp
1632 * Type: Function
1633 * Rank: Important(2)
1634 * EnvConditions: N/A
1635 * CaseDescription: 1. call SetPresentTimestamp with abnormal parameters and check ret
1636 * @tc.require: issueI5I57K
1637 */
1638 HWTEST_F(ConsumerSurfaceTest, presentTimestamp002, TestSize.Level0)
1639 {
1640 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_UNSUPPORTED, 0};
1641 GSError ret = cs->SetPresentTimestamp(-1, timestamp);
1642 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1643 }
1644
1645 /*
1646 * Function: SetPresentTimestamp and GetPresentTimestamp
1647 * Type: Function
1648 * Rank: Important(2)
1649 * EnvConditions: N/A
1650 * CaseDescription: 1. call SetPresentTimestamp with abnormal parameters and check ret
1651 * @tc.require: issueI5I57K
1652 */
1653 HWTEST_F(ConsumerSurfaceTest, presentTimestamp003, TestSize.Level0)
1654 {
1655 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_DELAY, 0};
1656 GSError ret = cs->SetPresentTimestamp(-1, timestamp);
1657 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1658 }
1659
1660 /*
1661 * Function: SetPresentTimestamp and GetPresentTimestamp
1662 * Type: Function
1663 * Rank: Important(1)
1664 * EnvConditions: N/A
1665 * CaseDescription: 1. call SetPresentTimestamp with normal parameters and check ret
1666 * @tc.require: issueI5I57K
1667 */
1668 HWTEST_F(ConsumerSurfaceTest, presentTimestamp004, TestSize.Level0)
1669 {
1670 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_DELAY, 0};
1671 GSError ret = cs->SetPresentTimestamp(firstSeqnum, timestamp);
1672 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1673 }
1674
1675 /*
1676 * Function: SetPresentTimestamp and GetPresentTimestamp
1677 * Type: Function
1678 * Rank: Important(1)
1679 * EnvConditions: N/A
1680 * CaseDescription: 1. call SetPresentTimestamp with normal parameters and check ret
1681 * @tc.require: issueI5I57K
1682 */
1683 HWTEST_F(ConsumerSurfaceTest, presentTimestamp005, TestSize.Level0)
1684 {
1685 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_TIMESTAMP, 0};
1686 GSError ret = cs->SetPresentTimestamp(firstSeqnum, timestamp);
1687 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1688 }
1689
1690 /*
1691 * Function: SetPresentTimestamp and GetPresentTimestamp
1692 * Type: Function
1693 * Rank: Important(1)
1694 * EnvConditions: N/A
1695 * CaseDescription: 1. call SetPresentTimestamp with nullptr and check ret
1696 */
1697 HWTEST_F(ConsumerSurfaceTest, presentTimestamp006, TestSize.Level0)
1698 {
1699 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_TIMESTAMP, 0};
1700 GSError ret = surface_->SetPresentTimestamp(firstSeqnum, timestamp);
1701 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1702 int64_t time = 0;
1703 ret = surface_->GetPresentTimestamp(firstSeqnum, GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_TIMESTAMP, time);
1704 ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
1705 }
1706
1707 /*
1708 * Function: AcquireBuffer and ReleaseBuffer
1709 * Type: Function
1710 * Rank: Important(2)
1711 * EnvConditions: N/A
1712 * CaseDescription: 1. call RequestBuffer and FlushBuffer
1713 * 2. call AcquireBuffer and ReleaseBuffer
1714 * 3. check ret
1715 */
1716 HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel005, TestSize.Level0)
1717 {
1718 sptr<SurfaceBuffer> buffer;
1719 int releaseFence = -1;
1720
1721 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1722 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1723 ASSERT_NE(buffer, nullptr);
1724
1725 ret = ps->FlushBuffer(buffer, SyncFence::INVALID_FENCE, flushConfigWithDamages);
1726 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1727
1728 sptr<OHOS::SyncFence> flushFence;
1729 ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damages);
1730 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1731 ASSERT_NE(buffer, nullptr);
1732 ASSERT_EQ(damages.size(), flushConfigWithDamages.damages.size());
1733 for (decltype(damages.size()) i = 0; i < damages.size(); i++) {
1734 ASSERT_EQ(damages[i].x, flushConfigWithDamages.damages[i].x);
1735 ASSERT_EQ(damages[i].y, flushConfigWithDamages.damages[i].y);
1736 ASSERT_EQ(damages[i].w, flushConfigWithDamages.damages[i].w);
1737 ASSERT_EQ(damages[i].h, flushConfigWithDamages.damages[i].h);
1738 }
1739
1740 ASSERT_EQ(timestamp, flushConfigWithDamages.timestamp);
1741 ret = cs->ReleaseBuffer(buffer, -1);
1742 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1743 }
1744
1745 /*
1746 * Function: AttachBuffer001
1747 * Type: Function
1748 * Rank: Important(2)
1749 * EnvConditions: N/A
1750 * CaseDescription: 1. call AttachBuffer
1751 * 2. check ret
1752 */
1753 HWTEST_F(ConsumerSurfaceTest, AttachBuffer001, TestSize.Level0)
1754 {
1755 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1756 ASSERT_NE(buffer, nullptr);
1757 GSError ret = cs->AttachBuffer(buffer);
1758 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1759 }
1760
1761 /*
1762 * Function: AttachBuffer002
1763 * Type: Function
1764 * Rank: Important(2)
1765 * EnvConditions: N/A
1766 * CaseDescription: 1. call AttachBuffer
1767 * 2. check ret
1768 */
1769 HWTEST_F(ConsumerSurfaceTest, AttachBuffer002, TestSize.Level0)
1770 {
1771 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1772 ASSERT_NE(buffer, nullptr);
1773 int32_t timeOut = 1;
1774 GSError ret = cs->AttachBuffer(buffer, timeOut);
1775 ASSERT_NE(ret, OHOS::GSERROR_OK);
1776 }
1777
1778 /*
1779 * Function: AttachBuffer003
1780 * Type: Function
1781 * Rank: Important(2)
1782 * EnvConditions: N/A
1783 * CaseDescription: 1. call AttachBuffer
1784 * 2. check ret
1785 */
1786 HWTEST_F(ConsumerSurfaceTest, AttachBuffer003, TestSize.Level0)
1787 {
1788 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1789 ASSERT_NE(buffer, nullptr);
1790 int32_t timeOut = 1;
1791 GSError ret = cs->AttachBuffer(buffer, timeOut);
1792 ASSERT_NE(ret, GSERROR_OK);
1793 }
1794
1795 /*
1796 * Function: AttachBuffer
1797 * Type: Function
1798 * Rank: Important(2)
1799 * EnvConditions: N/A
1800 * CaseDescription: 1. call AttachBuffer with nullptr params
1801 * 2. check ret
1802 */
1803 HWTEST_F(ConsumerSurfaceTest, AttachBuffer004, TestSize.Level0)
1804 {
1805 sptr<SurfaceBuffer> buffer = nullptr;
1806 GSError ret = surface_->AttachBuffer(buffer);
1807 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1808 }
1809
1810 /*
1811 * Function: AttachBuffer
1812 * Type: Function
1813 * Rank: Important(2)
1814 * EnvConditions: N/A
1815 * CaseDescription: 1. call AttachBuffer with nullptr params
1816 * 2. check ret
1817 */
1818 HWTEST_F(ConsumerSurfaceTest, AttachBuffer005, TestSize.Level0)
1819 {
1820 sptr<SurfaceBuffer> buffer = nullptr;
1821 int32_t timeOut = 1;
1822 GSError ret = surface_->AttachBuffer(buffer, timeOut);
1823 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1824 }
1825
1826 /*
1827 * Function: RegisterSurfaceDelegator
1828 * Type: Function
1829 * Rank: Important(2)
1830 * EnvConditions: N/A
1831 * CaseDescription: 1. call RegisterSurfaceDelegator
1832 * 2. check ret
1833 */
1834 HWTEST_F(ConsumerSurfaceTest, RegisterSurfaceDelegator001, TestSize.Level0)
1835 {
1836 GSError ret = cs->RegisterSurfaceDelegator(surfaceDelegator->AsObject());
1837 ASSERT_EQ(ret, GSERROR_OK);
1838 }
1839
1840 /*
1841 * Function: RegisterSurfaceDelegator
1842 * Type: Function
1843 * Rank: Important(2)
1844 * EnvConditions: N/A
1845 * CaseDescription: 1. call RegisterSurfaceDelegator with nullptr params
1846 * 2. check ret
1847 */
1848 HWTEST_F(ConsumerSurfaceTest, RegisterSurfaceDelegator002, TestSize.Level0)
1849 {
1850 GSError ret = surface_->RegisterSurfaceDelegator(nullptr);
1851 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1852 ASSERT_NE(surfaceDelegator, nullptr);
1853 sptr<IRemoteObject> client = surfaceDelegator->AsObject();
1854 ASSERT_NE(client, nullptr);
1855 ret = surface_->RegisterSurfaceDelegator(client);
1856 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1857 }
1858
1859 /*
1860 * Function: ConsumerRequestCpuAccess
1861 * Type: Function
1862 * Rank: Important(2)
1863 * EnvConditions: N/A
1864 * CaseDescription: 1. usage does not contain BUFFER_USAGE_CPU_HW_BOTH
1865 * 2. call ConsumerRequestCpuAccess(fasle/true)
1866 * 3. check ret
1867 */
1868 HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess001, TestSize.Level0)
1869 {
1870 using namespace HDI::Display::Graphic::Common;
1871 BufferRequestConfig config = {
1872 .width = 0x100,
1873 .height = 0x100,
1874 .strideAlignment = 0x8,
1875 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1876 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1877 .timeout = 0,
1878 };
1879 auto cSurface = IConsumerSurface::Create();
1880 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
1881 cSurface->RegisterConsumerListener(cListener);
1882 auto p = cSurface->GetProducer();
1883 auto pSurface = Surface::CreateSurfaceAsProducer(p);
1884
1885 // test default
1886 sptr<SurfaceBuffer> buffer;
1887 int releaseFence = -1;
1888 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1889 ASSERT_EQ(ret, GSERROR_OK);
1890 ASSERT_NE(buffer, nullptr);
1891
1892 std::vector<uint8_t> values;
1893 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1894 ASSERT_EQ(values.size(), 0);
1895
1896 ret = pSurface->CancelBuffer(buffer);
1897 ASSERT_EQ(ret, GSERROR_OK);
1898
1899 // test true
1900 cSurface->ConsumerRequestCpuAccess(true);
1901 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1902 ASSERT_EQ(ret, GSERROR_OK);
1903 ASSERT_NE(buffer, nullptr);
1904
1905 values.clear();
1906 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1907 ASSERT_EQ(values.size(), 0);
1908
1909 ret = pSurface->CancelBuffer(buffer);
1910 ASSERT_EQ(ret, GSERROR_OK);
1911
1912 // test false
1913 cSurface->ConsumerRequestCpuAccess(false);
1914 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1915 ASSERT_EQ(ret, GSERROR_OK);
1916 ASSERT_NE(buffer, nullptr);
1917
1918 values.clear();
1919 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1920 ASSERT_EQ(values.size(), 0);
1921
1922 ret = pSurface->CancelBuffer(buffer);
1923 ASSERT_EQ(ret, GSERROR_OK);
1924 }
1925
1926 /*
1927 * Function: ConsumerRequestCpuAccess
1928 * Type: Function
1929 * Rank: Important(2)
1930 * EnvConditions: N/A
1931 * CaseDescription: 1. usage contain BUFFER_USAGE_CPU_HW_BOTH
1932 * 2. call ConsumerRequestCpuAccess(true)
1933 * 3. check ret
1934 */
1935 HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess002, TestSize.Level0)
1936 {
1937 using namespace HDI::Display::Graphic::Common;
1938 BufferRequestConfig config = {
1939 .width = 0x100,
1940 .height = 0x100,
1941 .strideAlignment = 0x8,
1942 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1943 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH,
1944 .timeout = 0,
1945 };
1946 auto cSurface = IConsumerSurface::Create();
1947 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
1948 cSurface->RegisterConsumerListener(cListener);
1949 auto p = cSurface->GetProducer();
1950 auto pSurface = Surface::CreateSurfaceAsProducer(p);
1951
1952 // test default
1953 sptr<SurfaceBuffer> buffer;
1954 int releaseFence = -1;
1955 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1956 ASSERT_EQ(ret, GSERROR_OK);
1957 ASSERT_NE(buffer, nullptr);
1958
1959 std::vector<uint8_t> values;
1960 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1961 if (values.size() == 1) {
1962 ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_HW_ONLY);
1963 }
1964
1965 ret = pSurface->CancelBuffer(buffer);
1966 ASSERT_EQ(ret, GSERROR_OK);
1967
1968 // test true
1969 cSurface->ConsumerRequestCpuAccess(true);
1970 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1971 ASSERT_EQ(ret, GSERROR_OK);
1972 ASSERT_NE(buffer, nullptr);
1973
1974 values.clear();
1975 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1976 if (values.size() == 1) {
1977 ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_CPU_ACCESS);
1978 }
1979
1980 ret = pSurface->CancelBuffer(buffer);
1981 ASSERT_EQ(ret, GSERROR_OK);
1982
1983 // test false
1984 cSurface->ConsumerRequestCpuAccess(false);
1985 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1986 ASSERT_EQ(ret, GSERROR_OK);
1987 ASSERT_NE(buffer, nullptr);
1988
1989 values.clear();
1990 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1991 if (values.size() == 1) {
1992 ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_HW_ONLY);
1993 }
1994
1995 ret = pSurface->CancelBuffer(buffer);
1996 ASSERT_EQ(ret, GSERROR_OK);
1997 }
1998
1999 /*
2000 * Function: ConsumerRequestCpuAccess
2001 * Type: Function
2002 * Rank: Important(2)
2003 * EnvConditions: N/A
2004 * CaseDescription: 1. call ConsumerRequestCpuAccess with nullptr
2005 * 2. check ret
2006 */
2007 HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess003, TestSize.Level0)
2008 {
2009 ASSERT_NE(surface_, nullptr);
2010 surface_->ConsumerRequestCpuAccess(true);
2011 }
2012
2013 /*
2014 * Function: SetTransformHint and GetTransformHint
2015 * Type: Function
2016 * Rank: Important(1)
2017 * EnvConditions: N/A
2018 * CaseDescription: 1. call SetTransformHint with nullptr and check ret
2019 * 2. call GetTransformHint with nullptr and check ret
2020 */
2021 HWTEST_F(ConsumerSurfaceTest, transformHint001, TestSize.Level0)
2022 {
2023 GraphicTransformType typeSet = GraphicTransformType::GRAPHIC_ROTATE_BUTT;
2024 GSError ret = surface_->SetTransformHint(typeSet);
2025 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2026 GraphicTransformType typeGet = surface_->GetTransformHint();
2027 ASSERT_EQ(typeGet, GraphicTransformType::GRAPHIC_ROTATE_BUTT);
2028 }
2029
2030 /*
2031 * Function: SetSurfaceSourceType and GetSurfaceSourceType
2032 * Type: Function
2033 * Rank: Important(2)
2034 * EnvConditions: N/A
2035 * CaseDescription: 1. call SetSurfaceSourceType and check ret
2036 * 2. call GetSurfaceSourceType and check ret
2037 */
2038 HWTEST_F(ConsumerSurfaceTest, SurfaceSourceType001, TestSize.Level0)
2039 {
2040 OHSurfaceSource sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
2041 GSError ret = cs->SetSurfaceSourceType(sourceType);
2042 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2043 ASSERT_EQ(cs->GetSurfaceSourceType(), OH_SURFACE_SOURCE_VIDEO);
2044 }
2045
2046 /*
2047 * Function: SetSurfaceSourceType and GetSurfaceSourceType
2048 * Type: Function
2049 * Rank: Important(2)
2050 * EnvConditions: N/A
2051 * CaseDescription: 1. call SetSurfaceSourceType with nullptr and check ret
2052 * 2. call GetSurfaceSourceType with nullptr and check ret
2053 */
2054 HWTEST_F(ConsumerSurfaceTest, SurfaceSourceType002, TestSize.Level0)
2055 {
2056 OHSurfaceSource sourceTypeSet = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
2057 GSError ret = surface_->SetSurfaceSourceType(sourceTypeSet);
2058 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2059 OHSurfaceSource sourceTypeGet = surface_->GetSurfaceSourceType();
2060 ASSERT_EQ(sourceTypeGet, OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT);
2061 }
2062
2063 /*
2064 * Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
2065 * Type: Function
2066 * Rank: Important(2)
2067 * EnvConditions: N/A
2068 * CaseDescription: 1. call SetSurfaceAppFrameworkType and check ret
2069 * 2. call GetSurfaceAppFrameworkType and check ret
2070 */
2071 HWTEST_F(ConsumerSurfaceTest, SurfaceAppFrameworkType001, TestSize.Level0)
2072 {
2073 std::string type = "test";
2074 GSError ret = cs->SetSurfaceAppFrameworkType(type);
2075 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2076 ASSERT_EQ(cs->GetSurfaceAppFrameworkType(), "test");
2077 }
2078
2079 /*
2080 * Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
2081 * Type: Function
2082 * Rank: Important(2)
2083 * EnvConditions: N/A
2084 * CaseDescription: 1. call SetSurfaceAppFrameworkType with nullptr and check ret
2085 * 2. call GetSurfaceAppFrameworkType with nullptr and check ret
2086 */
2087 HWTEST_F(ConsumerSurfaceTest, SurfaceAppFrameworkType002, TestSize.Level0)
2088 {
2089 std::string type = "test";
2090 GSError ret = surface_->SetSurfaceAppFrameworkType(type);
2091 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2092 ASSERT_EQ(surface_->GetSurfaceAppFrameworkType(), "");
2093 }
2094
2095 /*
2096 * Function: GetHdrWhitePointBrightness and GetSdrWhitePointBrightness
2097 * Type: Function
2098 * Rank: Important(2)
2099 * EnvConditions: N/A
2100 * CaseDescription: 1. call GetHdrWhitePointBrightness with nullptr and check ret
2101 * 2. call GetSdrWhitePointBrightness with nullptr and check ret
2102 */
2103 HWTEST_F(ConsumerSurfaceTest, WhitePointBrightness001, TestSize.Level0)
2104 {
2105 float ret = surface_->GetHdrWhitePointBrightness();
2106 ASSERT_EQ(static_cast<int32_t>(ret), 0);
2107 ret = surface_->GetSdrWhitePointBrightness();
2108 ASSERT_EQ(static_cast<int32_t>(ret), 0);
2109 }
2110
2111 /*
2112 * Function: InvalidParameter
2113 * Type: Function
2114 * Rank: Important(2)
2115 * EnvConditions: N/A
2116 * CaseDescription: 1. call interface with invaild input nullptr and check ret
2117 */
2118 HWTEST_F(ConsumerSurfaceTest, InvalidParameter001, TestSize.Level0)
2119 {
2120 sptr<OHOS::SurfaceBuffer> sBuffer = nullptr;
2121 sptr<OHOS::SyncFence> fence = nullptr;
2122 ASSERT_EQ(surface_->AcquireLastFlushedBuffer(sBuffer, fence, nullptr, 0, false), GSERROR_NOT_SUPPORT);
2123 ASSERT_EQ(surface_->ReleaseLastFlushedBuffer(sBuffer), GSERROR_NOT_SUPPORT);
2124 }
2125
2126 /*
2127 * Function: GetGlobalAlpha
2128 * Type: Function
2129 * Rank: Important(2)
2130 * EnvConditions: N/A
2131 * CaseDescription: 1. call GetGlobalAlpha and check ret
2132 */
2133 HWTEST_F(ConsumerSurfaceTest, GetGlobalAlpha001, TestSize.Level0)
2134 {
2135 int32_t alpha = -1;
2136 ASSERT_EQ(cs->SetGlobalAlpha(alpha), GSERROR_NOT_SUPPORT);
2137 ASSERT_EQ(cs->GetGlobalAlpha(alpha), GSERROR_OK);
2138 }
2139
2140 /*
2141 * Function: AttachBufferToQueue
2142 * Type: Function
2143 * Rank: Important(2)
2144 * EnvConditions: N/A
2145 * CaseDescription: 1. call AttachBufferToQueue and check ret
2146 */
2147 HWTEST_F(ConsumerSurfaceTest, AttachBufferToQueueMemLeak, TestSize.Level0)
2148 {
2149 BufferRequestConfig config = {
2150 .width = 0x100,
2151 .height = 0x100,
2152 .strideAlignment = 0x8,
2153 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
2154 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH,
2155 .timeout = 0,
2156 };
2157 auto cSurface = IConsumerSurface::Create();
2158 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
2159 cSurface->RegisterConsumerListener(cListener);
2160 auto p = cSurface->GetProducer();
2161 auto pSurface = Surface::CreateSurfaceAsProducer(p);
2162
2163 sptr<SurfaceBuffer> buffer;
2164 int releaseFence = -1;
2165 BufferFlushConfig flushConfigTmp = {
2166 .damage = {
2167 .w = 0x100,
2168 .h = 0x100,
2169 },
2170 };
2171 int64_t timestampTmp = 0;
2172 Rect damageTmp = {};
2173 GSError ret;
2174 sptr<OHOS::SyncFence> fence;
2175 for (uint32_t i = 0; i < 3; i++) {
2176 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
2177 ASSERT_EQ(ret, GSERROR_OK);
2178 ASSERT_NE(buffer, nullptr);
2179 ret = pSurface->FlushBuffer(buffer, -1, flushConfigTmp);
2180 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2181 }
2182
2183 for (uint32_t i = 0; i < 3; i++) {
2184 ret = cSurface->AcquireBuffer(buffer, fence, timestampTmp, damageTmp);
2185 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2186 ret = cSurface->DetachBufferFromQueue(buffer);
2187 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2188 }
2189 for (uint32_t i = 0; i < 3; i++) {
2190 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
2191 ASSERT_EQ(ret, GSERROR_OK);
2192 }
2193 }
2194
2195 /*
2196 * Function: GetLastFlushedDesiredPresentTimeStamp
2197 * Type: Function
2198 * Rank: Important(2)
2199 * EnvConditions: N/A
2200 * CaseDescription: 1. call GetLastFlushedDesiredPresentTimeStamp and check ret
2201 */
2202 HWTEST_F(ConsumerSurfaceTest, GetLastFlushedDesiredPresentTimeStamp001, TestSize.Level0)
2203 {
2204 int64_t lastFlushedDesiredPresentTimeStamp = -1;
2205 ASSERT_EQ(cs->GetLastFlushedDesiredPresentTimeStamp(lastFlushedDesiredPresentTimeStamp), GSERROR_OK);
2206 }
2207
2208 /**
2209 * Function: GetFrontDesiredPresentTimeStamp001
2210 * Type: Function
2211 * Rank: Important(2)
2212 * EnvConditions: N/A
2213 * CaseDescription: 1. call GetFrontDesiredPresentTimeStamp and check ret
2214 */
2215 HWTEST_F(ConsumerSurfaceTest, GetFrontDesiredPresentTimeStamp001, Function | MediumTest | Level2)
2216 {
2217 int64_t desiredPresentTimeStamp = -1;
2218 bool isAutoTimeStamp = false;
2219 bq->dirtyList_.clear();
2220 bq->bufferQueueCache_.clear();
2221 ASSERT_EQ(bq->GetFrontDesiredPresentTimeStamp(desiredPresentTimeStamp, isAutoTimeStamp), GSERROR_NO_BUFFER);
2222 }
2223
2224 /**
2225 * Function: GetFrontDesiredPresentTimeStamp002
2226 * Type: Function
2227 * Rank: Important(2)
2228 * EnvConditions: N/A
2229 * CaseDescription: 1. call GetFrontDesiredPresentTimeStamp and check ret
2230 */
2231 HWTEST_F(ConsumerSurfaceTest, GetFrontDesiredPresentTimeStamp002, Function | MediumTest | Level2)
2232 {
2233 sptr<ConsumerSurface> tmpConsumerSurface = new ConsumerSurface("test");
2234 int64_t desiredPresentTimeStamp = -1;
2235 bool isAutoTimeStamp = false;
2236 EXPECT_EQ(tmpConsumerSurface->GetFrontDesiredPresentTimeStamp(desiredPresentTimeStamp, isAutoTimeStamp),
2237 SURFACE_ERROR_UNKOWN);
2238
2239 sptr<BufferQueue> queue = nullptr;
2240 tmpConsumerSurface->consumer_ = new BufferQueueConsumer(queue);
2241 EXPECT_EQ(tmpConsumerSurface->GetFrontDesiredPresentTimeStamp(desiredPresentTimeStamp, isAutoTimeStamp),
2242 SURFACE_ERROR_UNKOWN);
2243 }
2244
2245 /**
2246 * Function: GetFrontDesiredPresentTimeStamp003
2247 * Type: Function
2248 * Rank: Important(2)
2249 * EnvConditions: N/A
2250 * CaseDescription: 1. call GetFrontDesiredPresentTimeStamp and check ret
2251 */
2252 HWTEST_F(ConsumerSurfaceTest, GetFrontDesiredPresentTimeStamp003, Function | MediumTest | Level2)
2253 {
2254 sptr<ConsumerSurface> tmpConsumerSurface = new ConsumerSurface("test");
2255 sptr<BufferQueue> queue = new BufferQueue("test");
2256 tmpConsumerSurface->consumer_ = new BufferQueueConsumer(queue);
2257
2258 uint32_t sequence = 1;
2259 int64_t desiredPresentTimeStamp = -1;
2260 bool isAutoTimeStamp = false;
2261 queue->dirtyList_.push_back(sequence);
2262 EXPECT_EQ(tmpConsumerSurface->GetFrontDesiredPresentTimeStamp(desiredPresentTimeStamp, isAutoTimeStamp),
2263 GSERROR_NO_BUFFER);
2264 }
2265
2266 /*
2267 * Function: GetBufferSupportFastCompose
2268 * Type: Function
2269 * Rank: Important(2)
2270 * EnvConditions: N/A
2271 * CaseDescription: 1. call GetBufferSupportFastCompose and check ret
2272 */
2273 HWTEST_F(ConsumerSurfaceTest, GetBufferSupportFastCompose001, TestSize.Level0)
2274 {
2275 bool supportFastCompose = false;
2276 bool supportFastComposeStoreValue = false;
2277 sptr<BufferQueue> queue = new BufferQueue("test");
2278 surface_->consumer_ = new BufferQueueConsumer(queue);
2279 surface_->isFirstBuffer_.store(true);
2280 ASSERT_EQ(surface_->GetBufferSupportFastCompose(supportFastCompose), GSERROR_OK);
2281 ASSERT_EQ(surface_->isFirstBuffer_.load(), false);
2282 surface_->supportFastCompose_.store(supportFastComposeStoreValue);
2283 ASSERT_EQ(surface_->GetBufferSupportFastCompose(supportFastCompose), GSERROR_OK);
2284 ASSERT_EQ(supportFastCompose, supportFastComposeStoreValue);
2285 }
2286
2287 /*
2288 * Function: GetBufferCacheConfig001
2289 * Type: Function
2290 * Rank: Important(2)
2291 * EnvConditions: N/A
2292 * CaseDescription: 1. call GetBufferCacheConfig and check config
2293 */
2294 HWTEST_F(ConsumerSurfaceTest, GetBufferCacheConfig001, TestSize.Level0)
2295 {
2296 BufferRequestConfig config = {
2297 .width = 0x100,
2298 .height = 0x100,
2299 .strideAlignment = 0x8,
2300 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
2301 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH,
2302 .timeout = 0,
2303 };
2304 auto cSurface = IConsumerSurface::Create();
2305 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
2306 cSurface->RegisterConsumerListener(cListener);
2307 auto p = cSurface->GetProducer();
2308 auto pSurface = Surface::CreateSurfaceAsProducer(p);
2309
2310 sptr<SurfaceBuffer> buffer;
2311 int releaseFence = -1;
2312 BufferFlushConfig flushConfigTmp = {
2313 .damage = {
2314 .w = 0x100,
2315 .h = 0x100,
2316 },
2317 };
2318 int64_t timestampTmp = 0;
2319 Rect damageTmp = {};
2320 sptr<OHOS::SyncFence> fence;
2321
2322 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, config);
2323 ASSERT_EQ(ret, GSERROR_OK);
2324 ASSERT_NE(buffer, nullptr);
2325 ret = pSurface->FlushBuffer(buffer, -1, flushConfigTmp);
2326 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2327
2328 ret = cSurface->AcquireBuffer(buffer, fence, timestampTmp, damageTmp);
2329 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2330
2331 BufferRequestConfig cacheConfig;
2332 ret = cSurface->GetBufferCacheConfig(buffer, cacheConfig);
2333 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2334 ASSERT_EQ(cacheConfig == config, true);
2335
2336 sptr<SurfaceBuffer> bufferTmp;
2337 ret = cSurface->GetBufferCacheConfig(bufferTmp, cacheConfig);
2338 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2339
2340 pSurface->CleanCache(true);
2341 ret = cSurface->GetBufferCacheConfig(buffer, cacheConfig);
2342 ASSERT_EQ(ret, OHOS::GSERROR_BUFFER_NOT_INCACHE);
2343 }
2344
2345 /*
2346 * Function: GetAndSetRotatingBuffersNumber001
2347 * Type: Function
2348 * Rank: Important(2)
2349 * EnvConditions: N/A
2350 * CaseDescription: 1. call GetCycleBuffersNumber and SetCycleBuffersNumber function and check ret
2351 */
2352 HWTEST_F(ConsumerSurfaceTest, GetAndSetRotatingBuffersNumber001, TestSize.Level0)
2353 {
2354 auto cSurface = IConsumerSurface::Create();
2355 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
2356 cSurface->RegisterConsumerListener(cListener);
2357 auto p = cSurface->GetProducer();
2358 auto pSurface = Surface::CreateSurfaceAsProducer(p);
2359
2360 uint32_t cycleBuffersNumber = 0;
2361 ASSERT_EQ(cSurface->GetCycleBuffersNumber(cycleBuffersNumber), OHOS::GSERROR_OK);
2362 ASSERT_EQ(cycleBuffersNumber, cSurface->GetQueueSize());
2363 ASSERT_EQ(pSurface->SetCycleBuffersNumber(128), OHOS::GSERROR_OK); // 128 : normal num
2364 ASSERT_EQ(cSurface->GetCycleBuffersNumber(cycleBuffersNumber), OHOS::GSERROR_OK);
2365 ASSERT_EQ(cycleBuffersNumber, 128); // 128 : normal num
2366
2367 pSurface = nullptr;
2368 cSurface = nullptr;
2369 }
2370
2371 /*
2372 * Function: GetAndSetFrameGravity001
2373 * Type: Function
2374 * Rank: Important(2)
2375 * EnvConditions: N/A
2376 * CaseDescription: 1. Test IPC and producer-consumer process for frameGravity.
2377 Call GetFrameGravity and SetFrameGravity function and check ret
2378 */
2379 HWTEST_F(ConsumerSurfaceTest, GetAndSetFrameGravity001, TestSize.Level0)
2380 {
2381 auto cSurface = IConsumerSurface::Create();
2382 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
2383 cSurface->RegisterConsumerListener(cListener);
2384 auto p = cSurface->GetProducer();
2385 auto pSurface = Surface::CreateSurfaceAsProducer(p);
2386
2387 int32_t frameGravity = 0;
2388 ASSERT_EQ(cSurface->GetFrameGravity(frameGravity), OHOS::GSERROR_OK);
2389 ASSERT_EQ(frameGravity, -1);
2390 ASSERT_EQ(pSurface->SetFrameGravity(-2), OHOS::GSERROR_INVALID_ARGUMENTS); // -2 : error num
2391 ASSERT_EQ(pSurface->SetFrameGravity(16), OHOS::GSERROR_INVALID_ARGUMENTS); // 16 : error num
2392 ASSERT_EQ(pSurface->SetFrameGravity(15), OHOS::GSERROR_OK); // 15 : normal num
2393 ASSERT_EQ(cSurface->GetFrameGravity(frameGravity), OHOS::GSERROR_OK);
2394 ASSERT_EQ(frameGravity, 15); // 15 : normal num
2395
2396 pSurface = nullptr;
2397 cSurface = nullptr;
2398 }
2399
2400 /*
2401 * Function: GetAndSetFixedRotation001
2402 * Type: Function
2403 * Rank: Important(2)
2404 * EnvConditions: N/A
2405 * CaseDescription: 1. Test IPC and producer-consumer process for fixedRotation.
2406 Call GetFixedRotation and SetFixedRotation function and check ret.
2407 */
2408 HWTEST_F(ConsumerSurfaceTest, GetAndSetFixedRotation001, TestSize.Level0)
2409 {
2410 auto cSurface = IConsumerSurface::Create();
2411 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
2412 cSurface->RegisterConsumerListener(cListener);
2413 auto p = cSurface->GetProducer();
2414 auto pSurface = Surface::CreateSurfaceAsProducer(p);
2415
2416 int32_t fixedRotation = 0;
2417 ASSERT_EQ(cSurface->GetFixedRotation(fixedRotation), OHOS::GSERROR_OK);
2418 ASSERT_EQ(fixedRotation, -1);
2419 ASSERT_EQ(pSurface->SetFixedRotation(-2), OHOS::GSERROR_INVALID_ARGUMENTS); // -2 : error num
2420 ASSERT_EQ(pSurface->SetFixedRotation(2), OHOS::GSERROR_INVALID_ARGUMENTS); // 2 : error num
2421 ASSERT_EQ(pSurface->SetFixedRotation(1), OHOS::GSERROR_OK); // 1 : normal num
2422 ASSERT_EQ(cSurface->GetFixedRotation(fixedRotation), OHOS::GSERROR_OK);
2423 ASSERT_EQ(fixedRotation, 1); // 1 : normal num
2424
2425 pSurface = nullptr;
2426 cSurface = nullptr;
2427 }
2428
2429 /*
2430 * Function: DetachBufferFromQueueIsReserveSlot001
2431 * Type: Function
2432 * Rank: Important(2)
2433 * EnvConditions: N/A
2434 * CaseDescription: 1. call AttachBufferToQueue and DetachBufferFromQueue set isReserveSlot true function and check ret
2435 */
2436 HWTEST_F(ConsumerSurfaceTest, DetachBufferFromQueueIsReserveSlot001, TestSize.Level0)
2437 {
2438 auto cSurface = IConsumerSurface::Create();
2439 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
2440 cSurface->RegisterConsumerListener(cListener);
2441 auto p = cSurface->GetProducer();
2442 auto pSurface = Surface::CreateSurfaceAsProducer(p);
2443
2444 GSError ret = cSurface->SetQueueSize(5);
2445 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2446
2447 sptr<SurfaceBuffer> buffer;
2448 int releaseFence = -1;
2449 BufferFlushConfig flushConfigTmp = {
2450 .damage = {
2451 .w = 0x100,
2452 .h = 0x100,
2453 },
2454 };
2455 BufferRequestConfig config = {
2456 .width = 0x100,
2457 .height = 0x100,
2458 .strideAlignment = 0x8,
2459 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
2460 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH,
2461 .timeout = 0,
2462 };
2463 int64_t timestampTmp = 0;
2464 Rect damageTmp = {};
2465 sptr<OHOS::SyncFence> fence;
2466
2467 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
2468 ASSERT_EQ(ret, GSERROR_OK);
2469 ASSERT_NE(buffer, nullptr);
2470 ret = pSurface->FlushBuffer(buffer, -1, flushConfigTmp);
2471 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2472
2473 ret = cSurface->AcquireBuffer(buffer, fence, timestampTmp, damageTmp);
2474 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2475
2476 ret = cSurface->DetachBufferFromQueue(buffer, true);
2477 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2478
2479 for (uint32_t i = 0; i < 4; i++) {
2480 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
2481 ASSERT_EQ(ret, GSERROR_OK);
2482 }
2483
2484 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
2485 ASSERT_EQ(ret, GSERROR_NO_BUFFER);
2486
2487 pSurface = nullptr;
2488 cSurface = nullptr;
2489 }
2490
2491 /*
2492 * Function: DetachBufferFromQueueIsReserveSlot002
2493 * Type: Function
2494 * Rank: Important(2)
2495 * EnvConditions: N/A
2496 * CaseDescription: 1. call AttachBufferToQueue and DetachBufferFromQueue set isReserveSlot true function and check ret
2497 */
2498 HWTEST_F(ConsumerSurfaceTest, DetachBufferFromQueueIsReserveSlot002, TestSize.Level0)
2499 {
2500 auto cSurface = IConsumerSurface::Create();
2501 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
2502 cSurface->RegisterConsumerListener(cListener);
2503 auto p = cSurface->GetProducer();
2504 auto pSurface = Surface::CreateSurfaceAsProducer(p);
2505
2506 GSError ret = cSurface->SetQueueSize(5);
2507 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2508
2509 sptr<SurfaceBuffer> buffer[6];
2510 int releaseFence = -1;
2511 BufferFlushConfig flushConfigTmp = {
2512 .damage = {
2513 .w = 0x100,
2514 .h = 0x100,
2515 },
2516 };
2517 BufferRequestConfig config = {
2518 .width = 0x100,
2519 .height = 0x100,
2520 .strideAlignment = 0x8,
2521 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
2522 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH,
2523 .timeout = 0,
2524 };
2525 int64_t timestampTmp = 0;
2526 Rect damageTmp = {};
2527 sptr<OHOS::SyncFence> fence;
2528
2529 for (uint32_t i = 0; i < 5; i++) {
2530 ret = pSurface->RequestBuffer(buffer[i], releaseFence, config);
2531 ASSERT_EQ(ret, GSERROR_OK);
2532 ASSERT_NE(buffer[i], nullptr);
2533 ret = pSurface->FlushBuffer(buffer[i], -1, flushConfigTmp);
2534 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2535 }
2536
2537 ret = pSurface->RequestBuffer(buffer[5], releaseFence, config);
2538 ASSERT_EQ(ret, GSERROR_NO_BUFFER);
2539
2540 sptr<SurfaceBuffer> acquireBuffer;
2541 ret = cSurface->AcquireBuffer(acquireBuffer, fence, timestampTmp, damageTmp);
2542 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2543
2544 ret = cSurface->DetachBufferFromQueue(acquireBuffer, true);
2545 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2546
2547 ret = pSurface->RequestBuffer(buffer[5], releaseFence, config);
2548 ASSERT_EQ(ret, GSERROR_NO_BUFFER);
2549
2550 ret = cSurface->AttachBufferToQueue(acquireBuffer);
2551 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2552
2553 ret = pSurface->RequestBuffer(buffer[5], releaseFence, config);
2554 ASSERT_EQ(ret, GSERROR_NO_BUFFER);
2555
2556 ret = cSurface->ReleaseBuffer(acquireBuffer, fence);
2557 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2558
2559 ret = pSurface->RequestBuffer(buffer[5], releaseFence, config);
2560 ASSERT_EQ(ret, GSERROR_OK);
2561
2562 pSurface = nullptr;
2563 cSurface = nullptr;
2564 }
2565
2566 /*
2567 * Function: DetachBufferFromQueueIsReserveSlot003
2568 * Type: Function
2569 * Rank: Important(2)
2570 * EnvConditions: N/A
2571 * CaseDescription: 1. call AttachBufferToQueue and DetachBufferFromQueue set isReserveSlot true function and check ret
2572 */
2573 HWTEST_F(ConsumerSurfaceTest, DetachBufferFromQueueIsReserveSlot003, TestSize.Level0)
2574 {
2575 auto cSurface = IConsumerSurface::Create();
2576 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
2577 cSurface->RegisterConsumerListener(cListener);
2578 auto p = cSurface->GetProducer();
2579 auto pSurface = Surface::CreateSurfaceAsProducer(p);
2580
2581 GSError ret = cSurface->SetQueueSize(5);
2582 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2583
2584 sptr<SurfaceBuffer> buffer[6];
2585 int releaseFence = -1;
2586 BufferFlushConfig flushConfigTmp = {
2587 .damage = {
2588 .w = 0x100,
2589 .h = 0x100,
2590 },
2591 };
2592 BufferRequestConfig config = {
2593 .width = 0x100,
2594 .height = 0x100,
2595 .strideAlignment = 0x8,
2596 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
2597 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH,
2598 .timeout = 0,
2599 };
2600 int64_t timestampTmp = 0;
2601 Rect damageTmp = {};
2602 sptr<OHOS::SyncFence> fence;
2603
2604 for (uint32_t i = 0; i < 5; i++) {
2605 ret = pSurface->RequestBuffer(buffer[i], releaseFence, config);
2606 ASSERT_EQ(ret, GSERROR_OK);
2607 ASSERT_NE(buffer[i], nullptr);
2608 ret = pSurface->FlushBuffer(buffer[i], -1, flushConfigTmp);
2609 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2610 }
2611
2612 ret = pSurface->RequestBuffer(buffer[5], releaseFence, config);
2613 ASSERT_EQ(ret, GSERROR_NO_BUFFER);
2614
2615 sptr<SurfaceBuffer> acquireBuffer[6];
2616 for (uint32_t i = 0; i < 4; i++)
2617 {
2618 ret = cSurface->AcquireBuffer(acquireBuffer[i], fence, timestampTmp, damageTmp);
2619 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2620
2621 ret = cSurface->DetachBufferFromQueue(acquireBuffer[i], true);
2622 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2623 }
2624 ret = cSurface->SetQueueSize(3);
2625 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2626
2627 ret = cSurface->SetQueueSize(4);
2628 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2629
2630 pSurface = nullptr;
2631 cSurface = nullptr;
2632 }
2633
2634 /*
2635 * Function: SetMaxQueueSizeAndGetMaxQueueSize001
2636 * Type: Function
2637 * Rank: Important(2)
2638 * EnvConditions: N/A
2639 * CaseDescription: 1. call SetMaxQueueSize and GetMaxQueueSize function and check ret
2640 */
2641 HWTEST_F(ConsumerSurfaceTest, SetMaxQueueSizeAndGetMaxQueueSize001, TestSize.Level0)
2642 {
2643 auto cSurface = IConsumerSurface::Create();
2644 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
2645 cSurface->RegisterConsumerListener(cListener);
2646
2647 ASSERT_EQ(cSurface->SetMaxQueueSize(0), OHOS::GSERROR_INVALID_ARGUMENTS);
2648 ASSERT_EQ(cSurface->SetMaxQueueSize(SURFACE_MAX_QUEUE_SIZE + 1), OHOS::GSERROR_INVALID_ARGUMENTS);
2649 ASSERT_EQ(cSurface->SetQueueSize(2), OHOS::GSERROR_OK);
2650 ASSERT_EQ(cSurface->GetQueueSize(), 2);
2651 ASSERT_EQ(cSurface->SetMaxQueueSize(1), OHOS::GSERROR_OK);
2652 ASSERT_EQ(cSurface->GetQueueSize(), 1);
2653 ASSERT_EQ(cSurface->SetQueueSize(2), OHOS::GSERROR_OK);
2654 ASSERT_EQ(cSurface->GetQueueSize(), 1);
2655 ASSERT_EQ(cSurface->SetMaxQueueSize(2), OHOS::GSERROR_OK);
2656 ASSERT_EQ(cSurface->GetQueueSize(), 1);
2657
2658 cSurface = nullptr;
2659 }
2660
2661 /*
2662 * Function: AcquireBuffer and ReleaseBuffer
2663 * Type: Function
2664 * Rank: Important(2)
2665 * EnvConditions: N/A
2666 * CaseDescription: 1. call RequestBuffer and FlushBuffer
2667 * 2. call AcquireBuffer and ReleaseBuffer
2668 * 3. check ret
2669 */
2670 HWTEST_F(ConsumerSurfaceTest, ReleaseBufferWithSequence001, TestSize.Level0)
2671 {
2672 sptr<IConsumerSurface> csTmp = IConsumerSurface::Create();
2673 sptr<IBufferConsumerListener> listenerTmp = new BufferConsumerListener();
2674 csTmp->RegisterConsumerListener(listenerTmp);
2675 auto pTmp = csTmp->GetProducer();
2676 sptr<BufferQueue> bqTmp = new BufferQueue("test");
2677 sptr<Surface> psTmp = Surface::CreateSurfaceAsProducer(pTmp);
2678
2679 sptr<SurfaceBuffer> buffer;
2680 int releaseFence = -1;
2681
2682 GSError ret = psTmp->RequestBuffer(buffer, releaseFence, requestConfig);
2683 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2684 ASSERT_NE(buffer, nullptr);
2685
2686 ret = psTmp->FlushBuffer(buffer, SyncFence::INVALID_FENCE, flushConfigWithDamages);
2687 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2688
2689 IConsumerSurface::AcquireBufferReturnValue returnValue = {
2690 .buffer = nullptr,
2691 .fence = new SyncFence(-1),
2692 };
2693 ret = csTmp->AcquireBuffer(returnValue);
2694 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2695 ASSERT_NE(returnValue.buffer, nullptr);
2696 ASSERT_EQ(damages.size(), flushConfigWithDamages.damages.size());
2697 for (decltype(damages.size()) i = 0; i < damages.size(); i++) {
2698 ASSERT_EQ(damages[i].x, flushConfigWithDamages.damages[i].x);
2699 ASSERT_EQ(damages[i].y, flushConfigWithDamages.damages[i].y);
2700 ASSERT_EQ(damages[i].w, flushConfigWithDamages.damages[i].w);
2701 ASSERT_EQ(damages[i].h, flushConfigWithDamages.damages[i].h);
2702 }
2703
2704 ASSERT_EQ(returnValue.timestamp, flushConfigWithDamages.timestamp);
2705 ret = csTmp->ReleaseBuffer(returnValue.buffer, returnValue.fence);
2706 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2707 }
2708
2709 /*
2710 * Function: AcquireBuffer
2711 * Type: Function
2712 * Rank: Important(2)
2713 * EnvConditions: N/A
2714 * CaseDescription: 1. call RequestBuffer and check ret
2715 */
2716 HWTEST_F(ConsumerSurfaceTest, AcquireBufferByReturnValue, TestSize.Level0)
2717 {
2718 surface_ = new ConsumerSurface("test");
2719 ASSERT_NE(surface_, nullptr);
2720
2721 IConsumerSurface::AcquireBufferReturnValue returnValue;
2722 GSError ret = surface_->AcquireBuffer(returnValue);
2723 ASSERT_EQ(ret, OHOS::SURFACE_ERROR_UNKOWN);
2724
2725 surface_ = nullptr;
2726 }
2727
2728 /*
2729 * Function: ReleaseBuffer
2730 * Type: Function
2731 * Rank: Important(2)
2732 * EnvConditions: N/A
2733 * CaseDescription: 1. call ReleaseBuffer and check ret
2734 */
2735 HWTEST_F(ConsumerSurfaceTest, ReleaseBufferBySeq, TestSize.Level0)
2736 {
2737 surface_ = new ConsumerSurface("test");
2738 ASSERT_NE(surface_, nullptr);
2739 uint32_t sequence = 0;
2740 sptr<SyncFence> fence = new SyncFence(-1);
2741 GSError ret = surface_->ReleaseBuffer(sequence, fence);
2742 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2743
2744 sequence = 1;
2745 surface_->consumer_ = nullptr;
2746 ret = surface_->ReleaseBuffer(sequence, fence);
2747 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2748 surface_ = nullptr;
2749 }
2750
2751 /*
2752 * Function: SetIsActiveGame
2753 * Type: Function
2754 * Rank: Important(2)
2755 * EnvConditions: N/A
2756 * CaseDescription: 1. call SetIsActiveGame and check ret
2757 */
2758 HWTEST_F(ConsumerSurfaceTest, SetIsActiveGame001, TestSize.Level0)
2759 {
2760 surface_ = new ConsumerSurface("test");
2761 ASSERT_NE(surface_, nullptr);
2762 bool isTransactonActiveGame = false;
2763 // consumer_ is nullptr
2764 surface_->consumer_ = nullptr;
2765 surface_->SetIsActiveGame(isTransactonActiveGame);
2766 // consumer_ is not nullptr
2767 sptr<BufferQueue> queue = new BufferQueue("test");
2768 surface_->consumer_ = new BufferQueueConsumer(queue);
2769 surface_->SetIsActiveGame(isTransactonActiveGame);
2770 queue = nullptr;
2771 surface_->consumer_ = nullptr;
2772 surface_ = nullptr;
2773 }
2774
2775 /*
2776 * Function: GetAlphaType
2777 * Type: Function
2778 * Rank: Important(2)
2779 * EnvConditions: N/A
2780 * CaseDescription: GetAlphaType
2781 */
2782 HWTEST_F(ConsumerSurfaceTest, GetAlphaTypeTest, TestSize.Level0)
2783 {
2784 GraphicAlphaType alphaType;
2785 surface_ = new ConsumerSurface("test");
2786 ASSERT_NE(surface_, nullptr);
2787
2788 // consumer_ is nullptr
2789 surface_->consumer_ = nullptr;
2790 ASSERT_EQ(surface_->GetAlphaType(alphaType), SURFACE_ERROR_UNKOWN);
2791 // consumer_ is not nullptr
2792 sptr<BufferQueue> bufferQueue1 = nullptr;
2793 surface_->consumer_ = new BufferQueueConsumer(bufferQueue1);
2794 ASSERT_EQ(surface_->GetAlphaType(alphaType), SURFACE_ERROR_UNKOWN);
2795
2796 sptr<BufferQueue> tmpBq = new BufferQueue("test");
2797 surface_->consumer_ = new BufferQueueConsumer(tmpBq);
2798 ASSERT_NE(surface_->GetAlphaType(alphaType), SURFACE_ERROR_UNKOWN);
2799 surface_ = nullptr;
2800 }
2801
2802 /*
2803 * Function: SetLppDrawSource
2804 * Type: Function
2805 * Rank: Important(2)
2806 * EnvConditions: N/A
2807 * CaseDescription: acquire lpp buffer
2808 */
2809 HWTEST_F(ConsumerSurfaceTest, SetLppDrawSource001, TestSize.Level0)
2810 {
2811 bool isShbDrawLpp = false;
2812 bool isRsDrawLpp = false;
2813 surface_ = new ConsumerSurface("test");
2814 ASSERT_NE(surface_, nullptr);
2815
2816 // consumer_ is nullptr
2817 surface_->consumer_ = nullptr;
2818 ASSERT_EQ(surface_->SetLppDrawSource(isShbDrawLpp, isRsDrawLpp), SURFACE_ERROR_UNKOWN);
2819 // consumer_ is not nullptr
2820 sptr<BufferQueue> bufferQueue1 = nullptr;
2821 surface_->consumer_ = new BufferQueueConsumer(bufferQueue1);
2822 ASSERT_EQ(surface_->SetLppDrawSource(isShbDrawLpp, isRsDrawLpp), SURFACE_ERROR_UNKOWN);
2823 surface_ = nullptr;
2824 }
2825
2826 /*
2827 * Function: SetIsPriorityAlloc
2828 * Type: Function
2829 * Rank: Important(2)
2830 * EnvConditions: N/A
2831 * CaseDescription: 1. call SetIsPriorityAlloc and check ret
2832 */
2833 HWTEST_F(ConsumerSurfaceTest, SetIsPriorityAlloc001, TestSize.Level0)
2834 {
2835 surface_ = new ConsumerSurface("test");
2836 ASSERT_NE(surface_, nullptr);
2837 bool isPriorityAlloc = false;
2838 // consumer_ is nullptr
2839 surface_->consumer_ = nullptr;
2840 surface_->SetIsPriorityAlloc(isPriorityAlloc);
2841 // consumer_ is not nullptr
2842 sptr<BufferQueue> queue = new BufferQueue("test");
2843 surface_->consumer_ = new BufferQueueConsumer(queue);
2844 surface_->SetIsPriorityAlloc(isPriorityAlloc);
2845 queue = nullptr;
2846 surface_->consumer_ = nullptr;
2847 }
2848 }
2849