1 /*
2 * Copyright (c) 2020-2022 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
16 #include <climits>
17 #include <gtest/gtest.h>
18
19 #include "buffer_common.h"
20 #include "surface.h"
21 #include "surface_impl.h"
22
23 using namespace std;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 class SurfaceTest : public testing::Test {
28 public:
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp();
32 void TearDown();
33 };
34
35 class BufferConsumerTest : public IBufferConsumerListener {
36 public:
37 void OnBufferAvailable();
~BufferConsumerTest()38 ~BufferConsumerTest() {}
39 };
OnBufferAvailable()40 void BufferConsumerTest::OnBufferAvailable()
41 {
42 }
43
SetUpTestCase(void)44 void SurfaceTest::SetUpTestCase(void)
45 {
46 }
47
TearDownTestCase(void)48 void SurfaceTest::TearDownTestCase(void)
49 {
50 }
51
SetUp(void)52 void SurfaceTest::SetUp(void)
53 {
54 }
55
TearDown(void)56 void SurfaceTest::TearDown(void)
57 {
58 }
59
60 /*
61 * Feature: Surface
62 * Function: new SurfaceBuffer
63 * SubFunction: NA
64 * FunctionPoints: Surface Buffer initialization.
65 * EnvConditions: NA
66 * CaseDescription: Verify the Surface Buffer initialization.
67 */
68 HWTEST_F(SurfaceTest, surface_buffer_001, TestSize.Level1)
69 {
70 SurfaceBufferImpl* buffer = new SurfaceBufferImpl();
71 EXPECT_TRUE(buffer);
72 EXPECT_EQ(0, buffer->GetKey());
73 EXPECT_EQ(0, buffer->GetPhyAddr());
74 EXPECT_EQ(0, buffer->GetSize());
75 EXPECT_EQ(0, buffer->GetUsage());
76 EXPECT_EQ(0, buffer->GetDeletePending());
77 EXPECT_EQ(0, buffer->GetState());
78
79 int32_t aValue32;
80 int32_t ret = buffer->GetInt32(1, aValue32); // key = 1, test has value with key(1). if not, ret < 0.
81 EXPECT_LT(ret, 0);
82 int64_t aValue64;
83 ret = buffer->GetInt64(1, aValue64); // key = 1, test has value with key(1). if not, ret < 0.
84 EXPECT_LT(ret, 0);
85 delete buffer;
86 }
87
88 /*
89 * Feature: Surface
90 * Function: new SurfaceBuffer(uint32_t size, uint32_t flag, uint32_t usage)
91 * SubFunction: NA
92 * FunctionPoints: Surface Buffer initialization.
93 * EnvConditions: NA
94 * CaseDescription: Verify the Surface Buffer initialization.
95 */
96 HWTEST_F(SurfaceTest, surface_buffer_002, TestSize.Level1)
97 {
98 int32_t usage = BUFFER_CONSUMER_USAGE_HARDWARE; // alloc buffer with usage = BUFFER_CONSUMER_USAGE_HARDWARE
99 int32_t size = 1024; // alloc buffer with size = 1024;
100
101 SurfaceBufferImpl* buffer = new SurfaceBufferImpl();
102 buffer->SetUsage(usage);
103 buffer->SetMaxSize(size);
104 EXPECT_TRUE(buffer);
105 EXPECT_EQ(0, buffer->GetKey());
106 EXPECT_EQ(0, buffer->GetPhyAddr());
107 EXPECT_EQ(size, buffer->GetMaxSize());
108 EXPECT_EQ(usage, buffer->GetUsage());
109 EXPECT_EQ(0, buffer->GetDeletePending());
110 EXPECT_EQ(0, buffer->GetState());
111
112 int32_t aValue32;
113 int32_t ret = buffer->GetInt32(1, aValue32); // key = 1, test has value with key(1). if not, ret < 0.
114 EXPECT_LT(ret, 0);
115 int64_t aValue64;
116 ret = buffer->GetInt64(1, aValue64); // key = 1, test has value with key(1). if not, ret < 0?
117 EXPECT_LT(ret, 0);
118 delete buffer;
119 }
120
121 /*
122 * Feature: Surface
123 * Function: Surface Buffer set/get key-value
124 * SubFunction: NA
125 * FunctionPoints: buffer attr and extra attr set/get.
126 * EnvConditions: NA
127 * CaseDescription: Verify the Surface Buffer attr set/get.
128 */
129 HWTEST_F(SurfaceTest, surface_buffer_003, TestSize.Level1)
130 {
131 SurfaceBufferImpl buffer;
132
133 EXPECT_EQ(0, buffer.GetPhyAddr());
134 uint64_t phyAddr = 0x040a7000; // mock physical address as 0x040a7000
135 buffer.SetPhyAddr(phyAddr);
136 EXPECT_EQ(phyAddr, buffer.GetPhyAddr());
137
138 EXPECT_EQ(0, buffer.GetMaxSize());
139 uint32_t size = 1;
140 buffer.SetMaxSize(size);
141 EXPECT_EQ(size, buffer.GetMaxSize());
142
143 EXPECT_EQ(0, buffer.GetUsage());
144 uint32_t usage = 1;
145 buffer.SetUsage(usage);
146 EXPECT_EQ(usage, buffer.GetUsage());
147
148 EXPECT_EQ(0, buffer.GetDeletePending());
149 uint8_t deletePending = 1;
150 buffer.SetDeletePending(deletePending);
151 EXPECT_EQ(deletePending, buffer.GetDeletePending());
152
153 EXPECT_EQ(0, buffer.GetState());
154 buffer.SetState(BUFFER_STATE_REQUEST);
155 EXPECT_EQ(BUFFER_STATE_REQUEST, buffer.GetState());
156
157 int32_t aValue32;
158 int32_t ret = buffer.GetInt32(1, aValue32); // key = 1, test has value for key(1). if not, ret < 0.
159 EXPECT_LT(ret, 0);
160
161 int32_t key32 = 1; // set key-value , key = 1;
162 int32_t value32 = 100; // set key-value, value = 1;
163 buffer.SetInt32(key32, value32);
164 ret = buffer.GetInt32(key32, aValue32);
165 EXPECT_EQ(ret, 0);
166 EXPECT_EQ(value32, aValue32);
167
168 int64_t aValue64;
169 ret = buffer.GetInt64(1, aValue64); // key = 1, test has value for key(1). if not, ret < 0?
170 EXPECT_LT(ret, 0);
171
172 uint32_t key64 = 2; // set key-value , key = 2;
173 int64_t value64 = 0x040a7003; // set key-value, value = 0x040a7003;
174 buffer.SetInt64(key64, value64);
175 ret = buffer.GetInt64(key64, aValue64);
176 EXPECT_EQ(ret, 0);
177 EXPECT_EQ(value64, aValue64);
178
179 value64 = 0x040a7004; // set key-value, value = 0x040a7004 over cover 0x040a7003;
180 buffer.SetInt64(key64, value64);
181 ret = buffer.GetInt64(key64, aValue64);
182 EXPECT_EQ(ret, 0);
183 EXPECT_EQ(value64, aValue64);
184 }
185
186 /*
187 * Feature: Surface
188 * Function: Surface set width and height
189 * SubFunction: NA
190 * FunctionPoints: buffer consuctor and set/get width and height.
191 * EnvConditions: NA
192 * CaseDescription: Surface constuctor and set/set attr.
193 */
194 HWTEST_F(SurfaceTest, surface_set_001, TestSize.Level1)
195 {
196 IBufferConsumerListener* consumerListener = new BufferConsumerTest();
197 if (consumerListener == nullptr) {
198 return;
199 }
200 Surface* surface = Surface::CreateSurface();
201 if (surface == nullptr) {
202 delete consumerListener;
203 consumerListener = nullptr;
204 return;
205 }
206 surface->RegisterConsumerListener(*consumerListener);
207
208 EXPECT_EQ(1, surface->GetQueueSize());
209 EXPECT_EQ(0, surface->GetUsage()); // default usage is BUFFER_CONSUMER_USAGE_SORTWARE(0)
210 EXPECT_EQ(0, surface->GetSize());
211 EXPECT_EQ(0, surface->GetWidth());
212 EXPECT_EQ(0, surface->GetHeight());
213 EXPECT_EQ(101, surface->GetFormat()); // default format is IMAGE_PIXEL_FORMAT_RGB565(101)
214 EXPECT_EQ(4, surface->GetStrideAlignment()); // default format stride alignment is 4
215
216 // set width = 0 failed, return default.
217 surface->SetWidthAndHeight(0, 1080);
218 EXPECT_EQ(0, surface->GetWidth());
219 EXPECT_EQ(0, surface->GetHeight());
220
221 // set width = 7681 failed, return default.
222 surface->SetWidthAndHeight(7681, 1080);
223 EXPECT_EQ(0, surface->GetWidth());
224 EXPECT_EQ(0, surface->GetHeight());
225
226 // set width = 7680 succeed, return 7680.
227 surface->SetWidthAndHeight(7680, 1080);
228 EXPECT_EQ(7680, surface->GetWidth());
229 EXPECT_EQ(1080, surface->GetHeight());
230
231 // set width = 1920 succeed, return 1980.
232 surface->SetWidthAndHeight(1920, 1080);
233 EXPECT_EQ(1920, surface->GetWidth());
234 EXPECT_EQ(1080, surface->GetHeight());
235
236 // set height = 0 failed, return default.
237 surface->SetWidthAndHeight(1920, 0);
238 EXPECT_EQ(1920, surface->GetWidth());
239 EXPECT_EQ(1080, surface->GetHeight());
240
241 // set height = 7681 failed, return default.
242 surface->SetWidthAndHeight(1920, 7681);
243 EXPECT_EQ(1920, surface->GetWidth());
244 EXPECT_EQ(1080, surface->GetHeight());
245
246 // set height = 7680 succeed, return 7680.
247 surface->SetWidthAndHeight(1920, 7680);
248 EXPECT_EQ(1920, surface->GetWidth());
249 EXPECT_EQ(7680, surface->GetHeight());
250
251 // set height = 720 succeed, return 720.
252 surface->SetWidthAndHeight(1280, 720);
253 EXPECT_EQ(1280, surface->GetWidth());
254 EXPECT_EQ(720, surface->GetHeight());
255
256 surface->UnregisterConsumerListener();
257 delete surface;
258 delete consumerListener;
259 }
260
261 /*
262 * Feature: Surface
263 * Function: Surface set format
264 * SubFunction: NA
265 * FunctionPoints: buffer consuctor and set/get format.
266 * EnvConditions: NA
267 * CaseDescription: Surface constuctor and set/set format.
268 */
269 HWTEST_F(SurfaceTest, surface_set_002, TestSize.Level1)
270 {
271 IBufferConsumerListener* consumerListener = new BufferConsumerTest();
272 if (consumerListener == nullptr) {
273 return;
274 }
275 Surface* surface = Surface::CreateSurface();
276 if (surface == nullptr) {
277 delete consumerListener;
278 consumerListener = nullptr;
279 return;
280 }
281 surface->RegisterConsumerListener(*consumerListener);
282
283 EXPECT_EQ(1, surface->GetQueueSize());
284 EXPECT_EQ(0, surface->GetUsage()); // default usage is BUFFER_CONSUMER_USAGE_SORTWARE(0)
285 EXPECT_EQ(0, surface->GetSize());
286 EXPECT_EQ(0, surface->GetWidth());
287 EXPECT_EQ(0, surface->GetHeight());
288 EXPECT_EQ(101, surface->GetFormat()); // default format is IMAGE_PIXEL_FORMAT_RGB565(101)
289 EXPECT_EQ(4, surface->GetStrideAlignment()); // default format stride alignment is 4
290
291 // set format 0 failed, return default.
292 surface->SetFormat(0);
293 EXPECT_EQ(101, surface->GetFormat());
294
295 // set format 102 succeed, return 102.
296 surface->SetFormat(102);
297 EXPECT_EQ(102, surface->GetFormat());
298
299 surface->UnregisterConsumerListener();
300 delete surface;
301 delete consumerListener;
302 }
303
304 /*
305 * Feature: Surface
306 * Function: Surface set stride alignment
307 * SubFunction: NA
308 * FunctionPoints: buffer consuctor and set/get stride alignment.
309 * EnvConditions: NA
310 * CaseDescription: Surface constuctor and set/set stride alignment.
311 */
312 HWTEST_F(SurfaceTest, surface_set_003, TestSize.Level1)
313 {
314 IBufferConsumerListener* consumerListener = new BufferConsumerTest();
315 if (consumerListener == nullptr) {
316 return;
317 }
318 Surface* surface = Surface::CreateSurface();
319 if (surface == nullptr) {
320 delete consumerListener;
321 consumerListener = nullptr;
322 return;
323 }
324 surface->RegisterConsumerListener(*consumerListener);
325
326 EXPECT_EQ(1, surface->GetQueueSize());
327 EXPECT_EQ(0, surface->GetUsage()); // default usage is BUFFER_CONSUMER_USAGE_SORTWARE(0)
328 EXPECT_EQ(0, surface->GetSize());
329 EXPECT_EQ(0, surface->GetWidth());
330 EXPECT_EQ(0, surface->GetHeight());
331 EXPECT_EQ(101, surface->GetFormat()); // default format is IMAGE_PIXEL_FORMAT_RGB565(101)
332 EXPECT_EQ(4, surface->GetStrideAlignment()); // default format stride alignment is 4
333
334 surface->SetWidthAndHeight(99, 90);
335 SurfaceBuffer* bufferFirst = surface->RequestBuffer();
336 EXPECT_EQ(208, surface->GetStride());
337 surface->CancelBuffer(bufferFirst);
338
339 // set stride alignment 3 failed, return default.SetStrideAlignment has expired, delete again
340 surface->SetStrideAlignment(3);
341 EXPECT_EQ(4, surface->GetStrideAlignment());
342
343 // set stride alignment 33 failed, return default.SetStrideAlignment has expired, delete again
344 surface->SetStrideAlignment(33);
345 EXPECT_EQ(4, surface->GetStrideAlignment());
346
347 // set stride alignment 32 succeed, return default.SetStrideAlignment has expired, delete again
348 surface->SetStrideAlignment(32);
349 EXPECT_EQ(32, surface->GetStrideAlignment());
350
351 surface->UnregisterConsumerListener();
352 delete surface;
353 delete consumerListener;
354 }
355
356 /*
357 * Feature: Surface
358 * Function: Surface set size
359 * SubFunction: NA
360 * FunctionPoints: buffer consuctor and set/get size.
361 * EnvConditions: NA
362 * CaseDescription: Surface constuctor and set/set size.
363 */
364 HWTEST_F(SurfaceTest, surface_set_004, TestSize.Level1)
365 {
366 IBufferConsumerListener* consumerListener = new BufferConsumerTest();
367 if (consumerListener == nullptr) {
368 return;
369 }
370 Surface* surface = Surface::CreateSurface();
371 if (surface == nullptr) {
372 delete consumerListener;
373 consumerListener = nullptr;
374 return;
375 }
376 surface->RegisterConsumerListener(*consumerListener);
377
378 EXPECT_EQ(1, surface->GetQueueSize());
379 EXPECT_EQ(0, surface->GetUsage()); // default usage is BUFFER_CONSUMER_USAGE_SORTWARE(0)
380 EXPECT_EQ(0, surface->GetSize());
381 EXPECT_EQ(0, surface->GetWidth());
382 EXPECT_EQ(0, surface->GetHeight());
383 EXPECT_EQ(101, surface->GetFormat()); // default format is IMAGE_PIXEL_FORMAT_RGB565(101)
384 EXPECT_EQ(4, surface->GetStrideAlignment()); // default format stride alignment is 4
385
386 // set size 0 failed, return default.
387 surface->SetSize(0);
388 EXPECT_EQ(0, surface->GetSize());
389
390 // set size 58982400 failed, return default.
391 surface->SetSize(58982400);
392 EXPECT_EQ(0, surface->GetSize());
393
394 // set size 1024 succeed, return default.
395 surface->SetSize(1024);
396 EXPECT_EQ(1024, surface->GetSize());
397
398 surface->UnregisterConsumerListener();
399 delete surface;
400 delete consumerListener;
401 }
402
403 /*
404 * Feature: Surface
405 * Function: Surface set usage
406 * SubFunction: NA
407 * FunctionPoints: buffer consuctor and set/get usage.
408 * EnvConditions: NA
409 * CaseDescription: Surface constuctor and set/set usage.
410 */
411 HWTEST_F(SurfaceTest, surface_set_005, TestSize.Level1)
412 {
413 IBufferConsumerListener* consumerListener = new BufferConsumerTest();
414 if (consumerListener == nullptr) {
415 return;
416 }
417 Surface* surface = Surface::CreateSurface();
418 if (surface == nullptr) {
419 delete consumerListener;
420 consumerListener = nullptr;
421 return;
422 }
423 surface->RegisterConsumerListener(*consumerListener);
424
425 EXPECT_EQ(1, surface->GetQueueSize());
426 EXPECT_EQ(0, surface->GetUsage()); // default usage is BUFFER_CONSUMER_USAGE_SORTWARE(0)
427 EXPECT_EQ(0, surface->GetSize());
428 EXPECT_EQ(0, surface->GetWidth());
429 EXPECT_EQ(0, surface->GetHeight());
430 EXPECT_EQ(0, surface->GetHeight());
431 EXPECT_EQ(101, surface->GetFormat()); // default format is IMAGE_PIXEL_FORMAT_RGB565(101)
432 EXPECT_EQ(4, surface->GetStrideAlignment()); // default format stride alignment is 4
433
434 // set size BUFFER_CONSUMER_USAGE_MAX(4) failed, return default.
435 surface->SetUsage(4);
436 EXPECT_EQ(0, surface->GetUsage());
437
438 // set size 3 succeed, return default.
439 surface->SetUsage(3);
440 EXPECT_EQ(3, surface->GetUsage());
441
442 surface->UnregisterConsumerListener();
443 delete surface;
444 delete consumerListener;
445 }
446
447 /*
448 * Feature: Surface
449 * Function: Surface set queue size
450 * SubFunction: NA
451 * FunctionPoints: buffer consuctor and set/get queue size.
452 * EnvConditions: NA
453 * CaseDescription: Surface constuctor and set/set attr.
454 */
455 HWTEST_F(SurfaceTest, surface_set_006, TestSize.Level1)
456 {
457 IBufferConsumerListener* consumerListener = new BufferConsumerTest();
458 if (consumerListener == nullptr) {
459 return;
460 }
461 Surface* surface = Surface::CreateSurface();
462 if (surface == nullptr) {
463 delete consumerListener;
464 consumerListener = nullptr;
465 return;
466 }
467 surface->RegisterConsumerListener(*consumerListener);
468
469 EXPECT_EQ(1, surface->GetQueueSize());
470 EXPECT_EQ(0, surface->GetUsage()); // default usage is BUFFER_CONSUMER_USAGE_SORTWARE(0)
471 EXPECT_EQ(0, surface->GetSize());
472 EXPECT_EQ(0, surface->GetWidth());
473 EXPECT_EQ(0, surface->GetHeight());
474 EXPECT_EQ(0, surface->GetHeight());
475 EXPECT_EQ(101, surface->GetFormat()); // default format is IMAGE_PIXEL_FORMAT_RGB565(101)
476 EXPECT_EQ(4, surface->GetStrideAlignment()); // default format stride alignment is 4
477
478 // set queue size failed, return default.
479 surface->SetQueueSize(0);
480 EXPECT_EQ(1, surface->GetQueueSize());
481
482 // set queue size failed more than SURFACE_MAX_QUEUE_SIZE(10), return default.
483 surface->SetQueueSize(11);
484 EXPECT_EQ(1, surface->GetQueueSize());
485
486 // set queue size SURFACE_MAX_QUEUE_SIZE(10), return 10.
487 surface->SetQueueSize(10);
488 EXPECT_EQ(10, surface->GetQueueSize());
489
490 // set queue size 5 succeed, return 5.
491 surface->SetQueueSize(5);
492 EXPECT_EQ(5, surface->GetQueueSize());
493
494 surface->UnregisterConsumerListener();
495 delete surface;
496 delete consumerListener;
497 }
498
499 /*
500 * Feature: Surface
501 * Function: Surface set user data
502 * SubFunction: NA
503 * FunctionPoints: buffer consuctor and set/get user data.
504 * EnvConditions: NA
505 * CaseDescription: Surface constuctor and set/set user data.
506 */
507 HWTEST_F(SurfaceTest, surface_set_007, TestSize.Level1)
508 {
509 IBufferConsumerListener* consumerListener = new BufferConsumerTest();
510 if (consumerListener == nullptr) {
511 return;
512 }
513 Surface* surface = Surface::CreateSurface();
514 if (surface == nullptr) {
515 delete consumerListener;
516 consumerListener = nullptr;
517 return;
518 }
519 surface->RegisterConsumerListener(*consumerListener);
520
521 EXPECT_EQ(1, surface->GetQueueSize());
522 EXPECT_EQ(0, surface->GetUsage()); // default usage is BUFFER_CONSUMER_USAGE_SORTWARE(0)
523 EXPECT_EQ(0, surface->GetSize());
524 EXPECT_EQ(0, surface->GetWidth());
525 EXPECT_EQ(0, surface->GetHeight());
526 EXPECT_EQ(101, surface->GetFormat()); // default format is IMAGE_PIXEL_FORMAT_RGB565(101)
527 EXPECT_EQ(4, surface->GetStrideAlignment()); // default format stride alignment is 4
528
529 surface->SetUserData("testkey", "testvalue");
530 EXPECT_EQ("testvalue", surface->GetUserData("testkey"));
531
532 surface->UnregisterConsumerListener();
533 delete surface;
534 delete consumerListener;
535 }
536
537 /*
538 * Feature: Surface
539 * Function: Surface single process constuctor.
540 * SubFunction: NA
541 * FunctionPoints: buffer constuctor and set/get attr.
542 * EnvConditions: NA
543 * CaseDescription: Surface constuctor.
544 */
545 HWTEST_F(SurfaceTest, surface_001, TestSize.Level1)
546 {
547 IBufferConsumerListener* consumerListener = new BufferConsumerTest();
548 if (consumerListener == nullptr) {
549 return;
550 }
551 Surface* surface = Surface::CreateSurface();
552 if (surface == nullptr) {
553 delete consumerListener;
554 consumerListener = nullptr;
555 return;
556 }
557 surface->RegisterConsumerListener(*consumerListener);
558
559 EXPECT_EQ(1, surface->GetQueueSize());
560 EXPECT_EQ(0, surface->GetUsage()); // default usage is BUFFER_CONSUMER_USAGE_SORTWARE(0)
561 EXPECT_EQ(0, surface->GetSize());
562 EXPECT_EQ(0, surface->GetWidth());
563 EXPECT_EQ(0, surface->GetHeight());
564 EXPECT_EQ(0, surface->GetHeight());
565 EXPECT_EQ(101, surface->GetFormat()); // default format is IMAGE_PIXEL_FORMAT_RGB565(101)
566 EXPECT_EQ(4, surface->GetStrideAlignment()); // default format stride alignment is 4
567
568 surface->SetSize(1024); // Set alloc 1024B SHM
569 EXPECT_EQ(1024, surface->GetSize());
570
571 surface->SetWidthAndHeight(101, 202); // set width(101), height(202)
572 surface->SetFormat(102); // set format IMAGE_PIXEL_FORMAT_ARGB1555(102)
573 surface->SetStrideAlignment(8); // set format stride alignment is 8
574
575 EXPECT_EQ(101, surface->GetWidth());
576 EXPECT_EQ(202, surface->GetHeight());
577 EXPECT_EQ(102, surface->GetFormat());
578 EXPECT_EQ(8, surface->GetStrideAlignment());
579 SurfaceBuffer* bufferFirst = surface->RequestBuffer();
580 EXPECT_EQ(208, surface->GetStride()); // calculate by width, height, format.
581 EXPECT_EQ(42016, surface->GetSize()); // calculate by width, height, format.
582 surface->CancelBuffer(bufferFirst);
583
584 surface->UnregisterConsumerListener();
585 delete surface;
586 delete consumerListener;
587 }
588
589 /*
590 * Feature: Surface
591 * Function: Surface single process request and cancel Buffer
592 * SubFunction: NA
593 * FunctionPoints: buffer request and cancel.
594 * EnvConditions: NA
595 * CaseDescription: Surface single process request and cancel Buffer.
596 */
597 HWTEST_F(SurfaceTest, surface_002, TestSize.Level1)
598 {
599 Surface* surface = Surface::CreateSurface();
600 if (surface == nullptr) {
601 return;
602 }
603
604 SurfaceBuffer* bufferFirst = surface->RequestBuffer(); // no size, return null pointer
605 EXPECT_FALSE(bufferFirst);
606
607 surface->SetSize(1024); // Set alloc 1024B SHM
608 bufferFirst = surface->RequestBuffer();
609 EXPECT_TRUE(bufferFirst);
610
611 SurfaceBuffer* bufferSecond = surface->RequestBuffer(); // default queue size = 1, second return null pointer
612
613 EXPECT_FALSE(bufferSecond);
614 surface->CancelBuffer(bufferFirst);
615 EXPECT_TRUE(surface->RequestBuffer());
616
617 delete surface;
618 }
619
620 /*
621 * Feature: Surface
622 * Function: Surface single process request and flush Buffer
623 * SubFunction: NA
624 * FunctionPoints: buffer request and flush.
625 * EnvConditions: NA
626 * CaseDescription: Surface single process request and flush Buffer.
627 */
628 HWTEST_F(SurfaceTest, surface_003, TestSize.Level1)
629 {
630 Surface* surface = Surface::CreateSurface();
631 ASSERT_TRUE(surface);
632
633 SurfaceBuffer* requestBuffer = surface->RequestBuffer(); // no size, return null pointer
634 EXPECT_FALSE(requestBuffer);
635
636 surface->SetWidthAndHeight(454, 454); // 454 : surface width and height
637 requestBuffer = surface->RequestBuffer();
638 EXPECT_TRUE(requestBuffer);
639
640 SurfaceBufferImpl* buffer = new SurfaceBufferImpl();
641 EXPECT_TRUE(surface->FlushBuffer(buffer) != 0); // Not allocated by surface, could not flush.
642 EXPECT_EQ(0, surface->FlushBuffer(requestBuffer)); // allocated by surface, could flush.
643
644 delete buffer;
645 delete surface;
646 }
647
648 /*
649 * Feature: Surface
650 * Function: Surface single process acquire Buffer
651 * SubFunction: NA
652 * FunctionPoints: buffer acquire buffer
653 * EnvConditions: NA
654 * CaseDescription: Surface single process acquire Buffer.
655 */
656 HWTEST_F(SurfaceTest, surface_004, TestSize.Level1)
657 {
658 Surface* surface = Surface::CreateSurface();
659 ASSERT_TRUE(surface);
660
661 SurfaceBuffer* acquireBuffer = surface->AcquireBuffer(); // no size, return null pointer
662 EXPECT_FALSE(acquireBuffer);
663
664 surface->SetSize(1024); // Set alloc 1024B SHM
665 SurfaceBuffer* requestBuffer = surface->RequestBuffer();
666 if (requestBuffer == nullptr) {
667 delete surface;
668 return;
669 }
670 requestBuffer->SetInt32(10, 11); // set key-value <10, 11>
671
672 EXPECT_EQ(0, surface->FlushBuffer(requestBuffer)); // allocated by surface, could flush.
673
674 acquireBuffer = surface->AcquireBuffer();
675 ASSERT_TRUE(acquireBuffer);
676 int32_t value;
677 acquireBuffer->GetInt32(10, value);
678 EXPECT_EQ(11, value);
679
680 delete surface;
681 }
682
683 /*
684 * Feature: Surface
685 * Function: Surface single process release Buffer
686 * SubFunction: NA
687 * FunctionPoints: buffer release buffer
688 * EnvConditions: NA
689 * CaseDescription: Surface single process release Buffer.
690 */
691 HWTEST_F(SurfaceTest, surface_005, TestSize.Level1)
692 {
693 Surface* surface = Surface::CreateSurface();
694 ASSERT_TRUE(surface);
695
696 SurfaceBufferImpl* buffer = new SurfaceBufferImpl();
697 EXPECT_FALSE(surface->ReleaseBuffer(buffer)); // Not allocated by surface, could not release
698
699 SurfaceBuffer* acquireBuffer = surface->AcquireBuffer(); // no size, return null pointer
700 EXPECT_FALSE(acquireBuffer);
701
702 surface->SetSize(1024); // Set alloc 1024B SHM
703 SurfaceBuffer* requestBuffer = surface->RequestBuffer();
704 if (requestBuffer == nullptr) {
705 delete buffer;
706 delete surface;
707 return;
708 }
709 requestBuffer->SetInt32(10, 11); // set key-value <10, 11>
710
711 EXPECT_EQ(0, surface->FlushBuffer(requestBuffer)); // allocated by surface, could flush.
712
713 acquireBuffer = surface->AcquireBuffer();
714 if (acquireBuffer == nullptr) {
715 delete buffer;
716 delete surface;
717 return;
718 }
719 int32_t value;
720 acquireBuffer->GetInt32(10, value);
721 EXPECT_EQ(11, value);
722
723 EXPECT_TRUE(surface->ReleaseBuffer(acquireBuffer));
724 EXPECT_TRUE(acquireBuffer->GetInt32(10, value) != 0);
725
726 delete buffer;
727 delete surface;
728 }
729
730 /*
731 * Feature: Surface
732 * Function: Surface single process release Buffer
733 * SubFunction: NA
734 * FunctionPoints: buffer release buffer
735 * EnvConditions: NA
736 * CaseDescription: Surface single process release Buffer.
737 */
738 HWTEST_F(SurfaceTest, surface_006, TestSize.Level1)
739 {
740 IBufferConsumerListener* consumerListener = new BufferConsumerTest();
741 if (consumerListener == nullptr) {
742 return;
743 }
744 Surface* surface = Surface::CreateSurface();
745 if (surface == nullptr) {
746 delete consumerListener;
747 consumerListener = nullptr;
748 return;
749 }
750 surface->RegisterConsumerListener(*consumerListener);
751
752 SurfaceBufferImpl* buffer = new SurfaceBufferImpl();
753 EXPECT_FALSE(surface->ReleaseBuffer(buffer)); // Not allocated by surface, could not release
754
755 SurfaceBuffer* acquireBuffer = surface->AcquireBuffer(); // no size, return null pointer
756 EXPECT_FALSE(acquireBuffer);
757
758 surface->SetSize(1024); // Set alloc 1024B SHM
759 SurfaceBuffer* requestBuffer = surface->RequestBuffer();
760 if (requestBuffer == nullptr) {
761 delete buffer;
762 buffer = nullptr;
763 delete surface;
764 surface = nullptr;
765 delete consumerListener;
766 consumerListener = nullptr;
767 return;
768 }
769
770 requestBuffer->SetInt32(10, 11); // set key-value <10, 11>
771
772 EXPECT_EQ(0, surface->FlushBuffer(requestBuffer)); // allocated by surface, could flush.
773
774 acquireBuffer = surface->AcquireBuffer();
775 if (acquireBuffer == nullptr) {
776 delete buffer;
777 buffer = nullptr;
778 delete surface;
779 surface = nullptr;
780 delete consumerListener;
781 consumerListener = nullptr;
782 return;
783 }
784
785 int32_t value;
786 acquireBuffer->GetInt32(10, value);
787 EXPECT_EQ(11, value);
788
789 EXPECT_TRUE(surface->ReleaseBuffer(acquireBuffer));
790 EXPECT_TRUE(acquireBuffer->GetInt32(10, value) != 0);
791
792 delete buffer;
793 delete surface;
794 delete consumerListener;
795 }
796 } // namespace OHOS
797