1 /*
2 * Copyright (c) 2024 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, GetProducer001, Function | MediumTest | Level2)
121 {
122 ASSERT_NE(cs, nullptr);
123 sptr<ConsumerSurface> qs = static_cast<ConsumerSurface*>(cs.GetRefPtr());
124 ASSERT_NE(qs->GetProducer(), nullptr);
125 }
126
127 /*
128 * Function: ConsumerSurface ctor
129 * Type: Function
130 * Rank: Important(2)
131 * EnvConditions: N/A
132 * CaseDescription: 1. new ConsumerSurface, only one nullptr for consumer_ and producer_
133 * 2. dtor and check ret
134 */
135 HWTEST_F(ConsumerSurfaceTest, ConsumerSurfaceCtor001, Function | MediumTest | Level2)
136 {
137 sptr<BufferQueue> queue = new BufferQueue("test");
138 surface_->producer_ = new BufferQueueProducer(queue);
139
140 ASSERT_NE(surface_->producer_, nullptr);
141 ASSERT_EQ(surface_->consumer_, nullptr);
142 }
143
144 /*
145 * Function: ConsumerSurface ctor
146 * Type: Function
147 * Rank: Important(2)
148 * EnvConditions: N/A
149 * CaseDescription: 1. new ConsumerSurface, only one nullptr for consumer_ and producer_
150 * 2. dtor and check ret
151 */
152 HWTEST_F(ConsumerSurfaceTest, ConsumerSurfaceCtor002, Function | MediumTest | Level2)
153 {
154 sptr<BufferQueue> queue = new BufferQueue("test");
155 surface_->consumer_ = new BufferQueueConsumer(queue);
156 ASSERT_NE(surface_->consumer_, nullptr);
157 }
158
159 /*
160 * Function: SetDefaultWidthAndHeight, GetDefaultWidth and GetDefaultHeight
161 * Type: Function
162 * Rank: Important(2)
163 * EnvConditions: N/A
164 * CaseDescription: 1. call SetDefaultWidthAndHeight with consumer_ is nullptr
165 * 2. call GetDefaultWidth with producer_ is nullptr
166 * 3. call GetDefaultHeight with producer_ is nullptr
167 * 4. check ret
168 */
169 HWTEST_F(ConsumerSurfaceTest, SetAndGetDefaultWidthAndHeight001, Function | MediumTest | Level2)
170 {
171 ASSERT_NE(surface_, nullptr);
172 int32_t width = 0;
173 int32_t height = 0;
174 GSError ret = surface_->SetDefaultWidthAndHeight(width, height);
175 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
176
177 width = surface_->GetDefaultWidth();
178 ASSERT_EQ(width, -1);
179
180 height = surface_->GetDefaultHeight();
181 ASSERT_EQ(height, -1);
182 }
183
184 /*
185 * Function: SetDefaultWidthAndHeight, GetDefaultWidth and GetDefaultHeight
186 * Type: Function
187 * Rank: Important(2)
188 * EnvConditions: N/A
189 * CaseDescription: 1. call SetDefaultWidthAndHeight with noraml value
190 * 2. call GetDefaultWidth
191 * 3. call GetDefaultHeight
192 * 4. check ret
193 */
194 HWTEST_F(ConsumerSurfaceTest, SetAndGetDefaultWidthAndHeight002, Function | MediumTest | Level2)
195 {
196 ASSERT_NE(cs, nullptr);
197 int32_t width = 100; // 100 test value for width
198 int32_t height = 100; // 100 test value for height
199 GSError ret = cs->SetDefaultWidthAndHeight(width, height);
200 ASSERT_EQ(ret, OHOS::GSERROR_OK);
201
202 int32_t value = cs->GetDefaultWidth();
203 ASSERT_EQ(value, width);
204
205 value = cs->GetDefaultHeight();
206 ASSERT_EQ(value, height);
207 }
208
209 /*
210 * Function: SetDefaultUsage and GetDefaultUsage
211 * Type: Function
212 * Rank: Important(2)
213 * EnvConditions: N/A
214 * CaseDescription: 1. call SetDefaultUsage with consumer_ is nullptr
215 * 2. call GetDefaultUsage with producer_ is nullptr
216 * 3. check ret
217 */
218 HWTEST_F(ConsumerSurfaceTest, SetAndGetDefaultUsage001, Function | MediumTest | Level2)
219 {
220 ASSERT_NE(surface_, nullptr);
221 GSError ret = surface_->SetDefaultUsage(0);
222 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
223
224 uint64_t value = surface_->GetDefaultUsage();
225 ASSERT_EQ(value, 0);
226 }
227
228 /*
229 * Function: SetDefaultUsage and GetDefaultUsage
230 * Type: Function
231 * Rank: Important(2)
232 * EnvConditions: N/A
233 * CaseDescription: 1. call GetDefaultUsage with normal
234 * 2. call SetDefaultUsage with normal
235 * 3. call GetDefaultUsage agagin
236 * 4. check ret
237 */
238 HWTEST_F(ConsumerSurfaceTest, SetAndGetDefaultUsage002, Function | MediumTest | Level2)
239 {
240 ASSERT_NE(cs, nullptr);
241 int32_t usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA;
242 uint32_t value = cs->GetDefaultUsage();
243 ASSERT_EQ(value, 0);
244
245 GSError ret = cs->SetDefaultUsage(usage);
246 ASSERT_EQ(ret, OHOS::GSERROR_OK);
247
248 value = cs->GetDefaultUsage();
249 ASSERT_EQ(value, usage);
250 }
251
252 /*
253 * Function: SetQueueSize and GetQueueSize
254 * Type: Function
255 * Rank: Important(2)
256 * EnvConditions: N/A
257 * CaseDescription: 1. call GetQueueSize and get default value
258 * 2. call SetQueueSize
259 * 3. call SetQueueSize again with abnormal value
260 * 4. call GetQueueSize for BufferQueueProducer and BufferQueue
261 * 5. check ret
262 */
263 HWTEST_F(ConsumerSurfaceTest, SetAndGetQueueSize001, Function | MediumTest | Level2)
264 {
265 ASSERT_NE(cs, nullptr);
266 ASSERT_EQ(cs->GetQueueSize(), static_cast<uint32_t>(SURFACE_DEFAULT_QUEUE_SIZE));
267
268 GSError ret = cs->SetQueueSize(2);
269 ASSERT_EQ(ret, OHOS::GSERROR_OK);
270 ASSERT_EQ(cs->GetQueueSize(), 2u);
271
272 ret = cs->SetQueueSize(SURFACE_MAX_QUEUE_SIZE + 1);
273 ASSERT_NE(ret, OHOS::GSERROR_OK);
274 ASSERT_EQ(cs->GetQueueSize(), 2u);
275 }
276
277 /*
278 * Function: SetQueueSize and GetQueueSize
279 * Type: Function
280 * Rank: Important(2)
281 * EnvConditions: N/A
282 * CaseDescription: 1. call GetQueueSize
283 * 2. call SetQueueSize 2 times
284 * 3. check ret
285 */
286 HWTEST_F(ConsumerSurfaceTest, SetAndGetQueueSize002, Function | MediumTest | Level2)
287 {
288 sptr<ConsumerSurface> qs = static_cast<ConsumerSurface*>(cs.GetRefPtr());
289 sptr<BufferQueueProducer> bqp = static_cast<BufferQueueProducer*>(qs->GetProducer().GetRefPtr());
290 ASSERT_EQ(bqp->GetQueueSize(), 2u);
291
292 GSError ret = cs->SetQueueSize(1);
293 ASSERT_EQ(ret, OHOS::GSERROR_OK);
294
295 ret = cs->SetQueueSize(2);
296 ASSERT_EQ(ret, OHOS::GSERROR_OK);
297 }
298
299 /*
300 * Function: SetQueueSize and GetQueueSize
301 * Type: Function
302 * Rank: Important(2)
303 * EnvConditions: N/A
304 * CaseDescription: 1. call GetQueueSize with producer_ is nullptr
305 * 2. call SetQueueSize with producer_ is nullptr
306 * 3. check ret
307 */
308 HWTEST_F(ConsumerSurfaceTest, SetAndGetQueueSize003, Function | MediumTest | Level2)
309 {
310 ASSERT_NE(surface_, nullptr);
311 uint32_t size = surface_->GetQueueSize();
312 ASSERT_EQ(size, 0);
313
314 GSError ret = surface_->SetQueueSize(1);
315 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
316 }
317
318 /*
319 * Function: AcquireBuffer
320 * Type: Function
321 * Rank: Important(2)
322 * EnvConditions: N/A
323 * CaseDescription: 1. call AcquireBuffer with consumer_ is nullptr
324 * 2. check ret
325 */
326 HWTEST_F(ConsumerSurfaceTest, AcquireBuffer001, Function | MediumTest | Level2)
327 {
328 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
329 sptr<OHOS::SyncFence> fence;
330 GSError ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage);
331 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
332 }
333
334 /*
335 * Function: AcquireBuffer
336 * Type: Function
337 * Rank: Important(2)
338 * EnvConditions: N/A
339 * CaseDescription: 1. call AcquireBuffer with nullptr params
340 * 2. check ret
341 */
342 HWTEST_F(ConsumerSurfaceTest, AcquireBuffer002, Function | MediumTest | Level2)
343 {
344 sptr<SurfaceBuffer> buffer = nullptr;
345 sptr<OHOS::SyncFence> fence;
346 GSError ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage);
347 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
348
349 buffer = SurfaceBuffer::Create();
350 fence = nullptr;
351 ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage);
352 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
353 }
354
355 /*
356 * Function: ReleaseBuffer
357 * Type: Function
358 * Rank: Important(2)
359 * EnvConditions: N/A
360 * CaseDescription: 1. call ReleaseBuffer with consumer_ is nullptr
361 * 2. check ret
362 */
363 HWTEST_F(ConsumerSurfaceTest, ReleaseBuffer001, Function | MediumTest | Level2)
364 {
365 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
366 sptr<OHOS::SyncFence> fence;
367 GSError ret = surface_->ReleaseBuffer(buffer, fence);
368 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
369 }
370
371 /*
372 * Function: ReleaseBuffer
373 * Type: Function
374 * Rank: Important(2)
375 * EnvConditions: N/A
376 * CaseDescription: 1. call ReleaseBuffer with nullptr params
377 * 2. check ret
378 */
379 HWTEST_F(ConsumerSurfaceTest, ReleaseBuffer002, Function | MediumTest | Level2)
380 {
381 sptr<SurfaceBuffer> buffer = nullptr;
382 sptr<OHOS::SyncFence> fence;
383 GSError ret = surface_->ReleaseBuffer(buffer, fence);
384 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
385 }
386
387 /*
388 * Function: DetachBuffer
389 * Type: Function
390 * Rank: Important(2)
391 * EnvConditions: N/A
392 * CaseDescription: 1. call DetachBuffer with consumer_ is nullptr
393 * 2. check ret
394 */
395 HWTEST_F(ConsumerSurfaceTest, DetachBuffer001, Function | MediumTest | Level2)
396 {
397 sptr<SurfaceBuffer> buffer;
398 GSError ret = surface_->DetachBuffer(buffer);
399 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
400 }
401
402 /*
403 * Function: DetachBuffer
404 * Type: Function
405 * Rank: Important(2)
406 * EnvConditions: N/A
407 * CaseDescription: 1. call DetachBuffer with nullptr params
408 * 2. check ret
409 */
410 HWTEST_F(ConsumerSurfaceTest, DetachBuffer002, Function | MediumTest | Level2)
411 {
412 sptr<SurfaceBuffer> buffer = nullptr;
413 GSError ret = surface_->DetachBuffer(buffer);
414 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
415 }
416
417 /*
418 * Function: RequestBuffer and FlushBuffer
419 * Type: Function
420 * Rank: Important(2)
421 * EnvConditions: N/A
422 * CaseDescription: 1. call RequestBuffer by cs and ps
423 * 2. call FlushBuffer both
424 * 3. check ret
425 */
426 HWTEST_F(ConsumerSurfaceTest, RequestAndFlush001, Function | MediumTest | Level2)
427 {
428 sptr<SurfaceBuffer> buffer;
429 int releaseFence = -1;
430 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
431 ASSERT_EQ(ret, OHOS::GSERROR_OK);
432 ASSERT_NE(buffer, nullptr);
433
434 firstSeqnum = buffer->GetSeqNum();
435 ret = ps->FlushBuffer(buffer, -1, flushConfig);
436 ASSERT_EQ(ret, OHOS::GSERROR_OK);
437
438 ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
439 ASSERT_EQ(ret, OHOS::GSERROR_OK);
440 ret = ps->FlushBuffer(buffer, -1, flushConfig);
441 ASSERT_EQ(ret, OHOS::GSERROR_OK);
442 }
443
444 /*
445 * Function: AcquireBuffer and ReleaseBuffer
446 * Type: Function
447 * Rank: Important(2)
448 * EnvConditions: N/A
449 * CaseDescription: 1. call AcquireBuffer
450 * 2. call ReleaseBuffer
451 * 3. check ret
452 */
453 HWTEST_F(ConsumerSurfaceTest, AcquireAndRelease001, Function | MediumTest | Level2)
454 {
455 sptr<SurfaceBuffer> buffer;
456 int32_t flushFence;
457 GSError ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
458 ASSERT_EQ(ret, OHOS::GSERROR_OK);
459 ASSERT_NE(buffer, nullptr);
460
461 ret = cs->ReleaseBuffer(buffer, -1);
462 ASSERT_EQ(ret, OHOS::GSERROR_OK);
463 }
464
465 /*
466 * Function: AcquireBuffer and ReleaseBuffer
467 * Type: Function
468 * Rank: Important(2)
469 * EnvConditions: N/A
470 * CaseDescription: 1. call AcquireBuffer
471 * 2. call ReleaseBuffer 2 times
472 * 3. check ret
473 */
474 HWTEST_F(ConsumerSurfaceTest, AcquireAndRelease002, Function | MediumTest | Level2)
475 {
476 sptr<SurfaceBuffer> buffer;
477 int32_t flushFence;
478 GSError ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
479 ASSERT_EQ(ret, OHOS::GSERROR_OK);
480 ASSERT_NE(buffer, nullptr);
481
482 ret = cs->ReleaseBuffer(buffer, -1);
483 ASSERT_EQ(ret, OHOS::GSERROR_OK);
484
485 ret = cs->ReleaseBuffer(buffer, -1);
486 ASSERT_NE(ret, OHOS::GSERROR_OK);
487 }
488
489 /*
490 * Function: RequestBuffer and CancelBuffer
491 * Type: Function
492 * Rank: Important(2)
493 * EnvConditions: N/A
494 * CaseDescription: 1. call RequestBuffer by cs and ps
495 * 2. call CancelBuffer both
496 * 3. check ret
497 */
498 HWTEST_F(ConsumerSurfaceTest, RequestAndCancle001, Function | MediumTest | Level2)
499 {
500 sptr<SurfaceBuffer> buffer;
501 int releaseFence = -1;
502 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
503 ASSERT_EQ(ret, OHOS::GSERROR_OK);
504
505 ret = ps->CancelBuffer(buffer);
506 ASSERT_EQ(ret, OHOS::GSERROR_OK);
507 }
508
509 /*
510 * Function: SetUserData
511 * Type: Function
512 * Rank: Important(2)
513 * EnvConditions: N/A
514 * CaseDescription: 1. call SetUserData many times
515 * 2. check ret
516 */
517 HWTEST_F(ConsumerSurfaceTest, SetUserData001, Function | MediumTest | Level2)
518 {
519 GSError ret;
520
521 std::string strs[SURFACE_MAX_USER_DATA_COUNT];
522 constexpr int32_t stringLengthMax = 32;
523 char str[stringLengthMax] = {};
524 for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) {
525 auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%d", i);
526 ASSERT_GT(secRet, 0);
527
528 strs[i] = str;
529 ret = cs->SetUserData(strs[i], "magic");
530 ASSERT_EQ(ret, OHOS::GSERROR_OK);
531 }
532
533 ret = cs->SetUserData("-1", "error");
534 ASSERT_NE(ret, OHOS::GSERROR_OK);
535
536 std::string retStr;
537 for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) {
538 retStr = cs->GetUserData(strs[i]);
539 ASSERT_EQ(retStr, "magic");
540 }
541 }
542
543 /*
544 * Function: UserDataChangeListen
545 * Type: Function
546 * Rank: Important(2)
547 * EnvConditions: N/A
548 * CaseDescription: 1. RegisterUserDataChangeListen
549 * 2. SetUserData
550 * 3. check ret
551 */
552 HWTEST_F(ConsumerSurfaceTest, UserDataChangeListen001, Function | MediumTest | Level2)
553 {
554 sptr<IConsumerSurface> csTestUserData = IConsumerSurface::Create();
555 GSError ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
556 GSError ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
__anon8a12394a0102(const std::string& key, const std::string& value) 557 auto func1 = [&ret1](const std::string& key, const std::string& value) {
558 ret1 = OHOS::GSERROR_OK;
559 };
__anon8a12394a0202(const std::string& key, const std::string& value) 560 auto func2 = [&ret2](const std::string& key, const std::string& value) {
561 ret2 = OHOS::GSERROR_OK;
562 };
563 csTestUserData->RegisterUserDataChangeListener("func1", func1);
564 csTestUserData->RegisterUserDataChangeListener("func2", func2);
565 csTestUserData->RegisterUserDataChangeListener("func3", nullptr);
566 ASSERT_EQ(csTestUserData->RegisterUserDataChangeListener("func2", func2), OHOS::GSERROR_INVALID_ARGUMENTS);
567
568 if (csTestUserData->SetUserData("Regist", "OK") == OHOS::GSERROR_OK) {
569 ASSERT_EQ(ret1, OHOS::GSERROR_OK);
570 ASSERT_EQ(ret2, OHOS::GSERROR_OK);
571 }
572
573 ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
574 ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
575 csTestUserData->UnRegisterUserDataChangeListener("func1");
576 ASSERT_EQ(csTestUserData->UnRegisterUserDataChangeListener("func1"), OHOS::GSERROR_INVALID_ARGUMENTS);
577
578 if (csTestUserData->SetUserData("UnRegist", "INVALID") == OHOS::GSERROR_OK) {
579 ASSERT_EQ(ret1, OHOS::GSERROR_INVALID_ARGUMENTS);
580 ASSERT_EQ(ret2, OHOS::GSERROR_OK);
581 }
582
583 ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
584 ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
585 csTestUserData->ClearUserDataChangeListener();
586 csTestUserData->RegisterUserDataChangeListener("func1", func1);
587 if (csTestUserData->SetUserData("Clear", "OK") == OHOS::GSERROR_OK) {
588 ASSERT_EQ(ret1, OHOS::GSERROR_OK);
589 ASSERT_EQ(ret2, OHOS::GSERROR_INVALID_ARGUMENTS);
590 }
591 }
592
593 /*
594 * Function: UserDataChangeListen
595 * Type: Function
596 * Rank: Important(2)
597 * EnvConditions: N/A
598 * CaseDescription: 1. RegisterUserDataChangeListen
599 * 2. SetUserData
600 * 3. check ret
601 */
602 HWTEST_F(ConsumerSurfaceTest, UserDataChangeListen002, Function | MediumTest | Level2)
603 {
604 sptr<IConsumerSurface> csTestUserData = IConsumerSurface::Create();
605
__anon8a12394a0302(const std::string& FuncName) 606 auto func = [&csTestUserData](const std::string& FuncName) {
607 constexpr int32_t RegisterListenerNum = 1000;
608 std::vector<GSError> ret(RegisterListenerNum, OHOS::GSERROR_INVALID_ARGUMENTS);
609 std::string strs[RegisterListenerNum];
610 constexpr int32_t stringLengthMax = 32;
611 char str[stringLengthMax] = {};
612 for (int i = 0; i < RegisterListenerNum; i++) {
613 auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%s%d", FuncName.c_str(), i);
614 ASSERT_GT(secRet, 0);
615 strs[i] = str;
616 ASSERT_EQ(csTestUserData->RegisterUserDataChangeListener(strs[i], [i, &ret]
617 (const std::string& key, const std::string& value) {
618 ret[i] = OHOS::GSERROR_OK;
619 }), OHOS::GSERROR_OK);
620 }
621
622 if (csTestUserData->SetUserData("Regist", FuncName) == OHOS::GSERROR_OK) {
623 for (int i = 0; i < RegisterListenerNum; i++) {
624 ASSERT_EQ(ret[i], OHOS::GSERROR_OK);
625 }
626 }
627
628 for (int i = 0; i < RegisterListenerNum; i++) {
629 csTestUserData->UnRegisterUserDataChangeListener(strs[i]);
630 }
631 };
632
633 std::thread t1(func, "thread1");
634 std::thread t2(func, "thread2");
635 t1.join();
636 t2.join();
637 }
638
639 /*
640 * Function: RegisterConsumerListener
641 * Type: Function
642 * Rank: Important(2)
643 * EnvConditions: N/A
644 * CaseDescription: 1. call RegisterConsumerListener
645 * 2. check ret
646 */
647 HWTEST_F(ConsumerSurfaceTest, ConsumerListener001, Function | MediumTest | Level2)
648 {
649 class TestConsumerListener : public IBufferConsumerListener {
650 public:
OnBufferAvailable()651 void OnBufferAvailable() override
652 {
653 sptr<SurfaceBuffer> buffer;
654 int32_t flushFence;
655
656 cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
657 int32_t *p = (int32_t*)buffer->GetVirAddr();
658 if (p != nullptr) {
659 for (int32_t i = 0; i < 128; i++) {
660 ASSERT_EQ(p[i], i);
661 }
662 }
663
664 cs->ReleaseBuffer(buffer, -1);
665 }
666 };
667
668 sptr<IBufferConsumerListener> listener = new TestConsumerListener();
669 GSError ret = cs->RegisterConsumerListener(listener);
670 ASSERT_EQ(ret, OHOS::GSERROR_OK);
671
672 sptr<SurfaceBuffer> buffer;
673 int releaseFence = -1;
674 ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
675 ASSERT_EQ(ret, OHOS::GSERROR_OK);
676 ASSERT_NE(buffer, nullptr);
677
678 int32_t *p = (int32_t*)buffer->GetVirAddr();
679 if (p != nullptr) {
680 for (int32_t i = 0; i < 128; i++) {
681 p[i] = i;
682 }
683 }
684
685 GraphicTransformType tranformType = ps->GetTransform();
686 ret = ps->FlushBuffer(buffer, -1, flushConfig);
687 ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_180), OHOS::GSERROR_OK);
688 GraphicTransformType bufferTranformType = GraphicTransformType::GRAPHIC_ROTATE_NONE;
689 ASSERT_EQ(cs->GetSurfaceBufferTransformType(nullptr, &bufferTranformType), OHOS::SURFACE_ERROR_INVALID_PARAM);
690 ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, nullptr), OHOS::SURFACE_ERROR_INVALID_PARAM);
691 ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, &bufferTranformType), OHOS::GSERROR_OK);
692 ASSERT_EQ(bufferTranformType, tranformType);
693 ASSERT_EQ(ret, OHOS::GSERROR_OK);
694
695 listener->OnTunnelHandleChange();
696 listener->OnGoBackground();
697 listener->OnCleanCache();
698 listener->OnTransformChange();
699 TestConsumerListenerClazz* listenerClazz = new TestConsumerListenerClazz();
700 listenerClazz->OnTunnelHandleChange();
701 listenerClazz->OnGoBackground();
702 listenerClazz->OnCleanCache();
703 listenerClazz->OnTransformChange();
704 delete listenerClazz;
705 }
706
707 /*
708 * Function: RegisterConsumerListener, RequestBuffer and FlushBuffer
709 * Type: Function
710 * Rank: Important(2)
711 * EnvConditions: N/A
712 * CaseDescription: 1. call RegisterConsumerListener
713 * 2. call RequestBuffer
714 * 3. call FlushBuffer
715 * 4. check ret
716 */
717 HWTEST_F(ConsumerSurfaceTest, ConsumerListener002, Function | MediumTest | Level2)
718 {
719 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
720 GSError ret = cs->RegisterConsumerListener(listener);
721 ASSERT_EQ(ret, OHOS::GSERROR_OK);
722
723 sptr<SurfaceBuffer> buffer;
724 int releaseFence = -1;
725 ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
726 ASSERT_EQ(ret, OHOS::GSERROR_OK);
727 ASSERT_NE(buffer, nullptr);
728
729 int32_t *p = (int32_t*)buffer->GetVirAddr();
730 if (p != nullptr) {
731 for (int32_t i = 0; i < requestConfig.width * requestConfig.height; i++) {
732 p[i] = i;
733 }
734 }
735 ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_90), OHOS::GSERROR_OK);
736
737 ret = ps->FlushBuffer(buffer, -1, flushConfig);
738 GraphicTransformType bufferTranformType = GraphicTransformType::GRAPHIC_ROTATE_NONE;
739 ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, &bufferTranformType), OHOS::GSERROR_OK);
740 ASSERT_EQ(bufferTranformType, GraphicTransformType::GRAPHIC_ROTATE_90);
741 ASSERT_EQ(ret, OHOS::GSERROR_OK);
742 ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_NONE), OHOS::GSERROR_OK);
743
744 sptr<OHOS::SyncFence> flushFence;
745 ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
746 ASSERT_EQ(ret, OHOS::GSERROR_OK);
747 ASSERT_NE(buffer, nullptr);
748
749 bool isInCache = false;
750 ASSERT_EQ(cs->IsSurfaceBufferInCache(buffer->GetSeqNum(), isInCache), OHOS::GSERROR_OK);
751 ASSERT_EQ(isInCache, true);
752 ASSERT_EQ(cs->IsSurfaceBufferInCache(0xFFFFFFFF, isInCache), OHOS::GSERROR_OK);
753 ASSERT_EQ(isInCache, false);
754 }
755
756 /*
757 * Function: RegisterConsumerListener
758 * Type: Function
759 * Rank: Important(2)
760 * EnvConditions: N/A
761 * CaseDescription: 1. call RegisterConsumerListener with nullptr params
762 * 2. check ret
763 */
764 HWTEST_F(ConsumerSurfaceTest, ConsumerListener003, Function | MediumTest | Level2)
765 {
766 GSError ret = surface_->RegisterConsumerListener(nullptr);
767 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
768 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
769 ret = surface_->RegisterConsumerListener(listener);
770 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
771 }
772
773 /*
774 * Function: RegisterConsumerListener
775 * Type: Function
776 * Rank: Important(2)
777 * EnvConditions: N/A
778 * CaseDescription: 1. call RegisterConsumerListener with nullptr params
779 * 2. check ret
780 */
781 HWTEST_F(ConsumerSurfaceTest, ConsumerListener004, Function | MediumTest | Level2)
782 {
783 GSError ret = surface_->RegisterConsumerListener(nullptr);
784 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
785 TestConsumerListenerClazz* listenerClazz = new TestConsumerListenerClazz();
786 ret = surface_->RegisterConsumerListener(listenerClazz);
787 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
788 delete listenerClazz;
789 }
790
791 /*
792 * Function: UnregisterConsumerListener
793 * Type: Function
794 * Rank: Important(2)
795 * EnvConditions: N/A
796 * CaseDescription: 1. call UnregisterConsumerListener with consumer_ is nullptr
797 * 2. check ret
798 */
799 HWTEST_F(ConsumerSurfaceTest, ConsumerListener005, Function | MediumTest | Level2)
800 {
801 GSError ret = surface_->UnregisterConsumerListener();
802 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
803 }
804
805 /*
806 * Function: UnregisterConsumerListener
807 * Type: Function
808 * Rank: Important(2)
809 * EnvConditions: N/A
810 * CaseDescription: 1. call UnregisterConsumerListener with consumer_ is normal
811 * 2. check ret
812 */
813 HWTEST_F(ConsumerSurfaceTest, ConsumerListener006, Function | MediumTest | Level2)
814 {
815 sptr<BufferQueue> queue = new BufferQueue("test");
816 surface_->consumer_ = new BufferQueueConsumer(queue);
817 ASSERT_NE(surface_->consumer_, nullptr);
818 GSError ret = surface_->UnregisterConsumerListener();
819 ASSERT_EQ(ret, OHOS::GSERROR_OK);
820 }
821
822 /*
823 * Function: RegisterReleaseListener
824 * Type: Function
825 * Rank: Important(2)
826 * EnvConditions: N/A
827 * CaseDescription: 1. call RegisterReleaseListener with nullptr param
828 * 2. check ret
829 */
830 HWTEST_F(ConsumerSurfaceTest, ReleaseListener001, Function | MediumTest | Level2)
831 {
832 OnReleaseFunc onBufferRelease = nullptr;
833 GSError ret = surface_->RegisterReleaseListener(onBufferRelease);
834 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
835 }
836
837 /*
838 * Function: RegisterReleaseListener
839 * Type: Function
840 * Rank: Important(2)
841 * EnvConditions: N/A
842 * CaseDescription: 1. call RegisterReleaseListener with consumer_ is normal
843 * 2. check ret
844 */
845 HWTEST_F(ConsumerSurfaceTest, ReleaseListener002, Function | MediumTest | Level2)
846 {
847 sptr<BufferQueue> queue = new BufferQueue("test");
848 surface_->consumer_ = new BufferQueueConsumer(queue);
849 ASSERT_NE(surface_->consumer_, nullptr);
850
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, ReleaseListener003, 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, ReleaseListener004, 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, DeleteBufferListener001, 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, DeleteBufferListener002, Function | MediumTest | Level2)
909 {
910 sptr<BufferQueue> queue = new BufferQueue("test");
911 surface_->consumer_ = new BufferQueueConsumer(queue);
912 ASSERT_NE(surface_->consumer_, nullptr);
913
914 OnDeleteBufferFunc func = nullptr;
915 GSError ret = surface_->RegisterDeleteBufferListener(func, false);
916 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
917
918 ret = surface_->RegisterDeleteBufferListener(func, true);
919 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
920 }
921
922 /*
923 * Function: RegisterDeleteBufferListener
924 * Type: Function
925 * Rank: Important(2)
926 * EnvConditions: N/A
927 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
928 * 2. check ret
929 */
930 HWTEST_F(ConsumerSurfaceTest, DeleteBufferListener003, Function | MediumTest | Level2)
931 {
932 sptr<BufferQueue> queue = new BufferQueue("test");
933 surface_->consumer_ = new BufferQueueConsumer(queue);
934 ASSERT_NE(surface_->consumer_, nullptr);
935 OnDeleteBufferFunc func = deleteBuffer;
936 GSError ret = surface_->RegisterDeleteBufferListener(func, false);
937 ASSERT_EQ(ret, OHOS::GSERROR_OK);
938 ASSERT_EQ(surface_->hasRegistercallBackForRT_, true);
939 }
940
941 /*
942 * Function: RegisterDeleteBufferListener
943 * Type: Function
944 * Rank: Important(2)
945 * EnvConditions: N/A
946 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
947 * 2. check ret
948 */
949 HWTEST_F(ConsumerSurfaceTest, DeleteBufferListener004, Function | MediumTest | Level2)
950 {
951 sptr<BufferQueue> queue = new BufferQueue("test");
952 surface_->consumer_ = new BufferQueueConsumer(queue);
953 ASSERT_NE(surface_->consumer_, nullptr);
954
955 surface_->hasRegistercallBackForRT_ = true;
956 OnDeleteBufferFunc func = deleteBuffer;
957 GSError ret = surface_->RegisterDeleteBufferListener(func, false);
958 ASSERT_EQ(ret, OHOS::GSERROR_OK);
959 }
960
961 /*
962 * Function: RegisterDeleteBufferListener
963 * Type: Function
964 * Rank: Important(2)
965 * EnvConditions: N/A
966 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
967 * 2. check ret
968 */
969 HWTEST_F(ConsumerSurfaceTest, DeleteBufferListener005, Function | MediumTest | Level2)
970 {
971 sptr<BufferQueue> queue = new BufferQueue("test");
972 surface_->consumer_ = new BufferQueueConsumer(queue);
973 ASSERT_NE(surface_->consumer_, nullptr);
974
975 OnDeleteBufferFunc func = deleteBuffer;
976 GSError ret = surface_->RegisterDeleteBufferListener(func, true);
977 ASSERT_EQ(ret, OHOS::GSERROR_OK);
978 ASSERT_EQ(surface_->hasRegistercallBackForRedraw_, true);
979 }
980
981 /*
982 * Function: RegisterDeleteBufferListener
983 * Type: Function
984 * Rank: Important(2)
985 * EnvConditions: N/A
986 * CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
987 * 2. check ret
988 */
989 HWTEST_F(ConsumerSurfaceTest, DeleteBufferListener006, Function | MediumTest | Level2)
990 {
991 sptr<BufferQueue> queue = new BufferQueue("test");
992 surface_->consumer_ = new BufferQueueConsumer(queue);
993 ASSERT_NE(surface_->consumer_, nullptr);
994
995 surface_->hasRegistercallBackForRedraw_ = true;
996 OnDeleteBufferFunc func = deleteBuffer;
997 GSError ret = surface_->RegisterDeleteBufferListener(func, true);
998 ASSERT_EQ(ret, OHOS::GSERROR_OK);
999 }
1000
1001 /*
1002 * Function: RegisterUserDataChangeListener
1003 * Type: Function
1004 * Rank: Important(2)
1005 * EnvConditions: N/A
1006 * CaseDescription: 1. call RegisterUserDataChangeListener with nullptr param
1007 * 2. check ret
1008 */
1009 HWTEST_F(ConsumerSurfaceTest, UserDataChangeListener001, Function | MediumTest | Level2)
1010 {
1011 GSError ret = surface_->RegisterUserDataChangeListener("test", nullptr);
1012 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1013 }
1014
1015 /*
1016 * Function: GoBackground
1017 * Type: Function
1018 * Rank: Important(2)
1019 * EnvConditions: N/A
1020 * CaseDescription: 1. call GoBackground with consumer_ is nullptr
1021 * 2. check ret
1022 */
1023 HWTEST_F(ConsumerSurfaceTest, GoBackground001, Function | MediumTest | Level2)
1024 {
1025 GSError ret = surface_->GoBackground();
1026 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1027 }
1028
1029 /*
1030 * Function: GoBackground
1031 * Type: Function
1032 * Rank: Important(2)
1033 * EnvConditions: N/A
1034 * CaseDescription: 1. call GoBackground with consumer_ is normal
1035 * 2. check ret
1036 */
1037 HWTEST_F(ConsumerSurfaceTest, GoBackground002, Function | MediumTest | Level2)
1038 {
1039 sptr<BufferQueue> queue = new BufferQueue("test");
1040 surface_->consumer_ = new BufferQueueConsumer(queue);
1041 ASSERT_NE(surface_->consumer_, nullptr);
1042
1043 GSError ret = surface_->GoBackground();
1044 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1045
1046 surface_->producer_ = new BufferQueueProducer(queue);
1047 ASSERT_NE(surface_->producer_, nullptr);
1048
1049 ret = surface_->GoBackground();
1050 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1051 }
1052
1053 /*
1054 * Function: GetUniqueId
1055 * Type: Function
1056 * Rank: Important(2)
1057 * EnvConditions: N/A
1058 * CaseDescription: 1. call GetUniqueId with producer_ is nullptr
1059 * 2. check ret
1060 */
1061 HWTEST_F(ConsumerSurfaceTest, GetUniqueId001, Function | MediumTest | Level2)
1062 {
1063 uint64_t ret = surface_->GetUniqueId();
1064 ASSERT_EQ(ret, 0);
1065 }
1066
1067 /*
1068 * Function: Dump
1069 * Type: Function
1070 * Rank: Important(2)
1071 * EnvConditions: N/A
1072 * CaseDescription: 1. call Dump
1073 * 2. check ret
1074 */
1075 HWTEST_F(ConsumerSurfaceTest, Dump001, Function | MediumTest | Level2)
1076 {
1077 std::string result;
1078 surface_->Dump(result);
1079 sptr<BufferQueue> queue = new BufferQueue("test");
1080 surface_->consumer_ = new BufferQueueConsumer(queue);
1081 ASSERT_NE(surface_->consumer_, nullptr);
1082 surface_->Dump(result);
1083 }
1084
1085 /*
1086 * Function: SetScalingMode and GetScalingMode
1087 * Type: Function
1088 * Rank: Important(2)
1089 * EnvConditions: N/A
1090 * CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret
1091 */
1092 HWTEST_F(ConsumerSurfaceTest, SetAndGetScalingMode001, Function | MediumTest | Level2)
1093 {
1094 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1095 GSError ret = cs->SetScalingMode(-1, scalingMode);
1096 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1097
1098 ret = cs->GetScalingMode(-1, scalingMode);
1099 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1100 }
1101
1102 /*
1103 * Function: SetScalingMode and GetScalingMode
1104 * Type: Function
1105 * Rank: Important(1)
1106 * EnvConditions: N/A
1107 * CaseDescription: 1. call SetScalingMode with normal parameters and check ret
1108 * 2. call GetScalingMode and check ret
1109 */
1110 HWTEST_F(ConsumerSurfaceTest, SetAndGetScalingMode002, Function | MediumTest | Level1)
1111 {
1112 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1113 sptr<SurfaceBuffer> buffer;
1114 int releaseFence = -1;
1115 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1116 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1117 ASSERT_NE(buffer, nullptr);
1118
1119 uint32_t sequence = buffer->GetSeqNum();
1120 ret = cs->SetScalingMode(sequence, scalingMode);
1121 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1122
1123 ScalingMode scalingModeGet = ScalingMode::SCALING_MODE_FREEZE;
1124 ret = cs->GetScalingMode(sequence, scalingModeGet);
1125 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1126 ASSERT_EQ(scalingMode, scalingModeGet);
1127
1128 ret = ps->CancelBuffer(buffer);
1129 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1130 }
1131
1132 /*
1133 * Function: SetScalingMode and GetScalingMode
1134 * Type: Function
1135 * Rank: Important(2)
1136 * EnvConditions: N/A
1137 * CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret
1138 */
1139 HWTEST_F(ConsumerSurfaceTest, SetAndGetScalingMode003, Function | MediumTest | Level2)
1140 {
1141 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1142 GSError ret = cs->SetScalingMode(scalingMode);
1143 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1144 }
1145
1146 /*
1147 * Function: SetScalingMode and GetScalingMode
1148 * Type: Function
1149 * Rank: Important(1)
1150 * EnvConditions: N/A
1151 * CaseDescription: 1. call SetScalingMode with nullptr and check ret
1152 * 2. call GetScalingMode with nullptr and check ret
1153 */
1154 HWTEST_F(ConsumerSurfaceTest, SetAndGetScalingMode004, Function | MediumTest | Level1)
1155 {
1156 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
1157 GSError ret = surface_->SetScalingMode(firstSeqnum, scalingMode);
1158 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1159
1160 ret = surface_->SetScalingMode(scalingMode);
1161 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1162
1163 ret = surface_->GetScalingMode(firstSeqnum, scalingMode);
1164 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1165 }
1166
1167 /*
1168 * Function: QueryMetaDataType
1169 * Type: Function
1170 * Rank: Important(1)
1171 * EnvConditions: N/A
1172 * CaseDescription: 1. call QueryMetaDataType and check ret
1173 */
1174 HWTEST_F(ConsumerSurfaceTest, MetaDataType001, Function | MediumTest | Level1)
1175 {
1176 HDRMetaDataType type = HDRMetaDataType::HDR_META_DATA;
1177 GSError ret = cs->QueryMetaDataType(firstSeqnum, type);
1178 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1179 ASSERT_EQ(type, HDRMetaDataType::HDR_NOT_USED);
1180 }
1181
1182 /*
1183 * Function: QueryMetaDataType
1184 * Type: Function
1185 * Rank: Important(1)
1186 * EnvConditions: N/A
1187 * CaseDescription: 1. call SetMetaData with normal parameters and check ret
1188 * 2. call QueryMetaDataType and check ret
1189 */
1190 HWTEST_F(ConsumerSurfaceTest, MetaDataType002, Function | MediumTest | Level1)
1191 {
1192 std::vector<GraphicHDRMetaData> metaData;
1193 GraphicHDRMetaData data = {
1194 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1195 .value = 1,
1196 };
1197 metaData.push_back(data);
1198 GSError ret = cs->SetMetaData(firstSeqnum, metaData);
1199 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1200
1201 HDRMetaDataType type = HDRMetaDataType::HDR_NOT_USED;
1202 ret = cs->QueryMetaDataType(firstSeqnum, type);
1203 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1204 ASSERT_EQ(type, HDRMetaDataType::HDR_META_DATA);
1205 }
1206
1207 /*
1208 * Function: QueryMetaDataType
1209 * Type: Function
1210 * Rank: Important(1)
1211 * EnvConditions: N/A
1212 * CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
1213 * 2. call QueryMetaDataType and check ret
1214 */
1215 HWTEST_F(ConsumerSurfaceTest, MetaDataType003, Function | MediumTest | Level1)
1216 {
1217 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1218 std::vector<uint8_t> metaData;
1219 uint8_t data = 1;
1220 metaData.push_back(data);
1221 GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
1222 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1223
1224 HDRMetaDataType type = HDRMetaDataType::HDR_NOT_USED;
1225 ret = cs->QueryMetaDataType(firstSeqnum, type);
1226 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1227 ASSERT_EQ(type, HDRMetaDataType::HDR_META_DATA_SET);
1228 }
1229
1230 /*
1231 * Function: QueryMetaDataType
1232 * Type: Function
1233 * Rank: Important(1)
1234 * EnvConditions: N/A
1235 * CaseDescription: 1. call QueryMetaDataType with nullptr and check ret
1236 */
1237 HWTEST_F(ConsumerSurfaceTest, MetaDataType004, Function | MediumTest | Level1)
1238 {
1239 HDRMetaDataType type = HDRMetaDataType::HDR_META_DATA;
1240 GSError ret = surface_->QueryMetaDataType(firstSeqnum, type);
1241 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1242 }
1243
1244 /*
1245 * Function: GetHdrWhitePointBrightness and GetSdrWhitePointBrightness
1246 * Type: Function
1247 * Rank: Important(2)
1248 * EnvConditions: N/A
1249 * CaseDescription: 1. call GetHdrWhitePointBrightness with nullptr and check ret
1250 * 2. call GetSdrWhitePointBrightness with nullptr and check ret
1251 */
1252 HWTEST_F(ConsumerSurfaceTest, GetHdrWhitePointBrightness001, Function | MediumTest | Level2)
1253 {
1254 float ret = surface_->GetHdrWhitePointBrightness();
1255 ASSERT_EQ(static_cast<int32_t>(ret), 0);
1256 ret = surface_->GetSdrWhitePointBrightness();
1257 ASSERT_EQ(static_cast<int32_t>(ret), 0);
1258 }
1259
1260 /*
1261 * Function: SetMetaData and GetMetaData
1262 * Type: Function
1263 * Rank: Important(2)
1264 * EnvConditions: N/A
1265 * CaseDescription: 1. call SetMetaData with abnormal parameters and check ret
1266 */
1267 HWTEST_F(ConsumerSurfaceTest, SetAndGetMetaData001, Function | MediumTest | Level2)
1268 {
1269 std::vector<GraphicHDRMetaData> metaData;
1270 GSError ret = cs->SetMetaData(firstSeqnum, metaData);
1271 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1272 }
1273
1274 /*
1275 * Function: SetMetaData and GetMetaData
1276 * Type: Function
1277 * Rank: Important(1)
1278 * EnvConditions: N/A
1279 * CaseDescription: 1. call SetMetaData with normal parameters and check ret
1280 */
1281 HWTEST_F(ConsumerSurfaceTest, SetAndGetMetaData002, Function | MediumTest | Level1)
1282 {
1283 std::vector<GraphicHDRMetaData> metaData;
1284 GraphicHDRMetaData data = {
1285 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1286 .value = 100, // for test
1287 };
1288 metaData.push_back(data);
1289 GSError ret = cs->SetMetaData(firstSeqnum, metaData);
1290 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1291 }
1292
1293 /*
1294 * Function: SetMetaData and GetMetaData
1295 * Type: Function
1296 * Rank: Important(1)
1297 * EnvConditions: N/A
1298 * CaseDescription: 1. call SetMetaData with normal parameters and check ret
1299 * 2. call GetMetaData and check ret
1300 */
1301 HWTEST_F(ConsumerSurfaceTest, SetAndGetMetaData003, Function | MediumTest | Level1)
1302 {
1303 std::vector<GraphicHDRMetaData> metaData;
1304 GraphicHDRMetaData data = {
1305 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
1306 .value = 100, // for test
1307 };
1308 metaData.push_back(data);
1309
1310 sptr<SurfaceBuffer> buffer;
1311 int releaseFence = -1;
1312 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1313 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1314 ASSERT_NE(buffer, nullptr);
1315
1316 uint32_t sequence = buffer->GetSeqNum();
1317 ret = cs->SetMetaData(sequence, metaData);
1318 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1319
1320 std::vector<GraphicHDRMetaData> metaDataGet;
1321 ret = cs->GetMetaData(sequence, metaDataGet);
1322 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1323 ASSERT_EQ(metaData[0].key, metaDataGet[0].key);
1324 ASSERT_EQ(metaData[0].value, metaDataGet[0].value);
1325
1326 ret = cs->GetMetaData(sequence + 1, metaDataGet);
1327 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1328
1329 ret = ps->CancelBuffer(buffer);
1330 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1331 }
1332
1333 /*
1334 * Function: SetMetaData and GetMetaData
1335 * Type: Function
1336 * Rank: Important(2)
1337 * EnvConditions: N/A
1338 * CaseDescription: 1. call SetMetaData and GetMetaData with nullptr and check ret
1339 */
1340 HWTEST_F(ConsumerSurfaceTest, SetAndGetMetaData004, Function | MediumTest | Level2)
1341 {
1342 std::vector<GraphicHDRMetaData> metaData;
1343 GSError ret = surface_->SetMetaData(firstSeqnum, metaData);
1344 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1345 ret = surface_->GetMetaData(firstSeqnum, metaData);
1346 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1347 }
1348
1349 /*
1350 * Function: SetMetaDataSet and GetMetaDataSet
1351 * Type: Function
1352 * Rank: Important(2)
1353 * EnvConditions: N/A
1354 * CaseDescription: 1. call SetMetaDataSet with abnormal parameters and check ret
1355 */
1356 HWTEST_F(ConsumerSurfaceTest, SetAndGetMetaDataSet001, Function | MediumTest | Level2)
1357 {
1358 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1359 std::vector<uint8_t> metaData;
1360 GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
1361 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1362 }
1363
1364 /*
1365 * Function: SetMetaDataSet and GetMetaDataSet
1366 * Type: Function
1367 * Rank: Important(1)
1368 * EnvConditions: N/A
1369 * CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
1370 */
1371 HWTEST_F(ConsumerSurfaceTest, SetAndGetMetaDataSet002, Function | MediumTest | Level1)
1372 {
1373 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1374 std::vector<uint8_t> metaData;
1375 uint8_t data = 10; // for test
1376 metaData.push_back(data);
1377 GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
1378 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1379 }
1380
1381 /*
1382 * Function: SetMetaDataSet and GetMetaDataSet
1383 * Type: Function
1384 * Rank: Important(1)
1385 * EnvConditions: N/A
1386 * CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
1387 * 2. call GetMetaDataSet and check ret
1388 */
1389 HWTEST_F(ConsumerSurfaceTest, SetAndGetMetaDataSet003, Function | MediumTest | Level1)
1390 {
1391 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1392 std::vector<uint8_t> metaData;
1393 uint8_t data = 10; // for test
1394 metaData.push_back(data);
1395
1396 sptr<SurfaceBuffer> buffer;
1397 int releaseFence = -1;
1398 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1399 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1400 ASSERT_NE(buffer, nullptr);
1401
1402 uint32_t sequence = buffer->GetSeqNum();
1403 ret = cs->SetMetaDataSet(sequence, key, metaData);
1404 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1405
1406 GraphicHDRMetadataKey keyGet = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X;
1407 std::vector<uint8_t> metaDataGet;
1408 ret = cs->GetMetaDataSet(sequence, keyGet, metaDataGet);
1409 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1410 ASSERT_EQ(key, keyGet);
1411 ASSERT_EQ(metaData[0], metaDataGet[0]);
1412
1413 ret = cs->GetMetaDataSet(sequence + 1, keyGet, metaDataGet);
1414 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1415
1416 ret = ps->CancelBuffer(buffer);
1417 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1418 }
1419
1420 /*
1421 * Function: SetMetaDataSet and GetMetaDataSet
1422 * Type: Function
1423 * Rank: Important(2)
1424 * EnvConditions: N/A
1425 * CaseDescription: 1. call SetMetaDataSet and GetMetaDataSet with nullptr and check ret
1426 */
1427 HWTEST_F(ConsumerSurfaceTest, SetAndGetMetaDataSet004, Function | MediumTest | Level2)
1428 {
1429 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
1430 std::vector<uint8_t> metaData;
1431 GSError ret = surface_->SetMetaDataSet(firstSeqnum, key, metaData);
1432 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1433 ret = surface_->GetMetaDataSet(firstSeqnum, key, metaData);
1434 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1435 }
1436
1437 /*
1438 * Function: SetTunnelHandle and GetTunnelHandle
1439 * Type: Function
1440 * Rank: Important(2)
1441 * EnvConditions: N/A
1442 * CaseDescription: 1. call SetTunnelHandle with abnormal parameters and check ret
1443 */
1444 HWTEST_F(ConsumerSurfaceTest, SetAndGetTunnelHandle001, Function | MediumTest | Level2)
1445 {
1446 GraphicExtDataHandle *handle = nullptr;
1447 GSError ret = cs->SetTunnelHandle(handle);
1448 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1449 }
1450
1451 /*
1452 * Function: SetTunnelHandle and GetTunnelHandle
1453 * Type: Function
1454 * Rank: Important(2)
1455 * EnvConditions: N/A
1456 * CaseDescription: 1. call SetTunnelHandle with abnormal parameters and check ret
1457 */
1458 HWTEST_F(ConsumerSurfaceTest, SetAndGetTunnelHandle002, Function | MediumTest | Level2)
1459 {
1460 GraphicExtDataHandle *handle = nullptr;
1461 handle = new GraphicExtDataHandle();
1462 handle->fd = -1;
1463 handle->reserveInts = 0;
1464 GSError ret = cs->SetTunnelHandle(handle);
1465 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1466 }
1467
1468 /*
1469 * Function: SetTunnelHandle and GetTunnelHandle
1470 * Type: Function
1471 * Rank: Important(1)
1472 * EnvConditions: N/A
1473 * CaseDescription: 1. call SetTunnelHandle with normal parameters and check ret
1474 * 2. call GetTunnelHandle and check ret
1475 * @tc.require: issueI5GMZN issueI5IWHW
1476 */
1477 HWTEST_F(ConsumerSurfaceTest, SetAndGetTunnelHandle003, Function | MediumTest | Level1)
1478 {
1479 GraphicExtDataHandle *handle = static_cast<GraphicExtDataHandle *>(
1480 malloc(sizeof(GraphicExtDataHandle) + sizeof(int32_t)));
1481 handle->fd = -1;
1482 handle->reserveInts = 1;
1483 handle->reserve[0] = 0;
1484 GSError ret = cs->SetTunnelHandle(handle);
1485 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1486
1487 ret = cs->SetTunnelHandle(handle);
1488 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1489
1490 sptr<SurfaceTunnelHandle> handleGet = nullptr;
1491 handleGet = cs->GetTunnelHandle();
1492 ASSERT_NE(handleGet, nullptr);
1493 ASSERT_EQ(handle->fd, handleGet->GetHandle()->fd);
1494 ASSERT_EQ(handle->reserveInts, handleGet->GetHandle()->reserveInts);
1495 ASSERT_EQ(handle->reserve[0], handleGet->GetHandle()->reserve[0]);
1496 free(handle);
1497 }
1498
1499 /*
1500 * Function: SetTunnelHandle and GetTunnelHandle
1501 * Type: Function
1502 * Rank: Important(2)
1503 * EnvConditions: N/A
1504 * CaseDescription: 1. call SetTunnelHandle and GetTunnelHandle with nullptr and check ret
1505 */
1506 HWTEST_F(ConsumerSurfaceTest, SetAndGetTunnelHandle004, Function | MediumTest | Level2)
1507 {
1508 GraphicExtDataHandle *handle = nullptr;
1509 GSError ret = surface_->SetTunnelHandle(handle);
1510 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1511 sptr<SurfaceTunnelHandle> tunnelHandle = surface_->GetTunnelHandle();
1512 ASSERT_EQ(tunnelHandle, nullptr);
1513 }
1514
1515 /*
1516 * Function: SetPresentTimestamp and GetPresentTimestamp
1517 * Type: Function
1518 * Rank: Important(2)
1519 * EnvConditions: N/A
1520 * CaseDescription: 1. call SetPresentTimestamp with abnormal parameters and check ret
1521 * @tc.require: issueI5I57K
1522 */
1523 HWTEST_F(ConsumerSurfaceTest, SetAndGetPresentTimestamp001, Function | MediumTest | Level2)
1524 {
1525 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_UNSUPPORTED, 0};
1526 GSError ret = cs->SetPresentTimestamp(-1, timestamp);
1527 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1528 }
1529
1530 /*
1531 * Function: SetPresentTimestamp and GetPresentTimestamp
1532 * Type: Function
1533 * Rank: Important(2)
1534 * EnvConditions: N/A
1535 * CaseDescription: 1. call SetPresentTimestamp with abnormal parameters and check ret
1536 * @tc.require: issueI5I57K
1537 */
1538 HWTEST_F(ConsumerSurfaceTest, SetAndGetPresentTimestamp002, Function | MediumTest | Level2)
1539 {
1540 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_DELAY, 0};
1541 GSError ret = cs->SetPresentTimestamp(-1, timestamp);
1542 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
1543 }
1544
1545 /*
1546 * Function: SetPresentTimestamp and GetPresentTimestamp
1547 * Type: Function
1548 * Rank: Important(1)
1549 * EnvConditions: N/A
1550 * CaseDescription: 1. call SetPresentTimestamp with normal parameters and check ret
1551 * @tc.require: issueI5I57K
1552 */
1553 HWTEST_F(ConsumerSurfaceTest, SetAndGetPresentTimestamp003, Function | MediumTest | Level1)
1554 {
1555 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_DELAY, 0};
1556 GSError ret = cs->SetPresentTimestamp(firstSeqnum, timestamp);
1557 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1558 }
1559
1560 /*
1561 * Function: SetPresentTimestamp and GetPresentTimestamp
1562 * Type: Function
1563 * Rank: Important(1)
1564 * EnvConditions: N/A
1565 * CaseDescription: 1. call SetPresentTimestamp with normal parameters and check ret
1566 * @tc.require: issueI5I57K
1567 */
1568 HWTEST_F(ConsumerSurfaceTest, SetAndGetPresentTimestamp004, Function | MediumTest | Level1)
1569 {
1570 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_TIMESTAMP, 0};
1571 GSError ret = cs->SetPresentTimestamp(firstSeqnum, timestamp);
1572 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1573 }
1574
1575 /*
1576 * Function: SetPresentTimestamp and GetPresentTimestamp
1577 * Type: Function
1578 * Rank: Important(1)
1579 * EnvConditions: N/A
1580 * CaseDescription: 1. call SetPresentTimestamp with nullptr and check ret
1581 */
1582 HWTEST_F(ConsumerSurfaceTest, SetAndGetPresentTimestamp005, Function | MediumTest | Level1)
1583 {
1584 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_TIMESTAMP, 0};
1585 GSError ret = surface_->SetPresentTimestamp(firstSeqnum, timestamp);
1586 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1587 int64_t time = 0;
1588 ret = surface_->GetPresentTimestamp(firstSeqnum, GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_TIMESTAMP, time);
1589 ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
1590 }
1591
1592 /*
1593 * Function: AcquireBuffer and ReleaseBuffer
1594 * Type: Function
1595 * Rank: Important(2)
1596 * EnvConditions: N/A
1597 * CaseDescription: 1. call RequestBuffer and FlushBuffer
1598 * 2. call AcquireBuffer and ReleaseBuffer
1599 * 3. check ret
1600 */
1601 HWTEST_F(ConsumerSurfaceTest, RequestAndFlush002, Function | MediumTest | Level2)
1602 {
1603 sptr<SurfaceBuffer> buffer;
1604 int releaseFence = -1;
1605
1606 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
1607 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1608 ASSERT_NE(buffer, nullptr);
1609
1610 ret = ps->FlushBuffer(buffer, SyncFence::INVALID_FENCE, flushConfigWithDamages);
1611 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1612
1613 sptr<OHOS::SyncFence> flushFence;
1614 ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damages);
1615 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1616 ASSERT_NE(buffer, nullptr);
1617 ASSERT_EQ(damages.size(), flushConfigWithDamages.damages.size());
1618 for (decltype(damages.size()) i = 0; i < damages.size(); i++) {
1619 ASSERT_EQ(damages[i].x, flushConfigWithDamages.damages[i].x);
1620 ASSERT_EQ(damages[i].y, flushConfigWithDamages.damages[i].y);
1621 ASSERT_EQ(damages[i].w, flushConfigWithDamages.damages[i].w);
1622 ASSERT_EQ(damages[i].h, flushConfigWithDamages.damages[i].h);
1623 }
1624
1625 ASSERT_EQ(timestamp, flushConfigWithDamages.timestamp);
1626 ret = cs->ReleaseBuffer(buffer, -1);
1627 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1628 }
1629
1630 /*
1631 * Function: AttachBuffer
1632 * Type: Function
1633 * Rank: Important(2)
1634 * EnvConditions: N/A
1635 * CaseDescription: 1. call AttachBuffer
1636 * 2. check ret
1637 */
1638 HWTEST_F(ConsumerSurfaceTest, AttachBuffer001, Function | MediumTest | Level2)
1639 {
1640 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1641 ASSERT_NE(buffer, nullptr);
1642 GSError ret = cs->AttachBuffer(buffer);
1643 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1644 }
1645
1646 /*
1647 * Function: AttachBuffer
1648 * Type: Function
1649 * Rank: Important(2)
1650 * EnvConditions: N/A
1651 * CaseDescription: 1. call AttachBuffer
1652 * 2. check ret
1653 */
1654 HWTEST_F(ConsumerSurfaceTest, AttachBuffer002, Function | MediumTest | Level2)
1655 {
1656 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1657 ASSERT_NE(buffer, nullptr);
1658 int32_t timeOut = 1;
1659 GSError ret = cs->AttachBuffer(buffer, timeOut);
1660 ASSERT_NE(ret, OHOS::GSERROR_OK);
1661 }
1662
1663 /*
1664 * Function: AttachBuffer
1665 * Type: Function
1666 * Rank: Important(2)
1667 * EnvConditions: N/A
1668 * CaseDescription: 1. call AttachBuffer
1669 * 2. check ret
1670 */
1671 HWTEST_F(ConsumerSurfaceTest, AttachBuffer003, Function | MediumTest | Level2)
1672 {
1673 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
1674 ASSERT_NE(buffer, nullptr);
1675 int32_t timeOut = 1;
1676 GSError ret = cs->AttachBuffer(buffer, timeOut);
1677 ASSERT_NE(ret, GSERROR_OK);
1678 }
1679
1680 /*
1681 * Function: AttachBuffer
1682 * Type: Function
1683 * Rank: Important(2)
1684 * EnvConditions: N/A
1685 * CaseDescription: 1. call AttachBuffer with nullptr params
1686 * 2. check ret
1687 */
1688 HWTEST_F(ConsumerSurfaceTest, AttachBuffer004, Function | MediumTest | Level2)
1689 {
1690 sptr<SurfaceBuffer> buffer = nullptr;
1691 GSError ret = surface_->AttachBuffer(buffer);
1692 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1693 }
1694
1695 /*
1696 * Function: AttachBuffer
1697 * Type: Function
1698 * Rank: Important(2)
1699 * EnvConditions: N/A
1700 * CaseDescription: 1. call AttachBuffer with nullptr params
1701 * 2. check ret
1702 */
1703 HWTEST_F(ConsumerSurfaceTest, AttachBuffer005, Function | MediumTest | Level2)
1704 {
1705 sptr<SurfaceBuffer> buffer = nullptr;
1706 int32_t timeOut = 1;
1707 GSError ret = surface_->AttachBuffer(buffer, timeOut);
1708 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1709 }
1710
1711 /*
1712 * Function: RegisterSurfaceDelegator
1713 * Type: Function
1714 * Rank: Important(2)
1715 * EnvConditions: N/A
1716 * CaseDescription: 1. call RegisterSurfaceDelegator
1717 * 2. check ret
1718 */
1719 HWTEST_F(ConsumerSurfaceTest, RegisterSurfaceDelegator001, Function | MediumTest | Level2)
1720 {
1721 GSError ret = cs->RegisterSurfaceDelegator(surfaceDelegator->AsObject());
1722 ASSERT_EQ(ret, GSERROR_OK);
1723 }
1724
1725 /*
1726 * Function: RegisterSurfaceDelegator
1727 * Type: Function
1728 * Rank: Important(2)
1729 * EnvConditions: N/A
1730 * CaseDescription: 1. call RegisterSurfaceDelegator with nullptr params
1731 * 2. check ret
1732 */
1733 HWTEST_F(ConsumerSurfaceTest, RegisterSurfaceDelegator002, Function | MediumTest | Level2)
1734 {
1735 GSError ret = surface_->RegisterSurfaceDelegator(nullptr);
1736 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1737 ASSERT_NE(surfaceDelegator, nullptr);
1738 sptr<IRemoteObject> client = surfaceDelegator->AsObject();
1739 ASSERT_NE(client, nullptr);
1740 ret = surface_->RegisterSurfaceDelegator(client);
1741 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
1742 }
1743
1744 /*
1745 * Function: ConsumerRequestCpuAccess
1746 * Type: Function
1747 * Rank: Important(2)
1748 * EnvConditions: N/A
1749 * CaseDescription: 1. usage does not contain BUFFER_USAGE_CPU_HW_BOTH
1750 * 2. call ConsumerRequestCpuAccess(fasle/true)
1751 * 3. check ret
1752 */
1753 HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess001, Function | MediumTest | Level2)
1754 {
1755 using namespace HDI::Display::Graphic::Common;
1756 BufferRequestConfig config = {
1757 .width = 0x100,
1758 .height = 0x100,
1759 .strideAlignment = 0x8,
1760 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1761 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1762 .timeout = 0,
1763 };
1764 auto cSurface = IConsumerSurface::Create();
1765 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
1766 cSurface->RegisterConsumerListener(cListener);
1767 auto p = cSurface->GetProducer();
1768 auto pSurface = Surface::CreateSurfaceAsProducer(p);
1769
1770 // test default
1771 sptr<SurfaceBuffer> buffer;
1772 int releaseFence = -1;
1773 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1774 ASSERT_EQ(ret, GSERROR_OK);
1775 ASSERT_NE(buffer, nullptr);
1776
1777 std::vector<uint8_t> values;
1778 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1779 ASSERT_EQ(values.size(), 0);
1780
1781 ret = pSurface->CancelBuffer(buffer);
1782 ASSERT_EQ(ret, GSERROR_OK);
1783
1784 // test true
1785 cSurface->ConsumerRequestCpuAccess(true);
1786 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1787 ASSERT_EQ(ret, GSERROR_OK);
1788 ASSERT_NE(buffer, nullptr);
1789
1790 values.clear();
1791 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1792 ASSERT_EQ(values.size(), 0);
1793
1794 ret = pSurface->CancelBuffer(buffer);
1795 ASSERT_EQ(ret, GSERROR_OK);
1796
1797 // test false
1798 cSurface->ConsumerRequestCpuAccess(false);
1799 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1800 ASSERT_EQ(ret, GSERROR_OK);
1801 ASSERT_NE(buffer, nullptr);
1802
1803 values.clear();
1804 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1805 ASSERT_EQ(values.size(), 0);
1806
1807 ret = pSurface->CancelBuffer(buffer);
1808 ASSERT_EQ(ret, GSERROR_OK);
1809 }
1810
1811 /*
1812 * Function: ConsumerRequestCpuAccess
1813 * Type: Function
1814 * Rank: Important(2)
1815 * EnvConditions: N/A
1816 * CaseDescription: 1. usage contain BUFFER_USAGE_CPU_HW_BOTH
1817 * 2. call ConsumerRequestCpuAccess(true)
1818 * 3. check ret
1819 */
1820 HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess002, Function | MediumTest | Level2)
1821 {
1822 using namespace HDI::Display::Graphic::Common;
1823 BufferRequestConfig config = {
1824 .width = 0x100,
1825 .height = 0x100,
1826 .strideAlignment = 0x8,
1827 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1828 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH,
1829 .timeout = 0,
1830 };
1831 auto cSurface = IConsumerSurface::Create();
1832 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
1833 cSurface->RegisterConsumerListener(cListener);
1834 auto p = cSurface->GetProducer();
1835 auto pSurface = Surface::CreateSurfaceAsProducer(p);
1836
1837 // test default
1838 sptr<SurfaceBuffer> buffer;
1839 int releaseFence = -1;
1840 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1841 ASSERT_EQ(ret, GSERROR_OK);
1842 ASSERT_NE(buffer, nullptr);
1843
1844 std::vector<uint8_t> values;
1845 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1846 if (values.size() == 1) {
1847 ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_HW_ONLY);
1848 }
1849
1850 ret = pSurface->CancelBuffer(buffer);
1851 ASSERT_EQ(ret, GSERROR_OK);
1852
1853 // test true
1854 cSurface->ConsumerRequestCpuAccess(true);
1855 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1856 ASSERT_EQ(ret, GSERROR_OK);
1857 ASSERT_NE(buffer, nullptr);
1858
1859 values.clear();
1860 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1861 if (values.size() == 1) {
1862 ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_CPU_ACCESS);
1863 }
1864
1865 ret = pSurface->CancelBuffer(buffer);
1866 ASSERT_EQ(ret, GSERROR_OK);
1867
1868 // test false
1869 cSurface->ConsumerRequestCpuAccess(false);
1870 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1871 ASSERT_EQ(ret, GSERROR_OK);
1872 ASSERT_NE(buffer, nullptr);
1873
1874 values.clear();
1875 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
1876 if (values.size() == 1) {
1877 ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_HW_ONLY);
1878 }
1879
1880 ret = pSurface->CancelBuffer(buffer);
1881 ASSERT_EQ(ret, GSERROR_OK);
1882 }
1883
1884 /*
1885 * Function: ConsumerRequestCpuAccess
1886 * Type: Function
1887 * Rank: Important(2)
1888 * EnvConditions: N/A
1889 * CaseDescription: 1. call ConsumerRequestCpuAccess with nullptr
1890 * 2. check ret
1891 */
1892 HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess003, Function | MediumTest | Level2)
1893 {
1894 ASSERT_NE(surface_, nullptr);
1895 surface_->ConsumerRequestCpuAccess(true);
1896 }
1897
1898 /*
1899 * Function: InvalidParameter
1900 * Type: Function
1901 * Rank: Important(2)
1902 * EnvConditions: N/A
1903 * CaseDescription: 1. call interface with invaild input nullptr and check ret
1904 */
1905 HWTEST_F(ConsumerSurfaceTest, InvalidParameter001, Function | MediumTest | Level2)
1906 {
1907 sptr<OHOS::SurfaceBuffer> sBuffer = nullptr;
1908 sptr<OHOS::SyncFence> fence = nullptr;
1909 ASSERT_EQ(surface_->AcquireLastFlushedBuffer(sBuffer, fence, nullptr, 0, false), GSERROR_NOT_SUPPORT);
1910 ASSERT_EQ(surface_->ReleaseLastFlushedBuffer(sBuffer), GSERROR_NOT_SUPPORT);
1911 }
1912
1913 /*
1914 * Function: AttachBufferToQueue
1915 * Type: Function
1916 * Rank: Important(2)
1917 * EnvConditions: N/A
1918 * CaseDescription: 1. call AttachBufferToQueue and check ret
1919 */
1920 HWTEST_F(ConsumerSurfaceTest, AttachBufferToQueueMemLeak001, Function | MediumTest | Level2)
1921 {
1922 BufferRequestConfig config = {
1923 .width = 0x100,
1924 .height = 0x100,
1925 .strideAlignment = 0x8,
1926 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
1927 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH,
1928 .timeout = 0,
1929 };
1930 auto cSurface = IConsumerSurface::Create();
1931 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
1932 cSurface->RegisterConsumerListener(cListener);
1933 auto p = cSurface->GetProducer();
1934 auto pSurface = Surface::CreateSurfaceAsProducer(p);
1935
1936 sptr<SurfaceBuffer> buffer;
1937 int releaseFence = -1;
1938 BufferFlushConfig flushConfigTmp = {
1939 .damage = {
1940 .w = 0x100,
1941 .h = 0x100,
1942 },
1943 };
1944 int64_t timestampTmp = 0;
1945 Rect damageTmp = {};
1946 GSError ret;
1947 sptr<OHOS::SyncFence> fence;
1948 for (uint32_t i = 0; i < 3; i++) {
1949 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1950 ASSERT_EQ(ret, GSERROR_OK);
1951 ASSERT_NE(buffer, nullptr);
1952 ret = pSurface->FlushBuffer(buffer, -1, flushConfigTmp);
1953 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1954 }
1955
1956 for (uint32_t i = 0; i < 3; i++) {
1957 ret = cSurface->AcquireBuffer(buffer, fence, timestampTmp, damageTmp);
1958 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1959 ret = cSurface->DetachBufferFromQueue(buffer);
1960 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1961 }
1962 for (uint32_t i = 0; i < 3; i++) {
1963 ret = pSurface->RequestBuffer(buffer, releaseFence, config);
1964 ASSERT_EQ(ret, GSERROR_OK);
1965 }
1966 }
1967
1968 /*
1969 * Function: SetTransformHint and GetTransformHint
1970 * Type: Function
1971 * Rank: Important(1)
1972 * EnvConditions: N/A
1973 * CaseDescription: 1. call SetTransformHint with nullptr and check ret
1974 * 2. call GetTransformHint with nullptr and check ret
1975 */
1976 HWTEST_F(ConsumerSurfaceTest, SetAndGetTransformHint001, Function | MediumTest | Level1)
1977 {
1978 GraphicTransformType typeSet = GraphicTransformType::GRAPHIC_ROTATE_BUTT;
1979 GSError ret = surface_->SetTransformHint(typeSet);
1980 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
1981 GraphicTransformType typeGet = surface_->GetTransformHint();
1982 ASSERT_EQ(typeGet, GraphicTransformType::GRAPHIC_ROTATE_BUTT);
1983 }
1984
1985 /*
1986 * Function: SetSurfaceSourceType and GetSurfaceSourceType
1987 * Type: Function
1988 * Rank: Important(2)
1989 * EnvConditions: N/A
1990 * CaseDescription: 1. call SetSurfaceSourceType and check ret
1991 * 2. call GetSurfaceSourceType and check ret
1992 */
1993 HWTEST_F(ConsumerSurfaceTest, SetAndGetSurfaceSourceType001, Function | MediumTest | Level2)
1994 {
1995 OHSurfaceSource sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
1996 GSError ret = cs->SetSurfaceSourceType(sourceType);
1997 ASSERT_EQ(ret, OHOS::GSERROR_OK);
1998 ASSERT_EQ(cs->GetSurfaceSourceType(), OH_SURFACE_SOURCE_VIDEO);
1999 }
2000
2001 /*
2002 * Function: SetSurfaceSourceType and GetSurfaceSourceType
2003 * Type: Function
2004 * Rank: Important(2)
2005 * EnvConditions: N/A
2006 * CaseDescription: 1. call SetSurfaceSourceType with nullptr and check ret
2007 * 2. call GetSurfaceSourceType with nullptr and check ret
2008 */
2009 HWTEST_F(ConsumerSurfaceTest, SetAndGetSurfaceSourceType002, Function | MediumTest | Level2)
2010 {
2011 OHSurfaceSource sourceTypeSet = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
2012 GSError ret = surface_->SetSurfaceSourceType(sourceTypeSet);
2013 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2014 OHSurfaceSource sourceTypeGet = surface_->GetSurfaceSourceType();
2015 ASSERT_EQ(sourceTypeGet, OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT);
2016 }
2017
2018 /*
2019 * Function: GetGlobalAlpha
2020 * Type: Function
2021 * Rank: Important(2)
2022 * EnvConditions: N/A
2023 * CaseDescription: 1. call GetGlobalAlpha and check ret
2024 */
2025 HWTEST_F(ConsumerSurfaceTest, SetAndGetGlobalAlpha001, Function | MediumTest | Level2)
2026 {
2027 int32_t alpha = -1;
2028 ASSERT_EQ(cs->SetGlobalAlpha(alpha), GSERROR_NOT_SUPPORT);
2029 ASSERT_EQ(cs->GetGlobalAlpha(alpha), GSERROR_OK);
2030 }
2031
2032 /*
2033 * Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
2034 * Type: Function
2035 * Rank: Important(2)
2036 * EnvConditions: N/A
2037 * CaseDescription: 1. call SetSurfaceAppFrameworkType and check ret
2038 * 2. call GetSurfaceAppFrameworkType and check ret
2039 */
2040 HWTEST_F(ConsumerSurfaceTest, SetAndGetSurfaceAppFrameworkType001, Function | MediumTest | Level2)
2041 {
2042 std::string type = "test";
2043 GSError ret = cs->SetSurfaceAppFrameworkType(type);
2044 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2045 ASSERT_EQ(cs->GetSurfaceAppFrameworkType(), "test");
2046 }
2047
2048 /*
2049 * Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
2050 * Type: Function
2051 * Rank: Important(2)
2052 * EnvConditions: N/A
2053 * CaseDescription: 1. call SetSurfaceAppFrameworkType with nullptr and check ret
2054 * 2. call GetSurfaceAppFrameworkType with nullptr and check ret
2055 */
2056 HWTEST_F(ConsumerSurfaceTest, SetAndGetSurfaceAppFrameworkType002, Function | MediumTest | Level2)
2057 {
2058 std::string type = "test";
2059 GSError ret = surface_->SetSurfaceAppFrameworkType(type);
2060 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2061 ASSERT_EQ(surface_->GetSurfaceAppFrameworkType(), "");
2062 }
2063
2064 /*
2065 * Function: QueryIfBufferAvailable
2066 * Type: Function
2067 * Rank: Important(2)
2068 * EnvConditions: N/A
2069 * CaseDescription: 1. call QueryIfBufferAvailable with consumer_ is nullptr
2070 * 2. check ret
2071 */
2072 HWTEST_F(ConsumerSurfaceTest, QueryIfBufferAvailable001, Function | MediumTest | Level2)
2073 {
2074 bool ret = surface_->QueryIfBufferAvailable();
2075 ASSERT_EQ(ret, false);
2076 }
2077
2078 /*
2079 * Function: QueryIfBufferAvailable
2080 * Type: Function
2081 * Rank: Important(2)
2082 * EnvConditions: N/A
2083 * CaseDescription: 1. call QueryIfBufferAvailable with normal
2084 * 2. check ret
2085 */
2086 HWTEST_F(ConsumerSurfaceTest, QueryIfBufferAvailable002, Function | MediumTest | Level2)
2087 {
2088 ASSERT_NE(cs, nullptr);
2089 bool ret = cs->QueryIfBufferAvailable();
2090 ASSERT_EQ(ret, true);
2091 }
2092
2093 /*
2094 * Function: SetTransform and GetTransform
2095 * Type: Function
2096 * Rank: Important(2)
2097 * EnvConditions: N/A
2098 * CaseDescription: 1. call GetTransform by default
2099 */
2100 HWTEST_F(ConsumerSurfaceTest, SetAndGetTransform001, Function | MediumTest | Level2)
2101 {
2102 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_NONE);
2103 }
2104
2105 /*
2106 * Function: SetTransform and GetTransform
2107 * Type: Function
2108 * Rank: Important(1)
2109 * EnvConditions: N/A
2110 * CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
2111 * 2. check ret
2112 */
2113 HWTEST_F(ConsumerSurfaceTest, SetAndGetTransform002, Function | MediumTest | Level1)
2114 {
2115 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_90;
2116 GSError ret = ps->SetTransform(transform);
2117 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2118 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_90);
2119 }
2120
2121 /*
2122 * Function: SetTransform and GetTransform
2123 * Type: Function
2124 * Rank: Important(1)
2125 * EnvConditions: N/A
2126 * CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
2127 * 2. check ret
2128 */
2129 HWTEST_F(ConsumerSurfaceTest, SetAndGetTransform003, Function | MediumTest | Level1)
2130 {
2131 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_180;
2132 GSError ret = ps->SetTransform(transform);
2133 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2134 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_180);
2135 }
2136
2137 /*
2138 * Function: SetTransform and GetTransform
2139 * Type: Function
2140 * Rank: Important(1)
2141 * EnvConditions: N/A
2142 * CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
2143 * 2. check ret
2144 */
2145 HWTEST_F(ConsumerSurfaceTest, SetAndGetTransform004, Function | MediumTest | Level1)
2146 {
2147 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_270;
2148 GSError ret = ps->SetTransform(transform);
2149 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2150 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_270);
2151 }
2152
2153 /*
2154 * Function: SetTransform and GetTransform
2155 * Type: Function
2156 * Rank: Important(1)
2157 * EnvConditions: N/A
2158 * CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
2159 * 2. check ret
2160 */
2161 HWTEST_F(ConsumerSurfaceTest, SetAndGetTransform005, Function | MediumTest | Level1)
2162 {
2163 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_NONE;
2164 GSError ret = ps->SetTransform(transform);
2165 ASSERT_EQ(ret, OHOS::GSERROR_OK);
2166 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_NONE);
2167 }
2168
2169 /*
2170 * Function: SetTransform and GetTransform
2171 * Type: Function
2172 * Rank: Important(1)
2173 * EnvConditions: N/A
2174 * CaseDescription: 1. call SetTransform GetTransform with nullptr
2175 * 2. check ret
2176 */
2177 HWTEST_F(ConsumerSurfaceTest, SetAndGetTransform006, Function | MediumTest | Level1)
2178 {
2179 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_NONE;
2180 GSError ret = surface_->SetTransform(transform);
2181 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
2182 ASSERT_EQ(surface_->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_BUTT);
2183 }
2184 }
2185