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