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", false);
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", false);
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", false);
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: RequestBuffer and CancelBuffer
510 * Type: Function
511 * Rank: Important(2)
512 * EnvConditions: N/A
513 * CaseDescription: 1. call RequestBuffer by cs and ps
514 *                  2. call CancelBuffer both
515 *                  3. check ret
516  */
517 HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel004, Function | MediumTest | Level2)
518 {
519     sptr<SurfaceBuffer> buffer;
520     int releaseFence = -1;
521 
522     GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
523     ASSERT_EQ(ret, OHOS::GSERROR_OK);
524 
525     ret = ps->CancelBuffer(buffer);
526     ASSERT_EQ(ret, OHOS::GSERROR_OK);
527 }
528 
529 /*
530 * Function: SetUserData
531 * Type: Function
532 * Rank: Important(2)
533 * EnvConditions: N/A
534 * CaseDescription: 1. call SetUserData many times
535 *                  2. check ret
536  */
537 HWTEST_F(ConsumerSurfaceTest, UserData001, Function | MediumTest | Level2)
538 {
539     GSError ret;
540 
541     std::string strs[SURFACE_MAX_USER_DATA_COUNT];
542     constexpr int32_t stringLengthMax = 32;
543     char str[stringLengthMax] = {};
544     for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) {
545         auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%d", i);
546         ASSERT_GT(secRet, 0);
547 
548         strs[i] = str;
549         ret = cs->SetUserData(strs[i], "magic");
550         ASSERT_EQ(ret, OHOS::GSERROR_OK);
551     }
552 
553     ret = cs->SetUserData("-1", "error");
554     ASSERT_NE(ret, OHOS::GSERROR_OK);
555 
556     std::string retStr;
557     for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) {
558         retStr = cs->GetUserData(strs[i]);
559         ASSERT_EQ(retStr, "magic");
560     }
561 }
562 
563 /*
564 * Function: UserDataChangeListen
565 * Type: Function
566 * Rank: Important(2)
567 * EnvConditions: N/A
568 * CaseDescription: 1. RegisterUserDataChangeListen
569 *                  2. SetUserData
570 *                  3. check ret
571  */
572 HWTEST_F(ConsumerSurfaceTest, UserDataChangeListen001, Function | MediumTest | Level2)
573 {
574     sptr<IConsumerSurface> csTestUserData = IConsumerSurface::Create();
575     GSError ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
576     GSError ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
__anona5ac71430102(const std::string& key, const std::string& value) 577     auto func1 = [&ret1](const std::string& key, const std::string& value) {
578         ret1 = OHOS::GSERROR_OK;
579     };
__anona5ac71430202(const std::string& key, const std::string& value) 580     auto func2 = [&ret2](const std::string& key, const std::string& value) {
581         ret2 = OHOS::GSERROR_OK;
582     };
583     csTestUserData->RegisterUserDataChangeListener("func1", func1);
584     csTestUserData->RegisterUserDataChangeListener("func2", func2);
585     csTestUserData->RegisterUserDataChangeListener("func3", nullptr);
586     ASSERT_EQ(csTestUserData->RegisterUserDataChangeListener("func2", func2), OHOS::GSERROR_INVALID_ARGUMENTS);
587 
588     if (csTestUserData->SetUserData("Regist", "OK") == OHOS::GSERROR_OK) {
589         ASSERT_EQ(ret1, OHOS::GSERROR_OK);
590         ASSERT_EQ(ret2, OHOS::GSERROR_OK);
591     }
592 
593     ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
594     ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
595     csTestUserData->UnRegisterUserDataChangeListener("func1");
596     ASSERT_EQ(csTestUserData->UnRegisterUserDataChangeListener("func1"), OHOS::GSERROR_INVALID_ARGUMENTS);
597 
598     if (csTestUserData->SetUserData("UnRegist", "INVALID") == OHOS::GSERROR_OK) {
599         ASSERT_EQ(ret1, OHOS::GSERROR_INVALID_ARGUMENTS);
600         ASSERT_EQ(ret2, OHOS::GSERROR_OK);
601     }
602 
603     ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
604     ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
605     csTestUserData->ClearUserDataChangeListener();
606     csTestUserData->RegisterUserDataChangeListener("func1", func1);
607     if (csTestUserData->SetUserData("Clear", "OK") == OHOS::GSERROR_OK) {
608         ASSERT_EQ(ret1, OHOS::GSERROR_OK);
609         ASSERT_EQ(ret2, OHOS::GSERROR_INVALID_ARGUMENTS);
610     }
611 }
612 
613 /*
614 * Function: UserDataChangeListen
615 * Type: Function
616 * Rank: Important(2)
617 * EnvConditions: N/A
618 * CaseDescription: 1. RegisterUserDataChangeListen
619 *                  2. SetUserData
620 *                  3. check ret
621  */
622 HWTEST_F(ConsumerSurfaceTest, UserDataChangeListen002, Function | MediumTest | Level2)
623 {
624     sptr<IConsumerSurface> csTestUserData = IConsumerSurface::Create();
625 
__anona5ac71430302(const std::string& FuncName) 626     auto func = [&csTestUserData](const std::string& FuncName) {
627         constexpr int32_t RegisterListenerNum = 1000;
628         std::vector<GSError> ret(RegisterListenerNum, OHOS::GSERROR_INVALID_ARGUMENTS);
629         std::string strs[RegisterListenerNum];
630         constexpr int32_t stringLengthMax = 32;
631         char str[stringLengthMax] = {};
632         for (int i = 0; i < RegisterListenerNum; i++) {
633             auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%s%d", FuncName.c_str(), i);
634             ASSERT_GT(secRet, 0);
635             strs[i] = str;
636             ASSERT_EQ(csTestUserData->RegisterUserDataChangeListener(strs[i], [i, &ret]
637             (const std::string& key, const std::string& value) {
638                 ret[i] = OHOS::GSERROR_OK;
639             }), OHOS::GSERROR_OK);
640         }
641 
642         if (csTestUserData->SetUserData("Regist", FuncName) == OHOS::GSERROR_OK) {
643             for (int i = 0; i < RegisterListenerNum; i++) {
644                 ASSERT_EQ(ret[i], OHOS::GSERROR_OK);
645             }
646         }
647 
648         for (int i = 0; i < RegisterListenerNum; i++) {
649             csTestUserData->UnRegisterUserDataChangeListener(strs[i]);
650         }
651     };
652 
653     std::thread t1(func, "thread1");
654     std::thread t2(func, "thread2");
655     t1.join();
656     t2.join();
657 }
658 
659 /*
660 * Function: SetUserData
661 * Type: Function
662 * Rank: Important(2)
663 * EnvConditions: N/A
664 * CaseDescription: 1. call SetUserData many times
665 *                  2. check ret
666  */
667 HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener001, Function | MediumTest | Level2)
668 {
669     class TestConsumerListener : public IBufferConsumerListener {
670     public:
OnBufferAvailable()671         void OnBufferAvailable() override
672         {
673             sptr<SurfaceBuffer> buffer;
674             int32_t flushFence;
675 
676             cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
677             int32_t *p = (int32_t*)buffer->GetVirAddr();
678             if (p != nullptr) {
679                 for (int32_t i = 0; i < 128; i++) {
680                     ASSERT_EQ(p[i], i);
681                 }
682             }
683 
684             cs->ReleaseBuffer(buffer, -1);
685         }
686     };
687 
688     sptr<IBufferConsumerListener> listener = new TestConsumerListener();
689     GSError ret = cs->RegisterConsumerListener(listener);
690     ASSERT_EQ(ret, OHOS::GSERROR_OK);
691 
692     sptr<SurfaceBuffer> buffer;
693     int releaseFence = -1;
694     ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
695     ASSERT_EQ(ret, OHOS::GSERROR_OK);
696     ASSERT_NE(buffer, nullptr);
697 
698     int32_t *p = (int32_t*)buffer->GetVirAddr();
699     if (p != nullptr) {
700         for (int32_t i = 0; i < 128; i++) {
701             p[i] = i;
702         }
703     }
704 
705     GraphicTransformType tranformType = ps->GetTransform();
706     ret = ps->FlushBuffer(buffer, -1, flushConfig);
707     ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_180), OHOS::GSERROR_OK);
708     GraphicTransformType bufferTranformType = GraphicTransformType::GRAPHIC_ROTATE_NONE;
709     ASSERT_EQ(cs->GetSurfaceBufferTransformType(nullptr, &bufferTranformType), OHOS::SURFACE_ERROR_INVALID_PARAM);
710     ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, nullptr), OHOS::SURFACE_ERROR_INVALID_PARAM);
711     ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, &bufferTranformType), OHOS::GSERROR_OK);
712     ASSERT_EQ(bufferTranformType, tranformType);
713     ASSERT_EQ(ret, OHOS::GSERROR_OK);
714     listener->OnTunnelHandleChange();
715     listener->OnGoBackground();
716     listener->OnCleanCache();
717     listener->OnTransformChange();
718     TestConsumerListenerClazz* listenerClazz = new TestConsumerListenerClazz();
719     listenerClazz->OnTunnelHandleChange();
720     listenerClazz->OnGoBackground();
721     listenerClazz->OnCleanCache();
722     listenerClazz->OnTransformChange();
723     delete listenerClazz;
724 }
725 
726 /*
727 * Function: RegisterConsumerListener, RequestBuffer and FlushBuffer
728 * Type: Function
729 * Rank: Important(2)
730 * EnvConditions: N/A
731 * CaseDescription: 1. call RegisterConsumerListener
732 *                  2. call RequestBuffer
733 *                  3. call FlushBuffer
734 *                  4. check ret
735  */
736 HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener002, Function | MediumTest | Level2)
737 {
738     sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
739     GSError ret = cs->RegisterConsumerListener(listener);
740     ASSERT_EQ(ret, OHOS::GSERROR_OK);
741 
742     sptr<SurfaceBuffer> buffer;
743     int releaseFence = -1;
744     ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
745     ASSERT_EQ(ret, OHOS::GSERROR_OK);
746     ASSERT_NE(buffer, nullptr);
747 
748     int32_t *p = (int32_t*)buffer->GetVirAddr();
749     if (p != nullptr) {
750         for (int32_t i = 0; i < requestConfig.width * requestConfig.height; i++) {
751             p[i] = i;
752         }
753     }
754     ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_90), OHOS::GSERROR_OK);
755     ret = ps->FlushBuffer(buffer, -1, flushConfig);
756     GraphicTransformType bufferTranformType = GraphicTransformType::GRAPHIC_ROTATE_NONE;
757     ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, &bufferTranformType), OHOS::GSERROR_OK);
758     ASSERT_EQ(bufferTranformType, GraphicTransformType::GRAPHIC_ROTATE_90);
759     ASSERT_EQ(ret, OHOS::GSERROR_OK);
760     ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_NONE), OHOS::GSERROR_OK);
761     sptr<OHOS::SyncFence> flushFence;
762     ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
763     ASSERT_EQ(ret, OHOS::GSERROR_OK);
764     ASSERT_NE(buffer, nullptr);
765     bool isInCache = false;
766     ASSERT_EQ(cs->IsSurfaceBufferInCache(buffer->GetSeqNum(), isInCache), OHOS::GSERROR_OK);
767     ASSERT_EQ(isInCache, true);
768     ASSERT_EQ(cs->IsSurfaceBufferInCache(0xFFFFFFFF, isInCache), OHOS::GSERROR_OK);
769     ASSERT_EQ(isInCache, false);
770 }
771 
772 /*
773 * Function: RegisterConsumerListener
774 * Type: Function
775 * Rank: Important(2)
776 * EnvConditions: N/A
777 * CaseDescription: 1. call RegisterConsumerListener with nullptr params
778 *                  2. check ret
779  */
780 HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener003, Function | MediumTest | Level2)
781 {
782     GSError ret = surface_->RegisterConsumerListener(nullptr);
783     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
784     sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
785     ret = surface_->RegisterConsumerListener(listener);
786     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
787 }
788 
789 /*
790 * Function: RegisterConsumerListener
791 * Type: Function
792 * Rank: Important(2)
793 * EnvConditions: N/A
794 * CaseDescription: 1. call RegisterConsumerListener with nullptr params
795 *                  2. check ret
796  */
797 HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener004, Function | MediumTest | Level2)
798 {
799     GSError ret = surface_->RegisterConsumerListener(nullptr);
800     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
801     TestConsumerListenerClazz* listenerClazz = new TestConsumerListenerClazz();
802     ret = surface_->RegisterConsumerListener(listenerClazz);
803     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
804     delete listenerClazz;
805 }
806 
807 /*
808 * Function: RegisterReleaseListener
809 * Type: Function
810 * Rank: Important(2)
811 * EnvConditions: N/A
812 * CaseDescription: 1. call RegisterReleaseListener with nullptr param
813 *                  2. check ret
814  */
815 HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener001, Function | MediumTest | Level2)
816 {
817     OnReleaseFunc onBufferRelease = nullptr;
818     GSError ret = surface_->RegisterReleaseListener(onBufferRelease);
819     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
820 }
821 
822 /*
823 * Function: RegisterReleaseListener
824 * Type: Function
825 * Rank: Important(2)
826 * EnvConditions: N/A
827 * CaseDescription: 1. call RegisterReleaseListener with consumer_ is normal
828 *                  2. check ret
829  */
830 HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener002, Function | MediumTest | Level2)
831 {
832     sptr<BufferQueue> queue = new BufferQueue("test", false);
833     surface_->consumer_ = new BufferQueueConsumer(queue);
834     ASSERT_NE(surface_->consumer_, nullptr);
835     OnReleaseFunc onBufferRelease = nullptr;
836     GSError ret = surface_->RegisterReleaseListener(onBufferRelease);
837     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
838 }
839 
840 /*
841 * Function: RegisterReleaseListener
842 * Type: Function
843 * Rank: Important(2)
844 * EnvConditions: N/A
845 * CaseDescription: 1. call RegisterReleaseListener
846 *                  2. check ret
847  */
848 HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener003, Function | MediumTest | Level2)
849 {
850     OnReleaseFuncWithFence func = nullptr;
851     GSError ret = surface_->RegisterReleaseListener(func);
852     ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
853 }
854 
855 /*
856 * Function: UnRegisterReleaseListener
857 * Type: Function
858 * Rank: Important(2)
859 * EnvConditions: N/A
860 * CaseDescription: 1. call UnRegisterReleaseListener
861 *                  2. check ret
862  */
863 HWTEST_F(ConsumerSurfaceTest, UnRegisterReleaseListener001, Function | MediumTest | Level2)
864 {
865     GSError ret = surface_->UnRegisterReleaseListener();
866     ASSERT_EQ(ret, OHOS::GSERROR_OK);
867 }
868 
869 /*
870 * Function: RegisterDeleteBufferListener
871 * Type: Function
872 * Rank: Important(2)
873 * EnvConditions: N/A
874 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is nullptr
875 *                  2. check ret
876  */
877 HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener001, Function | MediumTest | Level2)
878 {
879     OnDeleteBufferFunc func = nullptr;
880     GSError ret = surface_->RegisterDeleteBufferListener(func, false);
881     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
882 }
883 
884 /*
885 * Function: RegisterDeleteBufferListener
886 * Type: Function
887 * Rank: Important(2)
888 * EnvConditions: N/A
889 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
890 *                  2. check ret
891  */
892 HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener002, Function | MediumTest | Level2)
893 {
894     sptr<BufferQueue> queue = new BufferQueue("test", false);
895     surface_->consumer_ = new BufferQueueConsumer(queue);
896     ASSERT_NE(surface_->consumer_, nullptr);
897     OnDeleteBufferFunc func = nullptr;
898     GSError ret = surface_->RegisterDeleteBufferListener(func, false);
899     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
900     ret = surface_->RegisterDeleteBufferListener(func, true);
901     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
902 }
903 
904 /*
905  * Function: RegisterDeleteBufferListener
906  * Type: Function
907  * Rank: Important(2)
908  * EnvConditions: N/A
909  * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
910  *                  2. check ret
911  */
912 HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener003, Function | MediumTest | Level2)
913 {
914     sptr<BufferQueue> queue = new BufferQueue("test");
915     surface_->consumer_ = new BufferQueueConsumer(queue);
916     ASSERT_NE(surface_->consumer_, nullptr);
917     OnDeleteBufferFunc func = deleteBuffer;
918     GSError ret = surface_->RegisterDeleteBufferListener(func, false);
919     ASSERT_EQ(ret, OHOS::GSERROR_OK);
920     ASSERT_EQ(surface_->hasRegistercallBackForRT_, true);
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, RegisterDeleteBufferListener004, Function | MediumTest | Level2)
932 {
933     sptr<BufferQueue> queue = new BufferQueue("test");
934     surface_->consumer_ = new BufferQueueConsumer(queue);
935     ASSERT_NE(surface_->consumer_, nullptr);
936     surface_->hasRegistercallBackForRT_ = true;
937     OnDeleteBufferFunc func = deleteBuffer;
938     GSError ret = surface_->RegisterDeleteBufferListener(func, false);
939     ASSERT_EQ(ret, OHOS::GSERROR_OK);
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, RegisterDeleteBufferListener005, Function | MediumTest | Level2)
951 {
952     sptr<BufferQueue> queue = new BufferQueue("test");
953     surface_->consumer_ = new BufferQueueConsumer(queue);
954     ASSERT_NE(surface_->consumer_, nullptr);
955     OnDeleteBufferFunc func = deleteBuffer;
956     GSError ret = surface_->RegisterDeleteBufferListener(func, true);
957     ASSERT_EQ(ret, OHOS::GSERROR_OK);
958     ASSERT_EQ(surface_->hasRegistercallBackForRedraw_, true);
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, RegisterDeleteBufferListener006, Function | MediumTest | Level2)
970 {
971     sptr<BufferQueue> queue = new BufferQueue("test");
972     surface_->consumer_ = new BufferQueueConsumer(queue);
973     ASSERT_NE(surface_->consumer_, nullptr);
974     surface_->hasRegistercallBackForRedraw_ = true;
975     OnDeleteBufferFunc func = deleteBuffer;
976     GSError ret = surface_->RegisterDeleteBufferListener(func, true);
977     ASSERT_EQ(ret, OHOS::GSERROR_OK);
978 }
979 
980 /*
981 * Function: UnregisterConsumerListener
982 * Type: Function
983 * Rank: Important(2)
984 * EnvConditions: N/A
985 * CaseDescription: 1. call UnregisterConsumerListener with consumer_ is nullptr
986 *                  2. check ret
987  */
988 HWTEST_F(ConsumerSurfaceTest, UnregisterConsumerListener001, Function | MediumTest | Level2)
989 {
990     GSError ret = surface_->UnregisterConsumerListener();
991     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
992 }
993 
994 /*
995 * Function: UnregisterConsumerListener
996 * Type: Function
997 * Rank: Important(2)
998 * EnvConditions: N/A
999 * CaseDescription: 1. call UnregisterConsumerListener with consumer_ is normal
1000 *                  2. check ret
1001  */
1002 HWTEST_F(ConsumerSurfaceTest, UnregisterConsumerListener002, Function | MediumTest | Level2)
1003 {
1004     sptr<BufferQueue> queue = new BufferQueue("test", false);
1005     surface_->consumer_ = new BufferQueueConsumer(queue);
1006     ASSERT_NE(surface_->consumer_, nullptr);
1007     GSError ret = surface_->UnregisterConsumerListener();
1008     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1009 }
1010 
1011 /*
1012 * Function: RegisterUserDataChangeListener
1013 * Type: Function
1014 * Rank: Important(2)
1015 * EnvConditions: N/A
1016 * CaseDescription: 1. call RegisterUserDataChangeListener with nullptr param
1017 *                  2. check ret
1018  */
1019 HWTEST_F(ConsumerSurfaceTest, RegisterUserDataChangeListener001, Function | MediumTest | Level2)
1020 {
1021     GSError ret = surface_->RegisterUserDataChangeListener("test", nullptr);
1022     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1023 }
1024 
1025 /*
1026 * Function: GoBackground
1027 * Type: Function
1028 * Rank: Important(2)
1029 * EnvConditions: N/A
1030 * CaseDescription: 1. call GoBackground with consumer_ is nullptr
1031 *                  2. check ret
1032  */
1033 HWTEST_F(ConsumerSurfaceTest, GoBackground001, Function | MediumTest | Level2)
1034 {
1035     GSError ret = surface_->GoBackground();
1036     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1037 }
1038 
1039 /*
1040 * Function: GoBackground
1041 * Type: Function
1042 * Rank: Important(2)
1043 * EnvConditions: N/A
1044 * CaseDescription: 1. call GoBackground with consumer_ is normal
1045 *                  2. check ret
1046  */
1047 HWTEST_F(ConsumerSurfaceTest, GoBackground002, Function | MediumTest | Level2)
1048 {
1049     sptr<BufferQueue> queue = new BufferQueue("test", false);
1050     surface_->consumer_ = new BufferQueueConsumer(queue);
1051     ASSERT_NE(surface_->consumer_, nullptr);
1052     GSError ret = surface_->GoBackground();
1053     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1054     surface_->producer_ = new BufferQueueProducer(queue);
1055     ASSERT_NE(surface_->producer_, nullptr);
1056     ret = surface_->GoBackground();
1057     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1058 }
1059 
1060 /*
1061 * Function: GetUniqueId
1062 * Type: Function
1063 * Rank: Important(2)
1064 * EnvConditions: N/A
1065 * CaseDescription: 1. call GetUniqueId with producer_ is nullptr
1066 *                  2. check ret
1067  */
1068 HWTEST_F(ConsumerSurfaceTest, GetUniqueId001, Function | MediumTest | Level2)
1069 {
1070     uint64_t ret = surface_->GetUniqueId();
1071     ASSERT_EQ(ret, 0);
1072 }
1073 
1074 /*
1075 * Function: Dump
1076 * Type: Function
1077 * Rank: Important(2)
1078 * EnvConditions: N/A
1079 * CaseDescription: 1. call Dump
1080 *                  2. check ret
1081  */
1082 HWTEST_F(ConsumerSurfaceTest, Dump001, Function | MediumTest | Level2)
1083 {
1084     std::string result;
1085     surface_->Dump(result);
1086     sptr<BufferQueue> queue = new BufferQueue("test", false);
1087     surface_->consumer_ = new BufferQueueConsumer(queue);
1088     ASSERT_NE(surface_->consumer_, nullptr);
1089     surface_->Dump(result);
1090 }
1091 
1092 /*
1093 * Function: SetTransform and GetTransform
1094 * Type: Function
1095 * Rank: Important(2)
1096 * EnvConditions: N/A
1097 * CaseDescription: 1. call GetTransform by default
1098  */
1099 HWTEST_F(ConsumerSurfaceTest, transform001, Function | MediumTest | Level2)
1100 {
1101     ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_NONE);
1102 }
1103 
1104 /*
1105 * Function: SetTransform and GetTransform
1106 * Type: Function
1107 * Rank: Important(1)
1108 * EnvConditions: N/A
1109 * CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
1110 *                  2. check ret
1111  */
1112 HWTEST_F(ConsumerSurfaceTest, transform002, Function | MediumTest | Level1)
1113 {
1114     GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_90;
1115     GSError ret = ps->SetTransform(transform);
1116     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1117     ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_90);
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, transform003, Function | MediumTest | Level1)
1129 {
1130     GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_180;
1131     GSError ret = ps->SetTransform(transform);
1132     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1133     ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_180);
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, transform004, Function | MediumTest | Level1)
1145 {
1146     GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_270;
1147     GSError ret = ps->SetTransform(transform);
1148     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1149     ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_270);
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, transform005, Function | MediumTest | Level1)
1161 {
1162     GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_NONE;
1163     GSError ret = ps->SetTransform(transform);
1164     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1165     ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_NONE);
1166 }
1167 
1168 /*
1169 * Function: SetTransform and GetTransform
1170 * Type: Function
1171 * Rank: Important(1)
1172 * EnvConditions: N/A
1173 * CaseDescription: 1. call SetTransform GetTransform with nullptr
1174 *                  2. check ret
1175  */
1176 HWTEST_F(ConsumerSurfaceTest, transform006, Function | MediumTest | Level1)
1177 {
1178     GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_NONE;
1179     GSError ret = surface_->SetTransform(transform);
1180     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1181     ASSERT_EQ(surface_->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_BUTT);
1182 }
1183 
1184 /*
1185 * Function: SetScalingMode and GetScalingMode
1186 * Type: Function
1187 * Rank: Important(2)
1188 * EnvConditions: N/A
1189 * CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret
1190  */
1191 HWTEST_F(ConsumerSurfaceTest, scalingMode001, Function | MediumTest | Level2)
1192 {
1193     ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1194     GSError ret = cs->SetScalingMode(-1, scalingMode);
1195     ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1196     ret = cs->GetScalingMode(-1, scalingMode);
1197     ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1198 }
1199 
1200 /*
1201 * Function: SetScalingMode and GetScalingMode
1202 * Type: Function
1203 * Rank: Important(1)
1204 * EnvConditions: N/A
1205 * CaseDescription: 1. call SetScalingMode with normal parameters and check ret
1206 *                  2. call GetScalingMode and check ret
1207  */
1208 HWTEST_F(ConsumerSurfaceTest, scalingMode002, Function | MediumTest | Level1)
1209 {
1210     ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1211     sptr<SurfaceBuffer> buffer;
1212     int releaseFence = -1;
1213     GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1214     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1215     ASSERT_NE(buffer, nullptr);
1216 
1217     uint32_t sequence = buffer->GetSeqNum();
1218     ret = cs->SetScalingMode(sequence, scalingMode);
1219     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1220 
1221     ScalingMode scalingModeGet = ScalingMode::SCALING_MODE_FREEZE;
1222     ret = cs->GetScalingMode(sequence, scalingModeGet);
1223     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1224     ASSERT_EQ(scalingMode, scalingModeGet);
1225 
1226     ret = ps->CancelBuffer(buffer);
1227     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1228 }
1229 
1230 /*
1231 * Function: SetScalingMode003
1232 * Type: Function
1233 * Rank: Important(2)
1234 * EnvConditions: N/A
1235 * CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret
1236  */
1237 HWTEST_F(ConsumerSurfaceTest, scalingMode003, Function | MediumTest | Level2)
1238 {
1239     ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1240     GSError ret = cs->SetScalingMode(scalingMode);
1241     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1242 }
1243 
1244 /*
1245 * Function: SetScalingMode and GetScalingMode
1246 * Type: Function
1247 * Rank: Important(1)
1248 * EnvConditions: N/A
1249 * CaseDescription: 1. call SetScalingMode with nullptr and check ret
1250 *                  2. call GetScalingMode with nullptr and check ret
1251  */
1252 HWTEST_F(ConsumerSurfaceTest, scalingMode004, Function | MediumTest | Level1)
1253 {
1254     ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1255     GSError ret = surface_->SetScalingMode(firstSeqnum, scalingMode);
1256     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1257     ret = surface_->SetScalingMode(scalingMode);
1258     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1259     ret = surface_->GetScalingMode(firstSeqnum, scalingMode);
1260     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1261 }
1262 
1263 /*
1264 * Function: QueryMetaDataType
1265 * Type: Function
1266 * Rank: Important(1)
1267 * EnvConditions: N/A
1268 * CaseDescription: 1. call QueryMetaDataType and check ret
1269  */
1270 HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType001, Function | MediumTest | Level1)
1271 {
1272     HDRMetaDataType type = HDRMetaDataType::HDR_META_DATA;
1273     GSError ret = cs->QueryMetaDataType(firstSeqnum, type);
1274     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1275     ASSERT_EQ(type, HDRMetaDataType::HDR_NOT_USED);
1276 }
1277 
1278 /*
1279 * Function: QueryMetaDataType
1280 * Type: Function
1281 * Rank: Important(1)
1282 * EnvConditions: N/A
1283 * CaseDescription: 1. call SetMetaData with normal parameters and check ret
1284 *                  2. call QueryMetaDataType and check ret
1285  */
1286 HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType002, Function | MediumTest | Level1)
1287 {
1288     std::vector<GraphicHDRMetaData> metaData;
1289     GraphicHDRMetaData data = {
1290         .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1291         .value = 1,
1292     };
1293     metaData.push_back(data);
1294     GSError ret = cs->SetMetaData(firstSeqnum, metaData);
1295     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1296 
1297     HDRMetaDataType type = HDRMetaDataType::HDR_NOT_USED;
1298     ret = cs->QueryMetaDataType(firstSeqnum, type);
1299     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1300     ASSERT_EQ(type, HDRMetaDataType::HDR_META_DATA);
1301 }
1302 
1303 /*
1304 * Function: QueryMetaDataType
1305 * Type: Function
1306 * Rank: Important(1)
1307 * EnvConditions: N/A
1308 * CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
1309 *                  2. call QueryMetaDataType and check ret
1310  */
1311 HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType003, Function | MediumTest | Level1)
1312 {
1313     GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1314     std::vector<uint8_t> metaData;
1315     uint8_t data = 1;
1316     metaData.push_back(data);
1317     GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
1318     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1319 
1320     HDRMetaDataType type = HDRMetaDataType::HDR_NOT_USED;
1321     ret = cs->QueryMetaDataType(firstSeqnum, type);
1322     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1323     ASSERT_EQ(type, HDRMetaDataType::HDR_META_DATA_SET);
1324 }
1325 
1326 /*
1327 * Function: QueryMetaDataType
1328 * Type: Function
1329 * Rank: Important(1)
1330 * EnvConditions: N/A
1331 * CaseDescription: 1. call QueryMetaDataType with nullptr and check ret
1332  */
1333 HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType004, Function | MediumTest | Level1)
1334 {
1335     HDRMetaDataType type = HDRMetaDataType::HDR_META_DATA;
1336     GSError ret = surface_->QueryMetaDataType(firstSeqnum, type);
1337     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1338 }
1339 
1340 /*
1341 * Function: SetMetaData and GetMetaData
1342 * Type: Function
1343 * Rank: Important(2)
1344 * EnvConditions: N/A
1345 * CaseDescription: 1. call SetMetaData with abnormal parameters and check ret
1346  */
1347 HWTEST_F(ConsumerSurfaceTest, metaData001, Function | MediumTest | Level2)
1348 {
1349     std::vector<GraphicHDRMetaData> metaData;
1350     GSError ret = cs->SetMetaData(firstSeqnum, metaData);
1351     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1352 }
1353 
1354 /*
1355 * Function: SetMetaData and GetMetaData
1356 * Type: Function
1357 * Rank: Important(1)
1358 * EnvConditions: N/A
1359 * CaseDescription: 1. call SetMetaData with normal parameters and check ret
1360  */
1361 HWTEST_F(ConsumerSurfaceTest, metaData002, Function | MediumTest | Level1)
1362 {
1363     std::vector<GraphicHDRMetaData> metaData;
1364     GraphicHDRMetaData data = {
1365         .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1366         .value = 100,  // for test
1367     };
1368     metaData.push_back(data);
1369     GSError ret = cs->SetMetaData(firstSeqnum, metaData);
1370     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1371 }
1372 
1373 /*
1374 * Function: SetMetaData and GetMetaData
1375 * Type: Function
1376 * Rank: Important(1)
1377 * EnvConditions: N/A
1378 * CaseDescription: 1. call SetMetaData with normal parameters and check ret
1379 *                  2. call GetMetaData and check ret
1380  */
1381 HWTEST_F(ConsumerSurfaceTest, metaData003, Function | MediumTest | Level1)
1382 {
1383     std::vector<GraphicHDRMetaData> metaData;
1384     GraphicHDRMetaData data = {
1385         .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1386         .value = 100,  // for test
1387     };
1388     metaData.push_back(data);
1389 
1390     sptr<SurfaceBuffer> buffer;
1391     int releaseFence = -1;
1392     GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1393     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1394     ASSERT_NE(buffer, nullptr);
1395 
1396     uint32_t sequence = buffer->GetSeqNum();
1397     ret = cs->SetMetaData(sequence, metaData);
1398     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1399 
1400     std::vector<GraphicHDRMetaData> metaDataGet;
1401     ret = cs->GetMetaData(sequence, metaDataGet);
1402     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1403     ASSERT_EQ(metaData[0].key, metaDataGet[0].key);
1404     ASSERT_EQ(metaData[0].value, metaDataGet[0].value);
1405 
1406     ret = cs->GetMetaData(sequence + 1, metaDataGet);
1407     ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1408 
1409     ret = ps->CancelBuffer(buffer);
1410     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1411 }
1412 
1413 /*
1414 * Function: SetMetaData and GetMetaData
1415 * Type: Function
1416 * Rank: Important(2)
1417 * EnvConditions: N/A
1418 * CaseDescription: 1. call SetMetaData and GetMetaData with nullptr and check ret
1419  */
1420 HWTEST_F(ConsumerSurfaceTest, metaData004, Function | MediumTest | Level2)
1421 {
1422     std::vector<GraphicHDRMetaData> metaData;
1423     GSError ret = surface_->SetMetaData(firstSeqnum, metaData);
1424     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1425     ret = surface_->GetMetaData(firstSeqnum, metaData);
1426     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1427 }
1428 
1429 /*
1430 * Function: SetMetaDataSet and GetMetaDataSet
1431 * Type: Function
1432 * Rank: Important(2)
1433 * EnvConditions: N/A
1434 * CaseDescription: 1. call SetMetaDataSet with abnormal parameters and check ret
1435  */
1436 HWTEST_F(ConsumerSurfaceTest, metaDataSet001, Function | MediumTest | Level2)
1437 {
1438     GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1439     std::vector<uint8_t> metaData;
1440     GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
1441     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1442 }
1443 
1444 /*
1445 * Function: SetMetaDataSet and GetMetaDataSet
1446 * Type: Function
1447 * Rank: Important(1)
1448 * EnvConditions: N/A
1449 * CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
1450  */
1451 HWTEST_F(ConsumerSurfaceTest, metaDataSet002, Function | MediumTest | Level1)
1452 {
1453     GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1454     std::vector<uint8_t> metaData;
1455     uint8_t data = 10;  // for test
1456     metaData.push_back(data);
1457     GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
1458     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1459 }
1460 
1461 /*
1462 * Function: SetMetaDataSet and GetMetaDataSet
1463 * Type: Function
1464 * Rank: Important(1)
1465 * EnvConditions: N/A
1466 * CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
1467 *                  2. call GetMetaDataSet and check ret
1468  */
1469 HWTEST_F(ConsumerSurfaceTest, metaDataSet003, Function | MediumTest | Level1)
1470 {
1471     GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1472     std::vector<uint8_t> metaData;
1473     uint8_t data = 10;  // for test
1474     metaData.push_back(data);
1475 
1476     sptr<SurfaceBuffer> buffer;
1477     int releaseFence = -1;
1478     GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1479     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1480     ASSERT_NE(buffer, nullptr);
1481 
1482     uint32_t sequence = buffer->GetSeqNum();
1483     ret = cs->SetMetaDataSet(sequence, key, metaData);
1484     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1485 
1486     GraphicHDRMetadataKey keyGet = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X;
1487     std::vector<uint8_t> metaDataGet;
1488     ret = cs->GetMetaDataSet(sequence, keyGet, metaDataGet);
1489     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1490     ASSERT_EQ(key, keyGet);
1491     ASSERT_EQ(metaData[0], metaDataGet[0]);
1492 
1493     ret = cs->GetMetaDataSet(sequence + 1, keyGet, metaDataGet);
1494     ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1495 
1496     ret = ps->CancelBuffer(buffer);
1497     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1498 }
1499 
1500 /*
1501 * Function: SetMetaDataSet and GetMetaDataSet
1502 * Type: Function
1503 * Rank: Important(2)
1504 * EnvConditions: N/A
1505 * CaseDescription: 1. call SetMetaDataSet and GetMetaDataSet with nullptr and check ret
1506  */
1507 HWTEST_F(ConsumerSurfaceTest, metaDataSet004, Function | MediumTest | Level2)
1508 {
1509     GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1510     std::vector<uint8_t> metaData;
1511     GSError ret = surface_->SetMetaDataSet(firstSeqnum, key, metaData);
1512     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1513     ret = surface_->GetMetaDataSet(firstSeqnum, key, metaData);
1514     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1515 }
1516 
1517 /*
1518 * Function: SetTunnelHandle and GetTunnelHandle
1519 * Type: Function
1520 * Rank: Important(2)
1521 * EnvConditions: N/A
1522 * CaseDescription: 1. call SetTunnelHandle with abnormal parameters and check ret
1523  */
1524 HWTEST_F(ConsumerSurfaceTest, TunnelHandle001, Function | MediumTest | Level2)
1525 {
1526     GraphicExtDataHandle *handle = nullptr;
1527     GSError ret = cs->SetTunnelHandle(handle);
1528     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1529 }
1530 
1531 /*
1532 * Function: SetTunnelHandle and GetTunnelHandle
1533 * Type: Function
1534 * Rank: Important(2)
1535 * EnvConditions: N/A
1536 * CaseDescription: 1. call SetTunnelHandle with abnormal parameters and check ret
1537  */
1538 HWTEST_F(ConsumerSurfaceTest, TunnelHandle002, Function | MediumTest | Level2)
1539 {
1540     GraphicExtDataHandle *handle = nullptr;
1541     handle = new GraphicExtDataHandle();
1542     handle->fd = -1;
1543     handle->reserveInts = 0;
1544     GSError ret = cs->SetTunnelHandle(handle);
1545     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1546 }
1547 
1548 /*
1549 * Function: SetTunnelHandle and GetTunnelHandle
1550 * Type: Function
1551 * Rank: Important(1)
1552 * EnvConditions: N/A
1553 * CaseDescription: 1. call SetTunnelHandle with normal parameters and check ret
1554 *                  2. call GetTunnelHandle and check ret
1555 * @tc.require: issueI5GMZN issueI5IWHW
1556  */
1557 HWTEST_F(ConsumerSurfaceTest, TunnelHandle003, Function | MediumTest | Level1)
1558 {
1559     GraphicExtDataHandle *handle = static_cast<GraphicExtDataHandle *>(
1560         malloc(sizeof(GraphicExtDataHandle) + sizeof(int32_t)));
1561     handle->fd = -1;
1562     handle->reserveInts = 1;
1563     handle->reserve[0] = 0;
1564     GSError ret = cs->SetTunnelHandle(handle);
1565     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1566 
1567     ret = cs->SetTunnelHandle(handle);
1568     ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1569 
1570     sptr<SurfaceTunnelHandle> handleGet = nullptr;
1571     handleGet = cs->GetTunnelHandle();
1572     ASSERT_NE(handleGet, nullptr);
1573     ASSERT_EQ(handle->fd, handleGet->GetHandle()->fd);
1574     ASSERT_EQ(handle->reserveInts, handleGet->GetHandle()->reserveInts);
1575     ASSERT_EQ(handle->reserve[0], handleGet->GetHandle()->reserve[0]);
1576     free(handle);
1577 }
1578 
1579 /*
1580 * Function: SetTunnelHandle and GetTunnelHandle
1581 * Type: Function
1582 * Rank: Important(2)
1583 * EnvConditions: N/A
1584 * CaseDescription: 1. call SetTunnelHandle and GetTunnelHandle with nullptr and check ret
1585  */
1586 HWTEST_F(ConsumerSurfaceTest, TunnelHandle004, Function | MediumTest | Level2)
1587 {
1588     GraphicExtDataHandle *handle = nullptr;
1589     GSError ret = surface_->SetTunnelHandle(handle);
1590     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1591     sptr<SurfaceTunnelHandle> tunnelHandle = surface_->GetTunnelHandle();
1592     ASSERT_EQ(tunnelHandle, nullptr);
1593 }
1594 
1595 /*
1596 * Function: SetPresentTimestamp and GetPresentTimestamp
1597 * Type: Function
1598 * Rank: Important(2)
1599 * EnvConditions: N/A
1600 * CaseDescription: 1. call SetPresentTimestamp with abnormal parameters and check ret
1601 * @tc.require: issueI5I57K
1602  */
1603 HWTEST_F(ConsumerSurfaceTest, presentTimestamp002, Function | MediumTest | Level2)
1604 {
1605     GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_UNSUPPORTED, 0};
1606     GSError ret = cs->SetPresentTimestamp(-1, timestamp);
1607     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1608 }
1609 
1610 /*
1611 * Function: SetPresentTimestamp and GetPresentTimestamp
1612 * Type: Function
1613 * Rank: Important(2)
1614 * EnvConditions: N/A
1615 * CaseDescription: 1. call SetPresentTimestamp with abnormal parameters and check ret
1616 * @tc.require: issueI5I57K
1617  */
1618 HWTEST_F(ConsumerSurfaceTest, presentTimestamp003, Function | MediumTest | Level2)
1619 {
1620     GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_DELAY, 0};
1621     GSError ret = cs->SetPresentTimestamp(-1, timestamp);
1622     ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1623 }
1624 
1625 /*
1626 * Function: SetPresentTimestamp and GetPresentTimestamp
1627 * Type: Function
1628 * Rank: Important(1)
1629 * EnvConditions: N/A
1630 * CaseDescription: 1. call SetPresentTimestamp with normal parameters and check ret
1631 * @tc.require: issueI5I57K
1632  */
1633 HWTEST_F(ConsumerSurfaceTest, presentTimestamp004, Function | MediumTest | Level1)
1634 {
1635     GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_DELAY, 0};
1636     GSError ret = cs->SetPresentTimestamp(firstSeqnum, timestamp);
1637     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1638 }
1639 
1640 /*
1641 * Function: SetPresentTimestamp and GetPresentTimestamp
1642 * Type: Function
1643 * Rank: Important(1)
1644 * EnvConditions: N/A
1645 * CaseDescription: 1. call SetPresentTimestamp with normal parameters and check ret
1646 * @tc.require: issueI5I57K
1647  */
1648 HWTEST_F(ConsumerSurfaceTest, presentTimestamp005, Function | MediumTest | Level1)
1649 {
1650     GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_TIMESTAMP, 0};
1651     GSError ret = cs->SetPresentTimestamp(firstSeqnum, timestamp);
1652     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1653 }
1654 
1655 /*
1656 * Function: SetPresentTimestamp and GetPresentTimestamp
1657 * Type: Function
1658 * Rank: Important(1)
1659 * EnvConditions: N/A
1660 * CaseDescription: 1. call SetPresentTimestamp with nullptr and check ret
1661  */
1662 HWTEST_F(ConsumerSurfaceTest, presentTimestamp006, Function | MediumTest | Level1)
1663 {
1664     GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_TIMESTAMP, 0};
1665     GSError ret = surface_->SetPresentTimestamp(firstSeqnum, timestamp);
1666     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1667     int64_t time = 0;
1668     ret = surface_->GetPresentTimestamp(firstSeqnum, GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_TIMESTAMP, time);
1669     ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
1670 }
1671 
1672 /*
1673 * Function: AcquireBuffer and ReleaseBuffer
1674 * Type: Function
1675 * Rank: Important(2)
1676 * EnvConditions: N/A
1677 * CaseDescription: 1. call RequestBuffer and FlushBuffer
1678 *                  2. call AcquireBuffer and ReleaseBuffer
1679 *                  3. check ret
1680  */
1681 HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel005, Function | MediumTest | Level2)
1682 {
1683     sptr<SurfaceBuffer> buffer;
1684     int releaseFence = -1;
1685 
1686     GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1687     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1688     ASSERT_NE(buffer, nullptr);
1689 
1690     ret = ps->FlushBuffer(buffer, SyncFence::INVALID_FENCE, flushConfigWithDamages);
1691     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1692 
1693     sptr<OHOS::SyncFence> flushFence;
1694     ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damages);
1695     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1696     ASSERT_NE(buffer, nullptr);
1697     ASSERT_EQ(damages.size(), flushConfigWithDamages.damages.size());
1698     for (decltype(damages.size()) i = 0; i < damages.size(); i++) {
1699         ASSERT_EQ(damages[i].x, flushConfigWithDamages.damages[i].x);
1700         ASSERT_EQ(damages[i].y, flushConfigWithDamages.damages[i].y);
1701         ASSERT_EQ(damages[i].w, flushConfigWithDamages.damages[i].w);
1702         ASSERT_EQ(damages[i].h, flushConfigWithDamages.damages[i].h);
1703     }
1704 
1705     ASSERT_EQ(timestamp, flushConfigWithDamages.timestamp);
1706     ret = cs->ReleaseBuffer(buffer, -1);
1707     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1708 }
1709 
1710 /*
1711 * Function: AttachBuffer001
1712 * Type: Function
1713 * Rank: Important(2)
1714 * EnvConditions: N/A
1715 * CaseDescription: 1. call AttachBuffer
1716 *                  2. check ret
1717  */
1718 HWTEST_F(ConsumerSurfaceTest, AttachBuffer001, Function | MediumTest | Level2)
1719 {
1720     sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1721     ASSERT_NE(buffer, nullptr);
1722     GSError ret = cs->AttachBuffer(buffer);
1723     ASSERT_EQ(ret, OHOS::GSERROR_OK);
1724 }
1725 
1726 /*
1727 * Function: AttachBuffer002
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, AttachBuffer002, Function | MediumTest | Level2)
1735 {
1736     sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1737     ASSERT_NE(buffer, nullptr);
1738     int32_t timeOut = 1;
1739     GSError ret = cs->AttachBuffer(buffer, timeOut);
1740     ASSERT_NE(ret, OHOS::GSERROR_OK);
1741 }
1742 
1743 /*
1744 * Function: AttachBuffer003
1745 * Type: Function
1746 * Rank: Important(2)
1747 * EnvConditions: N/A
1748 * CaseDescription: 1. call AttachBuffer
1749 *                  2. check ret
1750  */
1751 HWTEST_F(ConsumerSurfaceTest, AttachBuffer003, Function | MediumTest | Level2)
1752 {
1753     sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1754     ASSERT_NE(buffer, nullptr);
1755     int32_t timeOut = 1;
1756     GSError ret = cs->AttachBuffer(buffer, timeOut);
1757     ASSERT_NE(ret, GSERROR_OK);
1758 }
1759 
1760 /*
1761 * Function: AttachBuffer
1762 * Type: Function
1763 * Rank: Important(2)
1764 * EnvConditions: N/A
1765 * CaseDescription: 1. call AttachBuffer with nullptr params
1766 *                  2. check ret
1767  */
1768 HWTEST_F(ConsumerSurfaceTest, AttachBuffer004, Function | MediumTest | Level2)
1769 {
1770     sptr<SurfaceBuffer> buffer = nullptr;
1771     GSError ret = surface_->AttachBuffer(buffer);
1772     ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1773 }
1774 
1775 /*
1776 * Function: AttachBuffer
1777 * Type: Function
1778 * Rank: Important(2)
1779 * EnvConditions: N/A
1780 * CaseDescription: 1. call AttachBuffer with nullptr params
1781 *                  2. check ret
1782  */
1783 HWTEST_F(ConsumerSurfaceTest, AttachBuffer005, Function | MediumTest | Level2)
1784 {
1785     sptr<SurfaceBuffer> buffer = nullptr;
1786     int32_t timeOut = 1;
1787     GSError ret = surface_->AttachBuffer(buffer, timeOut);
1788     ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1789 }
1790 
1791 /*
1792 * Function: RegisterSurfaceDelegator
1793 * Type: Function
1794 * Rank: Important(2)
1795 * EnvConditions: N/A
1796 * CaseDescription: 1. call RegisterSurfaceDelegator
1797 *                  2. check ret
1798  */
1799 HWTEST_F(ConsumerSurfaceTest, RegisterSurfaceDelegator001, Function | MediumTest | Level2)
1800 {
1801     GSError ret = cs->RegisterSurfaceDelegator(surfaceDelegator->AsObject());
1802     ASSERT_EQ(ret, GSERROR_OK);
1803 }
1804 
1805 /*
1806 * Function: RegisterSurfaceDelegator
1807 * Type: Function
1808 * Rank: Important(2)
1809 * EnvConditions: N/A
1810 * CaseDescription: 1. call RegisterSurfaceDelegator with nullptr params
1811 *                  2. check ret
1812  */
1813 HWTEST_F(ConsumerSurfaceTest, RegisterSurfaceDelegator002, Function | MediumTest | Level2)
1814 {
1815     GSError ret = surface_->RegisterSurfaceDelegator(nullptr);
1816     ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1817     ASSERT_NE(surfaceDelegator, nullptr);
1818     sptr<IRemoteObject> client = surfaceDelegator->AsObject();
1819     ASSERT_NE(client, nullptr);
1820     ret = surface_->RegisterSurfaceDelegator(client);
1821     ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1822 }
1823 
1824 /*
1825 * Function: ConsumerRequestCpuAccess
1826 * Type: Function
1827 * Rank: Important(2)
1828 * EnvConditions: N/A
1829 * CaseDescription: 1. usage does not contain BUFFER_USAGE_CPU_HW_BOTH
1830 *                  2. call ConsumerRequestCpuAccess(fasle/true)
1831 *                  3. check ret
1832  */
1833 HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess001, Function | MediumTest | Level2)
1834 {
1835     using namespace HDI::Display::Graphic::Common;
1836     BufferRequestConfig config = {
1837         .width = 0x100,
1838         .height = 0x100,
1839         .strideAlignment = 0x8,
1840         .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1841         .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1842         .timeout = 0,
1843     };
1844     auto cSurface = IConsumerSurface::Create();
1845     sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
1846     cSurface->RegisterConsumerListener(cListener);
1847     auto p = cSurface->GetProducer();
1848     auto pSurface = Surface::CreateSurfaceAsProducer(p);
1849 
1850     // test default
1851     sptr<SurfaceBuffer> buffer;
1852     int releaseFence = -1;
1853     GSError ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1854     ASSERT_EQ(ret, GSERROR_OK);
1855     ASSERT_NE(buffer, nullptr);
1856 
1857     std::vector<uint8_t> values;
1858     buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1859     ASSERT_EQ(values.size(), 0);
1860 
1861     ret = pSurface->CancelBuffer(buffer);
1862     ASSERT_EQ(ret, GSERROR_OK);
1863 
1864     // test true
1865     cSurface->ConsumerRequestCpuAccess(true);
1866     ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1867     ASSERT_EQ(ret, GSERROR_OK);
1868     ASSERT_NE(buffer, nullptr);
1869 
1870     values.clear();
1871     buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1872     ASSERT_EQ(values.size(), 0);
1873 
1874     ret = pSurface->CancelBuffer(buffer);
1875     ASSERT_EQ(ret, GSERROR_OK);
1876 
1877     // test false
1878     cSurface->ConsumerRequestCpuAccess(false);
1879     ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1880     ASSERT_EQ(ret, GSERROR_OK);
1881     ASSERT_NE(buffer, nullptr);
1882 
1883     values.clear();
1884     buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1885     ASSERT_EQ(values.size(), 0);
1886 
1887     ret = pSurface->CancelBuffer(buffer);
1888     ASSERT_EQ(ret, GSERROR_OK);
1889 }
1890 
1891 /*
1892 * Function: ConsumerRequestCpuAccess
1893 * Type: Function
1894 * Rank: Important(2)
1895 * EnvConditions: N/A
1896 * CaseDescription: 1. usage contain BUFFER_USAGE_CPU_HW_BOTH
1897 *                  2. call ConsumerRequestCpuAccess(true)
1898 *                  3. check ret
1899  */
1900 HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess002, Function | MediumTest | Level2)
1901 {
1902     using namespace HDI::Display::Graphic::Common;
1903     BufferRequestConfig config = {
1904         .width = 0x100,
1905         .height = 0x100,
1906         .strideAlignment = 0x8,
1907         .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1908         .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH,
1909         .timeout = 0,
1910     };
1911     auto cSurface = IConsumerSurface::Create();
1912     sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
1913     cSurface->RegisterConsumerListener(cListener);
1914     auto p = cSurface->GetProducer();
1915     auto pSurface = Surface::CreateSurfaceAsProducer(p);
1916 
1917     // test default
1918     sptr<SurfaceBuffer> buffer;
1919     int releaseFence = -1;
1920     GSError ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1921     ASSERT_EQ(ret, GSERROR_OK);
1922     ASSERT_NE(buffer, nullptr);
1923 
1924     std::vector<uint8_t> values;
1925     buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1926     if (values.size() == 1) {
1927         ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_HW_ONLY);
1928     }
1929 
1930     ret = pSurface->CancelBuffer(buffer);
1931     ASSERT_EQ(ret, GSERROR_OK);
1932 
1933     // test true
1934     cSurface->ConsumerRequestCpuAccess(true);
1935     ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1936     ASSERT_EQ(ret, GSERROR_OK);
1937     ASSERT_NE(buffer, nullptr);
1938 
1939     values.clear();
1940     buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1941     if (values.size() == 1) {
1942         ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_CPU_ACCESS);
1943     }
1944 
1945     ret = pSurface->CancelBuffer(buffer);
1946     ASSERT_EQ(ret, GSERROR_OK);
1947 
1948     // test false
1949     cSurface->ConsumerRequestCpuAccess(false);
1950     ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1951     ASSERT_EQ(ret, GSERROR_OK);
1952     ASSERT_NE(buffer, nullptr);
1953 
1954     values.clear();
1955     buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1956     if (values.size() == 1) {
1957         ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_HW_ONLY);
1958     }
1959 
1960     ret = pSurface->CancelBuffer(buffer);
1961     ASSERT_EQ(ret, GSERROR_OK);
1962 }
1963 
1964 /*
1965 * Function: ConsumerRequestCpuAccess
1966 * Type: Function
1967 * Rank: Important(2)
1968 * EnvConditions: N/A
1969 * CaseDescription: 1. call ConsumerRequestCpuAccess with nullptr
1970 *                  2. check ret
1971  */
1972 HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess003, Function | MediumTest | Level2)
1973 {
1974     ASSERT_NE(surface_, nullptr);
1975     surface_->ConsumerRequestCpuAccess(true);
1976 }
1977 
1978 /*
1979 * Function: SetTransformHint and GetTransformHint
1980 * Type: Function
1981 * Rank: Important(1)
1982 * EnvConditions: N/A
1983 * CaseDescription: 1. call SetTransformHint with nullptr and check ret
1984 *                  2. call GetTransformHint with nullptr and check ret
1985  */
1986 HWTEST_F(ConsumerSurfaceTest, transformHint001, Function | MediumTest | Level1)
1987 {
1988     GraphicTransformType typeSet = GraphicTransformType::GRAPHIC_ROTATE_BUTT;
1989     GSError ret = surface_->SetTransformHint(typeSet);
1990     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1991     GraphicTransformType typeGet = surface_->GetTransformHint();
1992     ASSERT_EQ(typeGet, GraphicTransformType::GRAPHIC_ROTATE_BUTT);
1993 }
1994 
1995 /*
1996 * Function: SetSurfaceSourceType and GetSurfaceSourceType
1997 * Type: Function
1998 * Rank: Important(2)
1999 * EnvConditions: N/A
2000 * CaseDescription: 1. call SetSurfaceSourceType and check ret
2001 *                  2. call GetSurfaceSourceType and check ret
2002 */
2003 HWTEST_F(ConsumerSurfaceTest, SurfaceSourceType001, Function | MediumTest | Level2)
2004 {
2005     OHSurfaceSource sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
2006     GSError ret = cs->SetSurfaceSourceType(sourceType);
2007     ASSERT_EQ(ret, OHOS::GSERROR_OK);
2008     ASSERT_EQ(cs->GetSurfaceSourceType(), OH_SURFACE_SOURCE_VIDEO);
2009 }
2010 
2011 /*
2012 * Function: SetSurfaceSourceType and GetSurfaceSourceType
2013 * Type: Function
2014 * Rank: Important(2)
2015 * EnvConditions: N/A
2016 * CaseDescription: 1. call SetSurfaceSourceType with nullptr and check ret
2017 *                  2. call GetSurfaceSourceType with nullptr and check ret
2018 */
2019 HWTEST_F(ConsumerSurfaceTest, SurfaceSourceType002, Function | MediumTest | Level2)
2020 {
2021     OHSurfaceSource sourceTypeSet = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
2022     GSError ret = surface_->SetSurfaceSourceType(sourceTypeSet);
2023     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2024     OHSurfaceSource sourceTypeGet = surface_->GetSurfaceSourceType();
2025     ASSERT_EQ(sourceTypeGet, OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT);
2026 }
2027 
2028 /*
2029 * Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
2030 * Type: Function
2031 * Rank: Important(2)
2032 * EnvConditions: N/A
2033 * CaseDescription: 1. call SetSurfaceAppFrameworkType and check ret
2034 *                  2. call GetSurfaceAppFrameworkType and check ret
2035 */
2036 HWTEST_F(ConsumerSurfaceTest, SurfaceAppFrameworkType001, Function | MediumTest | Level2)
2037 {
2038     std::string type = "test";
2039     GSError ret = cs->SetSurfaceAppFrameworkType(type);
2040     ASSERT_EQ(ret, OHOS::GSERROR_OK);
2041     ASSERT_EQ(cs->GetSurfaceAppFrameworkType(), "test");
2042 }
2043 
2044 /*
2045 * Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
2046 * Type: Function
2047 * Rank: Important(2)
2048 * EnvConditions: N/A
2049 * CaseDescription: 1. call SetSurfaceAppFrameworkType with nullptr and check ret
2050 *                  2. call GetSurfaceAppFrameworkType with nullptr and check ret
2051 */
2052 HWTEST_F(ConsumerSurfaceTest, SurfaceAppFrameworkType002, Function | MediumTest | Level2)
2053 {
2054     std::string type = "test";
2055     GSError ret = surface_->SetSurfaceAppFrameworkType(type);
2056     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2057     ASSERT_EQ(surface_->GetSurfaceAppFrameworkType(), "");
2058 }
2059 
2060 /*
2061 * Function: GetHdrWhitePointBrightness and GetSdrWhitePointBrightness
2062 * Type: Function
2063 * Rank: Important(2)
2064 * EnvConditions: N/A
2065 * CaseDescription: 1. call GetHdrWhitePointBrightness with nullptr and check ret
2066 *                  2. call GetSdrWhitePointBrightness with nullptr and check ret
2067 */
2068 HWTEST_F(ConsumerSurfaceTest, WhitePointBrightness001, Function | MediumTest | Level2)
2069 {
2070     float ret = surface_->GetHdrWhitePointBrightness();
2071     ASSERT_EQ(static_cast<int32_t>(ret), 0);
2072     ret = surface_->GetSdrWhitePointBrightness();
2073     ASSERT_EQ(static_cast<int32_t>(ret), 0);
2074 }
2075 
2076 /*
2077 * Function: InvalidParameter
2078 * Type: Function
2079 * Rank: Important(2)
2080 * EnvConditions: N/A
2081 * CaseDescription: 1. call interface with invaild input nullptr and check ret
2082 */
2083 HWTEST_F(ConsumerSurfaceTest, InvalidParameter001, Function | MediumTest | Level2)
2084 {
2085     sptr<OHOS::SurfaceBuffer> sBuffer = nullptr;
2086     sptr<OHOS::SyncFence> fence = nullptr;
2087     ASSERT_EQ(surface_->AcquireLastFlushedBuffer(sBuffer, fence, nullptr, 0, false), GSERROR_NOT_SUPPORT);
2088     ASSERT_EQ(surface_->ReleaseLastFlushedBuffer(sBuffer), GSERROR_NOT_SUPPORT);
2089 }
2090 
2091 /*
2092 * Function: AttachBufferToQueue
2093 * Type: Function
2094 * Rank: Important(2)
2095 * EnvConditions: N/A
2096 * CaseDescription: 1. call AttachBufferToQueue and check ret
2097 */
2098 HWTEST_F(ConsumerSurfaceTest, AttachBufferToQueueMemLeak, Function | MediumTest | Level2)
2099 {
2100     BufferRequestConfig config = {
2101         .width = 0x100,
2102         .height = 0x100,
2103         .strideAlignment = 0x8,
2104         .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
2105         .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH,
2106         .timeout = 0,
2107     };
2108     auto cSurface = IConsumerSurface::Create();
2109     sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
2110     cSurface->RegisterConsumerListener(cListener);
2111     auto p = cSurface->GetProducer();
2112     auto pSurface = Surface::CreateSurfaceAsProducer(p);
2113 
2114     sptr<SurfaceBuffer> buffer;
2115     int releaseFence = -1;
2116     BufferFlushConfig flushConfigTmp = {
2117         .damage = {
2118             .w = 0x100,
2119             .h = 0x100,
2120         },
2121     };
2122     int64_t timestampTmp = 0;
2123     Rect damageTmp = {};
2124     GSError ret;
2125     sptr<OHOS::SyncFence> fence;
2126     for (uint32_t i = 0; i < 3; i++) {
2127         ret = pSurface->RequestBuffer(buffer, releaseFence, config);
2128         ASSERT_EQ(ret, GSERROR_OK);
2129         ASSERT_NE(buffer, nullptr);
2130         ret = pSurface->FlushBuffer(buffer, -1, flushConfigTmp);
2131         ASSERT_EQ(ret, OHOS::GSERROR_OK);
2132     }
2133 
2134     for (uint32_t i = 0; i < 3; i++) {
2135         ret = cSurface->AcquireBuffer(buffer, fence, timestampTmp, damageTmp);
2136         ASSERT_EQ(ret, OHOS::GSERROR_OK);
2137         ret = cSurface->DetachBufferFromQueue(buffer);
2138         ASSERT_EQ(ret, OHOS::GSERROR_OK);
2139     }
2140     for (uint32_t i = 0; i < 3; i++) {
2141         ret = pSurface->RequestBuffer(buffer, releaseFence, config);
2142         ASSERT_EQ(ret, GSERROR_OK);
2143     }
2144 }
2145 }
2146