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
23using namespace std;
24using namespace testing::ext;
25
26namespace OHOS {
27class SurfaceTest : public testing::Test {
28public:
29    static void SetUpTestCase(void);
30    static void TearDownTestCase(void);
31    void SetUp();
32    void TearDown();
33};
34
35class BufferConsumerTest : public IBufferConsumerListener {
36public:
37    void OnBufferAvailable();
38    ~BufferConsumerTest() {}
39};
40void BufferConsumerTest::OnBufferAvailable()
41{
42}
43
44void SurfaceTest::SetUpTestCase(void)
45{
46}
47
48void SurfaceTest::TearDownTestCase(void)
49{
50}
51
52void SurfaceTest::SetUp(void)
53{
54}
55
56void 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 */
68HWTEST_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 */
96HWTEST_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 */
129HWTEST_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 */
194HWTEST_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 */
269HWTEST_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 */
312HWTEST_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 */
364HWTEST_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 */
411HWTEST_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 */
455HWTEST_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 */
507HWTEST_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 */
545HWTEST_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 */
597HWTEST_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 */
628HWTEST_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 */
656HWTEST_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 */
691HWTEST_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 */
738HWTEST_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