1 /*
2 * Copyright (c) 2021-2023 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 <surface_buffer_impl.h>
19 #include <buffer_utils.h>
20 #include <metadata_helper.h>
21 #include "v1_1/buffer_handle_meta_key_type.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS::Rosen {
27 class SurfaceBufferImplTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31
32 static inline BufferRequestConfig requestConfig = {
33 .width = 0x100,
34 .height = 0x100,
35 .strideAlignment = 0x8,
36 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
37 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
38 .timeout = 0,
39 .colorGamut = GraphicColorGamut::GRAPHIC_COLOR_GAMUT_DCI_P3,
40 };
41 static inline sptr<SurfaceBuffer> buffer = nullptr;
42 static inline int32_t val32 = 0;
43 static inline int64_t val64 = 0;
44 };
45
SetUpTestCase()46 void SurfaceBufferImplTest::SetUpTestCase()
47 {
48 buffer = nullptr;
49 val32 = 0;
50 val64 = 0;
51 }
52
TearDownTestCase()53 void SurfaceBufferImplTest::TearDownTestCase()
54 {
55 buffer = nullptr;
56 }
57
58 /*
59 * Function: GetSeqNum
60 * Type: Function
61 * Rank: Important(2)
62 * EnvConditions: N/A
63 * CaseDescription: 1. new SurfaceBufferImpl and GetSeqNum
64 * 2. new SurfaceBufferImpl again and check GetSeqNum = oldSeq + 1
65 * 3. set and verify the value of parameter isConsumerAttachBufferFlag_ is false
66 * 4. set and verify the value of parameter isConsumerAttachBufferFlag_ is true
67 */
68 HWTEST_F(SurfaceBufferImplTest, NewSeqIncrease001, TestSize.Level0)
69 {
70 buffer = new SurfaceBufferImpl();
71 int oldSeq = buffer->GetSeqNum();
72
73 buffer = new SurfaceBufferImpl();
74 ASSERT_EQ(oldSeq + 1, buffer->GetSeqNum());
75
76 buffer->SetConsumerAttachBufferFlag(false);
77 ASSERT_EQ(buffer->GetConsumerAttachBufferFlag(), false);
78 buffer->SetConsumerAttachBufferFlag(true);
79 ASSERT_EQ(buffer->GetConsumerAttachBufferFlag(), true);
80 }
81
82 /*
83 * Function: GetSeqNum
84 * Type: Function
85 * Rank: Important(2)
86 * EnvConditions: N/A
87 * CaseDescription: 1. new 0xFFFF SurfaceBufferImpl and check SeqNum
88 * 2. new SurfaceBufferImpl again and check GetSeqNum = oldSeq + 1
89 */
90 HWTEST_F(SurfaceBufferImplTest, NewSeqIncrease002, TestSize.Level0)
91 {
92 // the max seqNum low 16 bit is 0xFFFF
93 uint32_t maxSeqNum = 0xFFFF;
94 std::vector<sptr<SurfaceBuffer>> vecBuffer;
95 for (uint32_t i = 0; i <= maxSeqNum; ++i) {
96 sptr<SurfaceBuffer> newBuffer = new SurfaceBufferImpl();
97 vecBuffer.push_back(newBuffer);
98 }
99 sptr<SurfaceBuffer> maxSeqBuffer = new SurfaceBufferImpl(maxSeqNum);
100 ASSERT_EQ(maxSeqNum, maxSeqBuffer->GetSeqNum() & maxSeqNum);
101 sptr<SurfaceBuffer> increbuffer = new SurfaceBufferImpl();
102 int oldSeq = increbuffer->GetSeqNum();
103 increbuffer = new SurfaceBufferImpl();
104 ASSERT_EQ(oldSeq + 1, increbuffer->GetSeqNum());
105 }
106
107 /*
108 * Function: GenerateSequenceNumber
109 * Type: Function
110 * Rank: Important(2)
111 * EnvConditions: N/A
112 * CaseDescription: 1. new SurfaceBufferImpl and GetSeqNum
113 * 2. GenerateSequenceNumber seqNumLow and check retval is oldSeq + 1
114 * 3. GenerateSequenceNumber 0xFFFF and check retval is 0
115 */
116 HWTEST_F(SurfaceBufferImplTest, GenerateSequenceNumber001, TestSize.Level0)
117 {
118 buffer = new SurfaceBufferImpl();
119 uint32_t oldSeq = buffer->GetSeqNum();
120
121 // the max seqNum low 16 bit is 0xFFFF
122 uint32_t maxSeqNum = 0xFFFF;
123 uint32_t seqNumLow = oldSeq & maxSeqNum;
124 ASSERT_EQ((oldSeq + 1) & maxSeqNum, SurfaceBufferImpl::GenerateSequenceNumber(seqNumLow));
125 ASSERT_EQ(0, SurfaceBufferImpl::GenerateSequenceNumber(maxSeqNum));
126 }
127
128 /*
129 * Function: check buffer state
130 * Type: Function
131 * Rank: Important(2)
132 * EnvConditions: N/A
133 * CaseDescription: 1. check buffer state, such as bufferhandle, virAddr, fileDescriptor and size
134 */
135 HWTEST_F(SurfaceBufferImplTest, State001, TestSize.Level0)
136 {
137 ASSERT_EQ(buffer->GetBufferHandle(), nullptr);
138 ASSERT_EQ(buffer->GetVirAddr(), nullptr);
139 ASSERT_EQ(buffer->GetFileDescriptor(), -1);
140 ASSERT_EQ(buffer->GetSize(), 0u);
141 }
142
143 /*
144 * Function: check buffer state
145 * Type: Function
146 * Rank: Important(2)
147 * EnvConditions: N/A
148 * CaseDescription: 1. call GetBufferHandle and Alloc
149 * 2. check buffer state, such as bufferhandle, virAddr and size
150 * 3. call Free
151 * 4. check ret
152 */
153 HWTEST_F(SurfaceBufferImplTest, State002, TestSize.Level0)
154 {
155 ASSERT_EQ(buffer->GetBufferHandle(), nullptr);
156 ASSERT_EQ(buffer->GetPhyAddr(), 0);
157 ASSERT_EQ(buffer->GetStride(), -1);
158 vector<uint32_t> keys;
159 ASSERT_EQ(buffer->ListMetadataKeys(keys), GSERROR_NOT_INIT);
160 ASSERT_EQ(buffer->EraseMetadataKey(1), GSERROR_NOT_INIT);
161 GSError ret = buffer->Alloc(requestConfig);
162 ASSERT_EQ(ret, OHOS::GSERROR_OK);
163
164 ASSERT_NE(buffer->GetBufferHandle(), nullptr);
165 ASSERT_NE(buffer->GetVirAddr(), nullptr);
166 ASSERT_NE(buffer->GetSize(), 0u);
167 ASSERT_EQ(buffer->GetFormat(), GRAPHIC_PIXEL_FMT_RGBA_8888);
168 ASSERT_EQ(buffer->GetUsage(), BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA);
169 ASSERT_EQ(buffer->GetSurfaceBufferColorGamut(), GraphicColorGamut::GRAPHIC_COLOR_GAMUT_DCI_P3);
170
171 buffer->SetBufferHandle(nullptr);
172 }
173
174 /*
175 * Function: parcel
176 * Type: Function
177 * Rank: Important(2)
178 * EnvConditions: N/A
179 * CaseDescription: 1. new SurfaceBufferImpl and Alloc
180 * 2. call Set data interface
181 * 3. call WriteSurfaceBufferImpl and ReadSurfaceBufferImpl
182 * 4. call Get data interface
183 * 5. check ret
184 */
185 HWTEST_F(SurfaceBufferImplTest, Parcel001, TestSize.Level0)
186 {
187 sptr<SurfaceBuffer> sbi = new SurfaceBufferImpl(0);
188 auto sret = sbi->Alloc(requestConfig);
189 ASSERT_EQ(sret, OHOS::GSERROR_OK);
190
191 MessageParcel parcel;
192 WriteSurfaceBufferImpl(parcel, sbi->GetSeqNum(), sbi);
193
194 sptr<SurfaceBuffer> buffer = nullptr;
195 uint32_t seq;
196 ReadSurfaceBufferImpl(parcel, seq, buffer);
197 ASSERT_NE(buffer, nullptr);
198 }
199
200 /*
201 * Function: Create
202 * Type: Function
203 * Rank: Important(2)
204 * EnvConditions: N/A
205 * CaseDescription: 1. Call SurfaceBuffer::Create()
206 * 2. check ret
207 */
208 HWTEST_F(SurfaceBufferImplTest, Create001, TestSize.Level0)
209 {
210 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
211 ASSERT_NE(buffer, nullptr);
212 }
213
214 /*
215 * Function: Alloc
216 * Type: Function
217 * Rank: Important(2)
218 * EnvConditions: N/A
219 * CaseDescription: 1. Call SurfaceBuffer::Alloc()
220 * 2. check ret
221 */
222 HWTEST_F(SurfaceBufferImplTest, Alloc001, TestSize.Level0)
223 {
224 sptr<SurfaceBuffer> buffer = new SurfaceBufferImpl();
225 sptr<SurfaceBuffer> bufferAlloc = new SurfaceBufferImpl();
226 auto sret = bufferAlloc->Alloc(requestConfig, buffer);
227 ASSERT_EQ(sret, OHOS::GSERROR_OK);
228 sptr<SurfaceBuffer> bufferRealloc = new SurfaceBufferImpl();
229 sret = bufferRealloc->Alloc(requestConfig, bufferAlloc);
230 ASSERT_EQ(sret, OHOS::GSERROR_OK);
231 }
232
233 /*
234 * Function: Set/Get/List/Erase Metadata
235 * Type: Function
236 * Rank: Important(2)
237 * EnvConditions: N/A
238 * CaseDescription: 1. new SurfaceBufferImpl and Alloc
239 * 2. call Set Metadata interface
240 * 3. call Get Metadata interface
241 * 4. check ret
242 * 5. call List Metadata keys interface
243 * 6. check ret
244 * 7. call Erase Metadata key interface
245 * 8. call List Metadata keys interface again
246 * 9. check ret
247 */
248 HWTEST_F(SurfaceBufferImplTest, Metadata001, TestSize.Level0)
249 {
250 using namespace HDI::Display::Graphic::Common::V1_0;
251
252 sptr<SurfaceBuffer> sbi = new SurfaceBufferImpl(0);
253 auto sret = sbi->Alloc(requestConfig);
254 ASSERT_EQ(sret, OHOS::GSERROR_OK);
255
256 uint32_t metadataKey = 2;
257
258 uint32_t setMetadata = 4260097;
259 std::vector<uint8_t> setData;
260 ASSERT_EQ(MetadataHelper::ConvertMetadataToVec(setMetadata, setData), OHOS::GSERROR_OK);
261 ASSERT_EQ(sbi->SetMetadata(0, setData), GSERROR_INVALID_ARGUMENTS);
262 ASSERT_EQ(sbi->SetMetadata(HDI::Display::Graphic::Common::V1_1::ATTRKEY_END, setData), GSERROR_INVALID_ARGUMENTS);
263 sret = sbi->SetMetadata(metadataKey, setData);
264 ASSERT_TRUE(sret == OHOS::GSERROR_OK || sret == GSERROR_HDI_ERROR);
265
266 std::vector<uint8_t> getData;
267 ASSERT_EQ(sbi->GetMetadata(0, getData), GSERROR_INVALID_ARGUMENTS);
268 ASSERT_EQ(sbi->GetMetadata(HDI::Display::Graphic::Common::V1_1::ATTRKEY_END, getData), GSERROR_INVALID_ARGUMENTS);
269 sret = sbi->GetMetadata(metadataKey, getData);
270 ASSERT_TRUE(sret == OHOS::GSERROR_OK || sret == GSERROR_HDI_ERROR);
271
272 if (sret == OHOS::GSERROR_OK) {
273 uint32_t getMetadata;
274 ASSERT_EQ(MetadataHelper::ConvertVecToMetadata(getData, getMetadata), OHOS::GSERROR_OK);
275 ASSERT_EQ(setMetadata, getMetadata);
276 }
277
278 std::vector<uint32_t> keys;
279
280 sret = sbi->ListMetadataKeys(keys);
281 ASSERT_TRUE(sret == OHOS::GSERROR_OK || sret == GSERROR_HDI_ERROR);
282 if (sret == OHOS::GSERROR_OK) {
283 ASSERT_EQ(sret, OHOS::GSERROR_OK);
284 ASSERT_EQ(keys.size(), 1);
285 ASSERT_EQ(keys[0], metadataKey);
286 }
287
288 ASSERT_EQ(sbi->EraseMetadataKey(0), GSERROR_INVALID_ARGUMENTS);
289 ASSERT_EQ(sbi->EraseMetadataKey(HDI::Display::Graphic::Common::V1_1::ATTRKEY_END), GSERROR_INVALID_ARGUMENTS);
290 sret = sbi->EraseMetadataKey(metadataKey);
291 ASSERT_TRUE(sret == OHOS::GSERROR_OK || sret == GSERROR_HDI_ERROR);
292
293 sret = sbi->ListMetadataKeys(keys);
294 ASSERT_TRUE(sret == OHOS::GSERROR_OK || sret == GSERROR_HDI_ERROR);
295 if (sret == OHOS::GSERROR_OK) {
296 ASSERT_EQ(keys.size(), 0);
297 }
298 }
299
300 /*
301 * Function: SetMetadata
302 * Type: Function
303 * Rank: Important(2)
304 * EnvConditions: N/A
305 * CaseDescription: 1. new SurfaceBufferImpl and Alloc
306 * 2. call Set Metadata interface with disbale cache
307 3. check ret and metaDataCache_ should be empty
308 */
309 HWTEST_F(SurfaceBufferImplTest, Metadata002, TestSize.Level0)
310 {
311 using namespace HDI::Display::Graphic::Common::V1_0;
312
313 sptr<SurfaceBufferImpl> sbi = new SurfaceBufferImpl(0);
314 auto sret = sbi->Alloc(requestConfig);
315 ASSERT_EQ(sret, OHOS::GSERROR_OK);
316
317 uint32_t metadataKey = 2;
318
319 uint32_t setMetadata = 4260097;
320 std::vector<uint8_t> setData;
321 ASSERT_EQ(MetadataHelper::ConvertMetadataToVec(setMetadata, setData), OHOS::GSERROR_OK);
322 ASSERT_EQ(sbi->SetMetadata(0, setData, false), GSERROR_INVALID_ARGUMENTS);
323 ASSERT_EQ(sbi->SetMetadata(HDI::Display::Graphic::Common::V1_1::ATTRKEY_END, setData, false),
324 GSERROR_INVALID_ARGUMENTS);
325 sret = sbi->SetMetadata(metadataKey, setData, false);
326 ASSERT_TRUE(sret == OHOS::GSERROR_OK || sret == GSERROR_HDI_ERROR);
327 if (sret == OHOS::GSERROR_OK) {
328 ASSERT_TRUE(sbi->metaDataCache_.empty());
329 }
330 }
331
332 /*
333 * Function: SetMetadata
334 * Type: Function
335 * Rank: Important(2)
336 * EnvConditions: N/A
337 * CaseDescription: 1. new SurfaceBufferImpl and Alloc
338 * 2. call Set Metadata interface with enable cache
339 3. check ret and metaDataCache_ size be 1
340 */
341 HWTEST_F(SurfaceBufferImplTest, Metadata003, TestSize.Level0)
342 {
343 using namespace HDI::Display::Graphic::Common::V1_0;
344
345 sptr<SurfaceBufferImpl> sbi = new SurfaceBufferImpl(0);
346 auto sret = sbi->Alloc(requestConfig);
347 ASSERT_EQ(sret, OHOS::GSERROR_OK);
348
349 uint32_t metadataKey = 2;
350
351 uint32_t setMetadata = 4260097;
352 std::vector<uint8_t> setData;
353 ASSERT_EQ(MetadataHelper::ConvertMetadataToVec(setMetadata, setData), OHOS::GSERROR_OK);
354 ASSERT_EQ(sbi->SetMetadata(0, setData, true), GSERROR_INVALID_ARGUMENTS);
355 ASSERT_EQ(sbi->SetMetadata(HDI::Display::Graphic::Common::V1_1::ATTRKEY_END, setData, true),
356 GSERROR_INVALID_ARGUMENTS);
357 sret = sbi->SetMetadata(metadataKey, setData, true);
358 ASSERT_TRUE(sret == OHOS::GSERROR_OK || sret == GSERROR_HDI_ERROR);
359 if (sret == OHOS::GSERROR_OK) {
360 ASSERT_TRUE(sbi->metaDataCache_.size() == 1);
361 }
362 }
363
364
365 /*
366 * Function: BufferRequestConfig
367 * Type: Function
368 * Rank: Important(2)
369 * EnvConditions: N/A
370 * CaseDescription: 1. new SurfaceBufferImpl
371 * 2. call SetBufferRequestConfig interface using requestConfig and check ret
372 * 3. call GetBufferRequestConfig interface using requestConfig and check ret
373 * 4. call WriteBufferRequestConfig interface and check ret
374 * 5. call ReadBufferRequestConfig interface and check ret
375 */
376 HWTEST_F(SurfaceBufferImplTest, BufferRequestConfig001, TestSize.Level0)
377 {
378 buffer = new SurfaceBufferImpl();
379 MessageParcel parcel;
380 buffer->SetBufferRequestConfig(requestConfig);
381 ASSERT_EQ(buffer->GetBufferRequestConfig(), requestConfig);
382 ASSERT_EQ(buffer->WriteBufferRequestConfig(parcel), GSERROR_OK);
383 ASSERT_EQ(buffer->ReadBufferRequestConfig(parcel), GSERROR_OK);
384 }
385
386 /*
387 * Function: SetSurfaceBufferScalingMode&GetSurfaceBufferScalingMode
388 * Type: Function
389 * Rank: Important(2)
390 * EnvConditions: N/A
391 * CaseDescription: 1. new SurfaceBufferImpl
392 * 2. call GetSurfaceBufferScalingMode and check default is SCALING_MODE_SCALE_TO_WINDOW
393 * 3. call SetSurfaceBufferScalingMode and GetSurfaceBufferScalingMode and check ret
394 * 4. repeatly call SetSurfaceBufferScalingMode and GetSurfaceBufferScalingMode and check ret
395 */
396 HWTEST_F(SurfaceBufferImplTest, SurfaceBufferScalingMode001, TestSize.Level0)
397 {
398 buffer = new SurfaceBufferImpl();
399 ASSERT_EQ(buffer->GetSurfaceBufferScalingMode(), ScalingMode::SCALING_MODE_SCALE_TO_WINDOW);
400 buffer->SetSurfaceBufferScalingMode(ScalingMode::SCALING_MODE_SCALE_CROP);
401 ASSERT_EQ(buffer->GetSurfaceBufferScalingMode(), ScalingMode::SCALING_MODE_SCALE_CROP);
402 buffer->SetSurfaceBufferScalingMode(ScalingMode::SCALING_MODE_NO_SCALE_CROP);
403 ASSERT_EQ(buffer->GetSurfaceBufferScalingMode(), ScalingMode::SCALING_MODE_NO_SCALE_CROP);
404 }
405
406 /*
407 * Function: SetBufferDeleteFromCacheFlag&GetBufferDeleteFromCacheFlag
408 * Type: Function
409 * Rank: Important(2)
410 * EnvConditions: N/A
411 * CaseDescription: 1. new SurfaceBufferImpl
412 * 2. call GetBufferDeleteFromCacheFlag and check default is false
413 * 3. call SetBufferDeleteFromCacheFlag and GetBufferDeleteFromCacheFlag and check ret
414 * 4. repeatly call SetBufferDeleteFromCacheFlag and GetBufferDeleteFromCacheFlag and check ret
415 */
416 HWTEST_F(SurfaceBufferImplTest, BufferDeleteFromCacheFlag001, TestSize.Level0)
417 {
418 buffer = new SurfaceBufferImpl();
419 ASSERT_EQ(buffer->GetBufferDeleteFromCacheFlag(), false);
420 buffer->SetBufferDeleteFromCacheFlag(true);
421 ASSERT_EQ(buffer->GetBufferDeleteFromCacheFlag(), true);
422 buffer->SetBufferDeleteFromCacheFlag(false);
423 ASSERT_EQ(buffer->GetBufferDeleteFromCacheFlag(), false);
424 }
425
426 /*
427 * Function: TryReclaim
428 * Type: Function
429 * Rank: Important(2)
430 * EnvConditions: N/A
431 * CaseDescription: 1. new SurfaceBufferImpl
432 * 2. call TryReclaim and check ret
433 * 3. call IsReclaimed and check ret
434 */
435 HWTEST_F(SurfaceBufferImplTest, TryReclaim001, TestSize.Level0)
436 {
437 buffer = new SurfaceBufferImpl();
438 ASSERT_EQ(buffer->TryReclaim(), GSERROR_INVALID_ARGUMENTS);
439 ASSERT_EQ(buffer->IsReclaimed(), false);
440 }
441
442 /*
443 * Function: TryReclaim
444 * Type: Function
445 * Rank: Important(2)
446 * EnvConditions: N/A
447 * CaseDescription: 1. new SurfaceBufferImpl
448 * 2. call SetBufferHandle and check buffer handle
449 * 3. set fd of handle to -1
450 * 4. call TryReclaim and check ret
451 * 5. set fd of handle to 123
452 * 6. call TryReclaim and check ret
453 */
454 HWTEST_F(SurfaceBufferImplTest, TryReclaim002, TestSize.Level0)
455 {
456 buffer = new SurfaceBufferImpl();
457 ASSERT_EQ(buffer->GetBufferHandle(), nullptr);
458 BufferHandle *handle = new BufferHandle();
459 buffer->SetBufferHandle(handle);
460 ASSERT_NE(buffer->GetBufferHandle(), nullptr);
461 handle->fd = -1;
462 ASSERT_EQ(buffer->TryReclaim(), GSERROR_INVALID_ARGUMENTS);
463 handle->fd = 123;
464 GSError ret = buffer->TryReclaim();
465 if (buffer->IsReclaimed()) {
466 printf("come into branch: isReclaimed = true\n");
467 ASSERT_EQ(ret, GSERROR_OK);
468 } else {
469 printf("come into branch: isReclaimed = false\n");
470 ASSERT_EQ(ret, GSERROR_API_FAILED);
471 }
472 }
473
474 /*
475 * Function: TryReclaim
476 * Type: Function
477 * Rank: Important(2)
478 * EnvConditions: N/A
479 * CaseDescription: 1. new SurfaceBufferImpl
480 * 2. call SetBufferHandle and check buffer handle
481 * 3. set fd of handle to 123
482 * 4. call TryReclaim and check ret
483 * 5. call TryReclaim again and check ret
484 */
485 HWTEST_F(SurfaceBufferImplTest, TryReclaim003, TestSize.Level0)
486 {
487 buffer = new SurfaceBufferImpl();
488 ASSERT_EQ(buffer->GetBufferHandle(), nullptr);
489 BufferHandle *handle = new BufferHandle();
490 buffer->SetBufferHandle(handle);
491 ASSERT_NE(buffer->GetBufferHandle(), nullptr);
492 handle->fd = 123;
493 GSError ret = buffer->TryReclaim();
494 if (buffer->IsReclaimed()) {
495 printf("come into branch: isReclaimed = true\n");
496 ASSERT_EQ(ret, GSERROR_OK);
497 } else {
498 printf("come into branch: isReclaimed = false\n");
499 ASSERT_EQ(ret, GSERROR_API_FAILED);
500 }
501 if (buffer->IsReclaimed()) {
502 ret = buffer->TryReclaim();
503 ASSERT_EQ(ret, GSERROR_INVALID_OPERATING);
504 }
505 }
506
507 /*
508 * Function: TryResumeIfNeeded
509 * Type: Function
510 * Rank: Important(2)
511 * EnvConditions: N/A
512 * CaseDescription: 1. new SurfaceBufferImpl
513 * 2. call TryResumeIfNeeded and check ret
514 * 3. call IsReclaimed and check ret
515 */
516 HWTEST_F(SurfaceBufferImplTest, TryResumeIfNeeded001, TestSize.Level0)
517 {
518 buffer = new SurfaceBufferImpl();
519 ASSERT_EQ(buffer->TryResumeIfNeeded(), GSERROR_INVALID_OPERATING);
520 ASSERT_EQ(buffer->IsReclaimed(), false);
521 }
522
523 /*
524 * Function: TryResumeIfNeeded
525 * Type: Function
526 * Rank: Important(2)
527 * EnvConditions: N/A
528 * CaseDescription: 1. new SurfaceBufferImpl
529 * 2. call SetBufferHandle and check buffer handle
530 * 3. set fd of handle to 123
531 * 4. call TryReclaim and check ret
532 * 5. call TryResumeIfNeeded and check ret
533 */
534 HWTEST_F(SurfaceBufferImplTest, TryResumeIfNeeded002, TestSize.Level0)
535 {
536 buffer = new SurfaceBufferImpl();
537 ASSERT_EQ(buffer->GetBufferHandle(), nullptr);
538 BufferHandle *handle = new BufferHandle();
539 buffer->SetBufferHandle(handle);
540 ASSERT_NE(buffer->GetBufferHandle(), nullptr);
541 handle->fd = 123;
542 GSError ret = buffer->TryReclaim();
543 if (buffer->IsReclaimed()) {
544 printf("come into branch: isReclaimed = true\n");
545 ASSERT_EQ(ret, GSERROR_OK);
546 ASSERT_EQ(buffer->TryResumeIfNeeded(), GSERROR_OK);
547 ASSERT_EQ(buffer->IsReclaimed(), false);
548 } else {
549 printf("come into branch: isReclaimed = false\n");
550 ASSERT_EQ(ret, GSERROR_API_FAILED);
551 }
552 }
553
554 /*
555 * Function: IsReclaimed
556 * Type: Function
557 * Rank: Important(2)
558 * EnvConditions: N/A
559 * CaseDescription: 1. new SurfaceBufferImpl
560 * 2. call IsReclaimed and check ret
561 */
562 HWTEST_F(SurfaceBufferImplTest, IsReclaimed001, TestSize.Level0)
563 {
564 buffer = new SurfaceBufferImpl();
565 ASSERT_EQ(buffer->IsReclaimed(), false);
566 }
567
568 /*
569 * Function: InitMemMgrMembers
570 * Type: Function
571 * Rank: Important(2)
572 * EnvConditions: N/A
573 * CaseDescription: 1. define a SurfaceBufferImpl object
574 * 2. call InitMemMgrMembers and check value
575 * 3. call InitMemMgrMembers again and check value
576 */
577 HWTEST_F(SurfaceBufferImplTest, InitMemMgrMembers001, TestSize.Level0)
578 {
579 SurfaceBufferImpl impl;
580 impl.InitMemMgrMembers();
581 ASSERT_EQ(impl.initMemMgrSucceed_, true);
582 impl.InitMemMgrMembers();
583 ASSERT_EQ(impl.initMemMgrSucceed_, true);
584 }
585
586 /*
587 * Function: ReadFromBufferInfo
588 * Type: Function
589 * Rank: Important(2)
590 * EnvConditions: N/A
591 * CaseDescription: 1. define a ReadFromBufferInfo object
592 * 2. call ReadFromBufferInfo and check value
593 * 3. call ReadFromBufferInfo again and check value
594 */
595 HWTEST_F(SurfaceBufferImplTest, ReadFromBufferInfo, TestSize.Level0)
596 {
597 RSBufferInfo bufferInfo;
598 SurfaceBufferImpl impl;
599 GSError ret = impl.ReadFromBufferInfo(bufferInfo);
600 ASSERT_EQ(ret, OHOS::GSERROR_OK);
601 }
602
603 /*
604 * Function: SurfaceBufferSyncFence
605 * Type: Function
606 * Rank: Important(2)
607 * EnvConditions: N/A
608 * CaseDescription: 1. surfacebuffer add sync fence
609 */
610 HWTEST_F(SurfaceBufferImplTest, SurfaceBufferSyncFence001, TestSize.Level0)
611 {
612 SurfaceBufferImpl buffer;
613 buffer.SetAndMergeSyncFence(nullptr);
614 ASSERT_EQ(buffer.GetSyncFence(), nullptr);
615 buffer.SetAndMergeSyncFence(SyncFence::INVALID_FENCE);
616 ASSERT_NE(buffer.GetSyncFence(), nullptr);
617 ASSERT_FALSE(buffer.GetSyncFence()->IsValid());
618 buffer.SetAndMergeSyncFence(new SyncFence(0));
619 ASSERT_NE(buffer.GetSyncFence(), nullptr);
620 ASSERT_EQ(buffer.GetSyncFence()->Get(), 0);
621 }
622 }
623