1 /*
2 * Copyright (c) 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 #include <gtest/gtest.h>
16 #include "iconsumer_surface.h"
17 #include <iservice_registry.h>
18 #include <ctime>
19 #include "native_buffer.h"
20 #include "native_buffer_inner.h"
21 #include "native_window.h"
22 #include "surface_type.h"
23 #include "graphic_common_c.h"
24
25 using namespace std;
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS::Rosen {
30 class BufferConsumerListener : public IBufferConsumerListener {
31 public:
OnBufferAvailable()32 void OnBufferAvailable() override
33 {
34 }
35 };
36
37 class NativeBufferTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41
42 static inline OH_NativeBuffer_Config config = {
43 .width = 0x100,
44 .height = 0x100,
45 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
46 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
47 };
48 static inline OH_NativeBuffer_Config checkConfig = {};
49 static inline OH_NativeBuffer* buffer = nullptr;
50 };
51
SetUpTestCase()52 void NativeBufferTest::SetUpTestCase()
53 {
54 buffer = nullptr;
55 }
56
TearDownTestCase()57 void NativeBufferTest::TearDownTestCase()
58 {
59 buffer = nullptr;
60 }
61
62 /*
63 * Function: OH_NativeBufferFromSurfaceBuffer
64 * Type: Function
65 * Rank: Important(2)
66 * EnvConditions: N/A
67 * CaseDescription: 1. call OH_NativeBufferFromSurfaceBuffer by abnormal input
68 * 2. check ret
69 */
70 HWTEST_F(NativeBufferTest, OH_NativeBufferFromSurfaceBuffer001, Function | MediumTest | Level2)
71 {
72 sptr<OHOS::SurfaceBuffer> surfaceBuffer = OHOS::SurfaceBuffer::Create();
73 NativeWindowBuffer* nativeWindowBuffer = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&surfaceBuffer);
74 ASSERT_NE(nativeWindowBuffer, nullptr);
75 nativeWindowBuffer->sfbuffer = nullptr;
76 OH_NativeBuffer* nativeBuffer = OH_NativeBufferFromNativeWindowBuffer(nativeWindowBuffer);
77 ASSERT_EQ(nativeBuffer, nullptr);
78 }
79
80 /*
81 * Function: OH_NativeBuffer_Alloc
82 * Type: Function
83 * Rank: Important(2)
84 * EnvConditions: N/A
85 * CaseDescription: 1. call OH_NativeBuffer_Alloc by abnormal input
86 * 2. check ret
87 */
88 HWTEST_F(NativeBufferTest, OHNativeBufferAlloc001, Function | MediumTest | Level2)
89 {
90 buffer = OH_NativeBuffer_Alloc(nullptr);
91 ASSERT_EQ(buffer, nullptr);
92 }
93
94 /*
95 * Function: OH_NativeBuffer_Alloc
96 * Type: Function
97 * Rank: Important(2)
98 * EnvConditions: N/A
99 * CaseDescription: 1. call OH_NativeBuffer_Alloc
100 * 2. check ret
101 */
102 HWTEST_F(NativeBufferTest, OHNativeBufferAlloc002, Function | MediumTest | Level2)
103 {
104 buffer = OH_NativeBuffer_Alloc(&config);
105 ASSERT_NE(buffer, nullptr);
106 }
107
108 /*
109 * Function: OH_NativeBuffer_GetSeqNum
110 * Type: Function
111 * Rank: Important(2)
112 * EnvConditions: N/A
113 * CaseDescription: 1. call OH_NativeBuffer_GetSeqNum by abnormal input
114 * 2. check ret
115 */
116 HWTEST_F(NativeBufferTest, OHNativeBufferGetSeqNum001, Function | MediumTest | Level2)
117 {
118 uint32_t id = OH_NativeBuffer_GetSeqNum(nullptr);
119 ASSERT_EQ(id, UINT_MAX);
120 }
121
122 /*
123 * Function: OH_NativeBuffer_GetSeqNum
124 * Type: Function
125 * Rank: Important(2)
126 * EnvConditions: N/A
127 * CaseDescription: 1. call OH_NativeBuffer_GetSeqNum
128 * 2. check ret
129 */
130 HWTEST_F(NativeBufferTest, OHNativeBufferGetSeqNum002, Function | MediumTest | Level2)
131 {
132 uint32_t id = OH_NativeBuffer_GetSeqNum(buffer);
133 ASSERT_NE(id, GSERROR_INVALID_ARGUMENTS);
134 }
135
136 /*
137 * Function: OH_NativeBuffer_GetConfig
138 * Type: Function
139 * Rank: Important(2)
140 * EnvConditions: N/A
141 * CaseDescription: 1. call OH_NativeBuffer_GetConfig
142 * 2. check ret
143 */
144 HWTEST_F(NativeBufferTest, OHNativeBufferGetConfig001, Function | MediumTest | Level2)
145 {
146 OH_NativeBuffer_GetConfig(buffer, &checkConfig);
147 ASSERT_NE(&checkConfig, nullptr);
148 }
149
150 /*
151 * Function: OH_NativeBuffer_GetConfig
152 * Type: Function
153 * Rank: Important(2)
154 * EnvConditions: N/A
155 * CaseDescription: 1. call OH_NativeBuffer_GetConfig by abnormal input
156 * 2. check ret
157 */
158 HWTEST_F(NativeBufferTest, OHNativeBufferGetConfig002, Function | MediumTest | Level2)
159 {
160 checkConfig.width = 0x0;
161 checkConfig.height = 0x0;
162 checkConfig.format = 0x0;
163 checkConfig.usage = 0x0;
164 OH_NativeBuffer_GetConfig(nullptr, &checkConfig);
165 ASSERT_EQ(checkConfig.width, 0x0);
166 ASSERT_EQ(checkConfig.height, 0x0);
167 ASSERT_EQ(checkConfig.format, 0x0);
168 ASSERT_EQ(checkConfig.usage, 0x0);
169 }
170
171 /*
172 * Function: OH_NativeBuffer_Reference
173 * Type: Function
174 * Rank: Important(2)
175 * EnvConditions: N/A
176 * CaseDescription: 1. call OH_NativeBuffer_Reference by abnormal input
177 * 2. check ret
178 */
179 HWTEST_F(NativeBufferTest, OHNativeBufferReference001, Function | MediumTest | Level2)
180 {
181 int32_t ret = OH_NativeBuffer_Reference(nullptr);
182 ASSERT_NE(ret, GSERROR_OK);
183 }
184
185 /*
186 * Function: OH_NativeBuffer_Reference
187 * Type: Function
188 * Rank: Important(2)
189 * EnvConditions: N/A
190 * CaseDescription: 1. call OH_NativeBuffer_Reference
191 * 2. check ret
192 */
193 HWTEST_F(NativeBufferTest, OHNativeBufferReference002, Function | MediumTest | Level2)
194 {
195 int32_t ret = OH_NativeBuffer_Reference(buffer);
196 ASSERT_EQ(ret, GSERROR_OK);
197 }
198
199 /*
200 * Function: OH_NativeBuffer_Unreference
201 * Type: Function
202 * Rank: Important(2)
203 * EnvConditions: N/A
204 * CaseDescription: 1. call OH_NativeBuffer_Unreference by abnormal input
205 * 2. check ret
206 */
207 HWTEST_F(NativeBufferTest, OHNativeBufferUnreference001, Function | MediumTest | Level2)
208 {
209 int32_t ret = OH_NativeBuffer_Unreference(nullptr);
210 ASSERT_NE(ret, GSERROR_OK);
211 }
212
213 /*
214 * Function: OH_NativeBuffer_Unreference
215 * Type: Function
216 * Rank: Important(2)
217 * EnvConditions: N/A
218 * CaseDescription: 1. call OH_NativeBuffer_Unreference
219 * 2. check ret
220 */
221 HWTEST_F(NativeBufferTest, OHNativeBufferUnreference002, Function | MediumTest | Level2)
222 {
223 int32_t ret = OH_NativeBuffer_Unreference(buffer);
224 ASSERT_EQ(ret, GSERROR_OK);
225 }
226
227 /*
228 * Function: OH_NativeBuffer_GetSeqNum and OH_NativeBuffer_Unreference
229 * Type: Function
230 * Rank: Important(2)
231 * EnvConditions: N/A
232 * CaseDescription: 1. call OH_NativeBuffer_GetSeqNum
233 * 2. call OH_NativeBuffer_Unreference
234 * 3. OH_NativeBuffer_Alloc again
235 * 4. check OH_NativeBuffer_GetSeqNum = oldSeq + 1
236 */
237 HWTEST_F(NativeBufferTest, OHNativeBufferGetSeqNum003, Function | MediumTest | Level2)
238 {
239 uint32_t oldSeq = OH_NativeBuffer_GetSeqNum(buffer);
240 int32_t ret = OH_NativeBuffer_Unreference(buffer);
241 ASSERT_EQ(ret, GSERROR_OK);
242 buffer = OH_NativeBuffer_Alloc(&config);
243 ASSERT_EQ(oldSeq + 1, OH_NativeBuffer_GetSeqNum(buffer));
244 }
245
246 /*
247 * Function: OH_NativeBuffer_GetNativeBufferConfig
248 * Type: Function
249 * Rank: Important(2)
250 * EnvConditions: N/A
251 * CaseDescription: 1. call OH_NativeBuffer_GetNativeBufferConfig
252 * 2. check result
253 */
254 HWTEST_F(NativeBufferTest, OHNativeBufferGetNativeBufferConfig001, Function | MediumTest | Level2)
255 {
256 OH_NativeBuffer_Config testConfig = {};
257 OH_NativeBuffer_GetNativeBufferConfig(buffer, &testConfig);
258 ASSERT_EQ(testConfig.width, config.width);
259 ASSERT_EQ(testConfig.height, config.height);
260 ASSERT_EQ(testConfig.format, config.format);
261 ASSERT_EQ(testConfig.usage, config.usage);
262 }
263
264 /*
265 * Function: OH_NativeBuffer_SetColorSpace
266 * Type: Function
267 * Rank: Important(2)
268 * EnvConditions: N/A
269 * CaseDescription: 1. call OH_NativeBuffer_SetColorSpace by abnormal input
270 * 2. check ret
271 */
272 HWTEST_F(NativeBufferTest, OHNativeBufferSetColorSpace001, Function | MediumTest | Level2)
273 {
274 int32_t ret = OH_NativeBuffer_SetColorSpace(nullptr, OH_COLORSPACE_DISPLAY_BT2020_PQ);
275 ASSERT_NE(ret, GSERROR_OK);
276 }
277
278 /*
279 * Function: OH_NativeBuffer_SetColorSpace
280 * Type: Function
281 * Rank: Important(2)
282 * EnvConditions: N/A
283 * CaseDescription: 1. call OH_NativeBuffer_SetColorSpace
284 * 2. check ret
285 */
286 HWTEST_F(NativeBufferTest, OHNativeBufferSetColorSpace002, Function | MediumTest | Level2)
287 {
288 if (buffer == nullptr) {
289 buffer = OH_NativeBuffer_Alloc(&config);
290 ASSERT_NE(buffer, nullptr);
291 }
292
293 int32_t ret = OH_NativeBuffer_SetColorSpace(buffer, OH_COLORSPACE_BT709_LIMIT);
294 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
295 ASSERT_EQ(ret, GSERROR_OK);
296 }
297 }
298
299 /*
300 * Function: OH_NativeBuffer_GetColorSpace
301 * Type: Function
302 * Rank: Important(2)
303 * EnvConditions: N/A
304 * CaseDescription: 1. call OH_NativeBuffer_GetColorSpace by abnormal input
305 * 2. check ret
306 */
307 HWTEST_F(NativeBufferTest, OHNativeBufferGetColorSpace001, Function | MediumTest | Level2)
308 {
309 OH_NativeBuffer_ColorSpace *colorSpace = nullptr;
310 int32_t ret = OH_NativeBuffer_GetColorSpace(nullptr, colorSpace);
311 ASSERT_NE(ret, GSERROR_OK);
312 }
313
314 /*
315 * Function: OH_NativeBuffer_GetColorSpace
316 * Type: Function
317 * Rank: Important(2)
318 * EnvConditions: N/A
319 * CaseDescription: 1. call OH_NativeBuffer_GetColorSpace
320 * 2. check ret
321 */
322 HWTEST_F(NativeBufferTest, OHNativeBufferGetColorSpace002, Function | MediumTest | Level2)
323 {
324 if (buffer == nullptr) {
325 buffer = OH_NativeBuffer_Alloc(&config);
326 ASSERT_NE(buffer, nullptr);
327 }
328 OH_NativeBuffer_ColorSpace colorSpace = OH_COLORSPACE_NONE;
329 int32_t ret = OH_NativeBuffer_SetColorSpace(buffer, OH_COLORSPACE_BT709_LIMIT);
330 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
331 ASSERT_EQ(ret, GSERROR_OK);
332 }
333 ret = OH_NativeBuffer_GetColorSpace(buffer, &colorSpace);
334 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
335 ASSERT_EQ(colorSpace, OH_COLORSPACE_BT709_LIMIT);
336 ASSERT_EQ(ret, GSERROR_OK);
337 }
338 }
339
340 /*
341 * Function: OH_NativeBuffer_GetColorSpace
342 * Type: Function
343 * Rank: Important(2)
344 * EnvConditions: N/A
345 * CaseDescription: 1. call OH_NativeBuffer_GetColorSpace
346 * 2. check ret
347 */
348 HWTEST_F(NativeBufferTest, OHNativeBufferGetColorSpace003, Function | MediumTest | Level2)
349 {
350 if (buffer == nullptr) {
351 buffer = OH_NativeBuffer_Alloc(&config);
352 ASSERT_NE(buffer, nullptr);
353 }
354 OH_NativeBuffer_ColorSpace colorSpace = OH_COLORSPACE_NONE;
355 int32_t ret = OH_NativeBuffer_GetColorSpace(buffer, &colorSpace);
356 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
357 ASSERT_EQ(ret, GSERROR_OK);
358 }
359 ret = OH_NativeBuffer_SetColorSpace(buffer, OH_COLORSPACE_BT709_LIMIT);
360 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
361 ASSERT_EQ(colorSpace, OH_COLORSPACE_BT709_LIMIT);
362 ASSERT_EQ(ret, GSERROR_OK);
363 }
364 }
365
366 /*
367 * Function: OH_NativeBuffer_SetMetadataValue
368 * Type: Function
369 * Rank: Important(2)
370 * EnvConditions: N/A
371 * CaseDescription: 1. call OH_NativeBuffer_SetMetadataValue by abnormal input
372 * 2. check ret
373 */
374 HWTEST_F(NativeBufferTest, OH_NativeBuffer_SetMetadataValue001, Function | MediumTest | Level2)
375 {
376 int32_t size = 1024;
377 uint8_t buff[size];
378 int32_t ret = OH_NativeBuffer_SetMetadataValue(nullptr, OH_HDR_STATIC_METADATA, size, buff);
379 ASSERT_NE(ret, GSERROR_OK);
380 }
381
382 /*
383 * Function: OH_NativeBuffer_SetMetadataValue
384 * Type: Function
385 * Rank: Important(2)
386 * EnvConditions: N/A
387 * CaseDescription: 1. call OH_NativeBuffer_SetMetadataValue
388 * 2. check ret
389 */
390 HWTEST_F(NativeBufferTest, OH_NativeBuffer_SetMetadataValue002, Function | MediumTest | Level2)
391 {
392 if (buffer == nullptr) {
393 buffer = OH_NativeBuffer_Alloc(&config);
394 ASSERT_NE(buffer, nullptr);
395 }
396 int32_t len = 60;
397 uint8_t outbuff[len];
398 for (int i = 0; i < 60; ++i) {
399 outbuff[i] = static_cast<uint8_t>(i);
400 }
401 int32_t ret = OH_NativeBuffer_SetMetadataValue(buffer, OH_HDR_STATIC_METADATA, len, outbuff);
402 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
403 ASSERT_EQ(ret, GSERROR_OK);
404 }
405 ret = OH_NativeBuffer_SetMetadataValue(buffer, OH_HDR_DYNAMIC_METADATA, len, outbuff);
406 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
407 ASSERT_EQ(ret, GSERROR_OK);
408 }
409 uint8_t type = OH_NativeBuffer_MetadataType::OH_VIDEO_HDR_HLG;
410 ret = OH_NativeBuffer_SetMetadataValue(buffer, OH_HDR_METADATA_TYPE, sizeof(OH_NativeBuffer_MetadataType), &type);
411 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
412 ASSERT_EQ(ret, GSERROR_OK);
413 }
414 type = OH_NativeBuffer_MetadataType::OH_VIDEO_NONE;
415 ret = OH_NativeBuffer_SetMetadataValue(buffer, OH_HDR_METADATA_TYPE, sizeof(OH_NativeBuffer_MetadataType), &type);
416 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
417 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
418 }
419 ret = OH_NativeBuffer_SetMetadataValue(buffer, static_cast<OH_NativeBuffer_MetadataKey>(-1), len, outbuff);
420 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
421 ASSERT_EQ(ret, GSERROR_INTERNAL);
422 }
423 }
424
425 /*
426 * Function: OH_NativeBuffer_SetMetadataValue
427 * Type: Function
428 * Rank: Important(2)
429 * EnvConditions: N/A
430 * CaseDescription: 1. call OH_NativeBuffer_SetMetadataValue by abnormal input
431 * 2. check ret
432 */
433 HWTEST_F(NativeBufferTest, OH_NativeBuffer_SetMetadataValue003, Function | MediumTest | Level2)
434 {
435 int32_t max_size = -1;
436 int32_t size = 60;
437 uint8_t buff[size];
438 int32_t ret = OH_NativeBuffer_SetMetadataValue(nullptr, OH_HDR_STATIC_METADATA, max_size, buff);
439 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
440 ASSERT_NE(ret, GSERROR_OK);
441 }
442 }
443
444 /*
445 * Function: OH_NativeBuffer_GetMetadataValue
446 * Type: Function
447 * Rank: Important(2)
448 * EnvConditions: N/A
449 * CaseDescription: 1. call OH_NativeBuffer_GetMetadataValue by abnormal input
450 * 2. check ret
451 */
452 HWTEST_F(NativeBufferTest, OH_NativeBuffer_GetMetadataValue001, Function | MediumTest | Level2)
453 {
454 int32_t size = 1024;
455 uint8_t *buff;
456 int32_t ret = OH_NativeBuffer_GetMetadataValue(nullptr, OH_HDR_STATIC_METADATA, &size, &buff);
457 if (buff != nullptr) {
458 delete[] buff;
459 buff = nullptr;
460 }
461 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
462 ASSERT_NE(ret, GSERROR_OK);
463 }
464 }
465
466 /*
467 * Function: OH_NativeBuffer_GetMetadataValue
468 * Type: Function
469 * Rank: Important(2)
470 * EnvConditions: N/A
471 * CaseDescription: 1. call OH_NativeBuffer_GetMetadataValue
472 * 2. check ret
473 */
474 HWTEST_F(NativeBufferTest, OH_NativeBuffer_GetMetadataValue002, Function | MediumTest | Level2)
475 {
476 if (buffer == nullptr) {
477 buffer = OH_NativeBuffer_Alloc(&config);
478 ASSERT_NE(buffer, nullptr);
479 }
480 int32_t len = 60;
481 uint8_t outbuff[len];
482 for (int i = 0; i < 60; ++i) {
483 outbuff[i] = static_cast<uint8_t>(i);
484 }
485 int32_t ret = OH_NativeBuffer_SetMetadataValue(buffer, OH_HDR_STATIC_METADATA, len, outbuff);
486 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
487 ASSERT_EQ(ret, GSERROR_OK);
488 }
489 int32_t buffSize = 0;
490 uint8_t *buff;
491 ret = OH_NativeBuffer_GetMetadataValue(buffer, OH_HDR_STATIC_METADATA, &buffSize, &buff);
492 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
493 if (buff != nullptr) {
494 ASSERT_EQ(memcmp(outbuff, buff, 60), 0);
495 delete[] buff;
496 buff = nullptr;
497 }
498 ASSERT_EQ(ret, GSERROR_OK);
499 }
500 ret = OH_NativeBuffer_SetMetadataValue(buffer, OH_HDR_DYNAMIC_METADATA, len, outbuff);
501 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
502 ASSERT_EQ(ret, GSERROR_OK);
503 }
504 ret = OH_NativeBuffer_GetMetadataValue(buffer, OH_HDR_DYNAMIC_METADATA, &buffSize, &buff);
505 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
506 if (buff != nullptr) {
507 ASSERT_EQ(memcmp(outbuff, buff, 60), 0);
508 delete[] buff;
509 buff = nullptr;
510 }
511 ASSERT_EQ(ret, GSERROR_OK);
512 }
513 ret = OH_NativeBuffer_GetMetadataValue(buffer, static_cast<OH_NativeBuffer_MetadataKey>(-1), &buffSize, &buff);
514 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
515 ASSERT_EQ(ret, GSERROR_INTERNAL);
516 }
517 }
518
519 /*
520 * Function: OH_NativeBuffer_GetMetadataValue
521 * Type: Function
522 * Rank: Important(2)
523 * EnvConditions: N/A
524 * CaseDescription: 1. call OH_NativeBuffer_GetMetadataValue
525 * 2. check ret
526 */
527 HWTEST_F(NativeBufferTest, OH_NativeBuffer_GetMetadataValue003, Function | MediumTest | Level2)
528 {
529 if (buffer == nullptr) {
530 buffer = OH_NativeBuffer_Alloc(&config);
531 ASSERT_NE(buffer, nullptr);
532 }
533 uint8_t *buff;
534 int32_t ret = OH_NativeBuffer_GetMetadataValue(buffer, OH_HDR_STATIC_METADATA, nullptr, &buff);
535 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
536 ASSERT_NE(ret, GSERROR_OK);
537 }
538 uint8_t type = OH_NativeBuffer_MetadataType::OH_VIDEO_HDR_HLG;
539 uint8_t *resType = new uint8_t;
540 int32_t typeSize = sizeof(OH_NativeBuffer_MetadataType);
541 ret = OH_NativeBuffer_SetMetadataValue(buffer, OH_HDR_METADATA_TYPE, typeSize, &type);
542 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
543 ASSERT_EQ(ret, GSERROR_OK);
544 }
545 ret = OH_NativeBuffer_GetMetadataValue(buffer, OH_HDR_METADATA_TYPE, &typeSize, &resType);
546 if (ret != GSERROR_NOT_SUPPORT) { // some device not support set colorspace
547 ASSERT_EQ(type, *resType);
548 ASSERT_EQ(ret, GSERROR_OK);
549 }
550 delete resType;
551 resType = nullptr;
552 }
553
554 /*
555 * Function: OH_NativeBuffer_Map
556 * Type: Function
557 * Rank: Important(2)
558 * EnvConditions: N/A
559 * CaseDescription: 1. call OH_NativeBuffer_Map by abnormal input
560 * 2. check ret
561 */
562 HWTEST_F(NativeBufferTest, OHNativeBufferMap001, Function | MediumTest | Level2)
563 {
564 void *virAddr = nullptr;
565 int32_t ret = OH_NativeBuffer_Map(nullptr, &virAddr);
566 ASSERT_NE(ret, GSERROR_OK);
567 }
568
569 /*
570 * Function: OH_NativeBuffer_Map
571 * Type: Function
572 * Rank: Important(2)
573 * EnvConditions: N/A
574 * CaseDescription: 1. call OH_NativeBuffer_Map
575 * 2. check ret
576 */
577 HWTEST_F(NativeBufferTest, OHNativeBufferMap002, Function | MediumTest | Level2)
578 {
579 void *virAddr = nullptr;
580 int32_t ret = OH_NativeBuffer_Map(buffer, &virAddr);
581 ASSERT_EQ(ret, GSERROR_OK);
582 ASSERT_NE(virAddr, nullptr);
583 }
584
585 /*
586 * Function: OH_NativeBuffer_Unmap
587 * Type: Function
588 * Rank: Important(2)
589 * EnvConditions: N/A
590 * CaseDescription: 1. call OH_NativeBuffer_Unmap by abnormal input
591 * 2. check ret
592 */
593 HWTEST_F(NativeBufferTest, OHNativeBufferUnmap001, Function | MediumTest | Level2)
594 {
595 int32_t ret = OH_NativeBuffer_Unmap(nullptr);
596 ASSERT_NE(ret, GSERROR_OK);
597 }
598
599 /*
600 * Function: OH_NativeBuffer_Unmap and OH_NativeBuffer_Unreference
601 * Type: Function
602 * Rank: Important(2)
603 * EnvConditions: N/A
604 * CaseDescription: 1. call OH_NativeBuffer_Unmap
605 * 2. check ret
606 * 3. call OH_NativeBuffer_Unreference
607 */
608 HWTEST_F(NativeBufferTest, OHNativeBufferUnmap002, Function | MediumTest | Level2)
609 {
610 int32_t ret = OH_NativeBuffer_Unmap(buffer);
611 ASSERT_EQ(ret, GSERROR_OK);
612 ret = OH_NativeBuffer_Unreference(buffer);
613 ASSERT_EQ(ret, GSERROR_OK);
614 }
615
616 /*
617 * Function: OH_NativeBufferFromNativeWindowBuffer
618 * Type: Function
619 * Rank: Important(2)
620 * EnvConditions: N/A
621 * CaseDescription: 1. call OH_NativeBufferFromNativeWindowBuffer by abnormal input
622 * 2. check ret
623 */
624 HWTEST_F(NativeBufferTest, NativeBufferFromNativeWindowBuffer001, Function | MediumTest | Level2)
625 {
626 OH_NativeBuffer* nativeBuffer = OH_NativeBufferFromNativeWindowBuffer(nullptr);
627 ASSERT_EQ(nativeBuffer, nullptr);
628 }
629
630 /*
631 * Function: OH_NativeBufferFromNativeWindowBuffer
632 * Type: Function
633 * Rank: Important(2)
634 * EnvConditions: N/A
635 * CaseDescription: 1. call OH_NativeBufferFromNativeWindowBuffer
636 * 2. check ret
637 */
638 HWTEST_F(NativeBufferTest, NativeBufferFromNativeWindowBuffer002, Function | MediumTest | Level2)
639 {
640 sptr<OHOS::IConsumerSurface> cSurface = IConsumerSurface::Create();
641 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
642 cSurface->RegisterConsumerListener(listener);
643 sptr<OHOS::IBufferProducer> producer = cSurface->GetProducer();
644 sptr<OHOS::Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
645 int32_t fence;
646 sptr<OHOS::SurfaceBuffer> sBuffer = nullptr;
647 BufferRequestConfig requestConfig = {
648 .width = 0x100, // small
649 .height = 0x100, // small
650 .strideAlignment = 0x8,
651 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
652 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
653 .timeout = 0,
654 };
655 pSurface->RequestBuffer(sBuffer, fence, requestConfig);
656 NativeWindow* nativeWindow = OH_NativeWindow_CreateNativeWindow(&pSurface);
657 ASSERT_NE(nativeWindow, nullptr);
658 NativeWindowBuffer* nativeWindowBuffer = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&sBuffer);
659 ASSERT_NE(nativeWindowBuffer, nullptr);
660 OH_NativeBuffer* nativeBuffer = OH_NativeBufferFromNativeWindowBuffer(nativeWindowBuffer);
661 ASSERT_NE(nativeBuffer, nullptr);
662
663 int32_t ret = OH_NativeBuffer_FromNativeWindowBuffer(nativeWindowBuffer, nullptr);
664 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
665 OH_NativeBuffer* nativeBufferTmp = nullptr;
666 ret = OH_NativeBuffer_FromNativeWindowBuffer(nativeWindowBuffer, &nativeBufferTmp);
667 ASSERT_EQ(ret, OHOS::GSERROR_OK);
668 ASSERT_EQ(nativeBuffer, nativeBufferTmp);
669
670 void *virAddr = nullptr;
671 OH_NativeBuffer_Planes outPlanes;
672 ret = OH_NativeBuffer_MapPlanes(nativeBuffer, &virAddr, &outPlanes);
673 if (ret != GSERROR_HDI_ERROR) {
674 ASSERT_EQ(ret, OHOS::GSERROR_OK);
675 }
676
677 sBuffer = nullptr;
678 cSurface = nullptr;
679 producer = nullptr;
680 pSurface = nullptr;
681 nativeWindow = nullptr;
682 nativeWindowBuffer = nullptr;
683 }
684
685 /*
686 * Function: OH_NativeBuffer_FromNativeWindowBuffer
687 * Type: Function
688 * Rank: Important(2)
689 * EnvConditions: N/A
690 * CaseDescription: 1. call OH_NativeBuffer_FromNativeWindowBuffer by abnormal input
691 * 2. check ret
692 */
693 HWTEST_F(NativeBufferTest, NativeBufferFromNativeWindowBuffer003, Function | MediumTest | Level2)
694 {
695 int32_t ret = OH_NativeBuffer_FromNativeWindowBuffer(nullptr, nullptr);
696 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
697
698 NativeWindowBuffer nativeWindowBuffer;
699 ret = OH_NativeBuffer_FromNativeWindowBuffer(&nativeWindowBuffer, nullptr);
700 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
701
702 OH_NativeBuffer_GetNativeBufferConfig(nullptr, nullptr);
703 OH_NativeBuffer_GetNativeBufferConfig(buffer, nullptr);
704 ASSERT_EQ(OH_NativeBuffer_GetBufferHandle(nullptr), nullptr);
705 }
706
707 /*
708 * Function: OH_NativeBuffer_MapPlanes
709 * Type: Function
710 * Rank: Important(2)
711 * EnvConditions: N/A
712 * CaseDescription: 1. call OH_NativeBuffer_MapPlanes by abnormal input
713 * 2. check ret
714 */
715 HWTEST_F(NativeBufferTest, OHNativeBufferMapPlanes001, Function | MediumTest | Level2)
716 {
717 int32_t ret = OH_NativeBuffer_MapPlanes(nullptr, nullptr, nullptr);
718 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
719
720 OH_NativeBuffer *buffer = (OH_NativeBuffer *)0xFFFFFFFF;
721 ret = OH_NativeBuffer_MapPlanes(buffer, nullptr, nullptr);
722 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
723
724 void *virAddr = nullptr;
725 ret = OH_NativeBuffer_MapPlanes(buffer, &virAddr, nullptr);
726 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
727 }
728
729 /*
730 * Function: OH_NativeBuffer_MapPlanes
731 * Type: Function
732 * Rank: Important(2)
733 * EnvConditions: N/A
734 * CaseDescription: 1. call OH_NativeBuffer_MapPlanes
735 * 2. check ret
736 */
737 HWTEST_F(NativeBufferTest, OHNativeBufferMapPlanes002, Function | MediumTest | Level2)
738 {
739 sptr<OHOS::IConsumerSurface> cSurface = IConsumerSurface::Create();
740 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
741 cSurface->RegisterConsumerListener(listener);
742 sptr<OHOS::IBufferProducer> producer = cSurface->GetProducer();
743 sptr<OHOS::Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
744 int32_t fence;
745 sptr<OHOS::SurfaceBuffer> sBuffer = nullptr;
746 BufferRequestConfig requestConfig = {.width = 0x100, .height = 0x100, .strideAlignment = 0x8,
747 .format = GRAPHIC_PIXEL_FMT_YCBCR_420_SP,
748 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA, .timeout = 0};
749 pSurface->SetQueueSize(4);
750 int32_t formatType[] = {GRAPHIC_PIXEL_FMT_YCBCR_420_SP, GRAPHIC_PIXEL_FMT_YCRCB_420_SP,
751 GRAPHIC_PIXEL_FMT_YCBCR_420_P, GRAPHIC_PIXEL_FMT_YCRCB_420_P};
752 NativeWindow* nativeWindow;
753 NativeWindowBuffer* nativeWindowBuffer;
754 for (int32_t i = 0; i < sizeof(formatType) / sizeof(int32_t); i++) {
755 requestConfig.format = formatType[i];
756 pSurface->RequestBuffer(sBuffer, fence, requestConfig);
757 nativeWindow = OH_NativeWindow_CreateNativeWindow(&pSurface);
758 ASSERT_NE(nativeWindow, nullptr);
759 nativeWindowBuffer = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&sBuffer);
760 ASSERT_NE(nativeWindowBuffer, nullptr);
761 OH_NativeBuffer* nativeBuffer = OH_NativeBufferFromNativeWindowBuffer(nativeWindowBuffer);
762 ASSERT_NE(nativeBuffer, nullptr);
763
764 void *virAddr = nullptr;
765 OH_NativeBuffer_Planes outPlanes;
766 int32_t ret = OH_NativeBuffer_MapPlanes(nativeBuffer, &virAddr, &outPlanes);
767 if (ret != GSERROR_HDI_ERROR) {
768 ASSERT_EQ(ret, OHOS::GSERROR_OK);
769 ASSERT_NE(virAddr, nullptr);
770 }
771 }
772
773 sBuffer = nullptr;
774 cSurface = nullptr;
775 producer = nullptr;
776 pSurface = nullptr;
777 nativeWindow = nullptr;
778 nativeWindowBuffer = nullptr;
779 }
780
781 /*
782 * Function: OH_NativeBuffer_MapPlanes
783 * Type: Function
784 * Rank: Important(2)
785 * EnvConditions: N/A
786 * CaseDescription: 1. call OH_NativeBuffer_MapPlanes
787 * 2. check ret
788 */
789 HWTEST_F(NativeBufferTest, OHNativeBufferMapPlanes003, Function | MediumTest | Level2)
790 {
791 sptr<OHOS::IConsumerSurface> cSurface = IConsumerSurface::Create();
792 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
793 cSurface->RegisterConsumerListener(listener);
794 sptr<OHOS::IBufferProducer> producer = cSurface->GetProducer();
795 sptr<OHOS::Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
796 int32_t fence;
797 sptr<OHOS::SurfaceBuffer> sBuffer = nullptr;
798 BufferRequestConfig requestConfig = {.width = 0x100, .height = 0x100, .strideAlignment = 0x8,
799 .format = GRAPHIC_PIXEL_FMT_YCBCR_420_SP,
800 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA, .timeout = 0};
801 pSurface->SetQueueSize(4);
802 int32_t formatType = GRAPHIC_PIXEL_FMT_YCBCR_420_SP;
803 NativeWindow* nativeWindow;
804 NativeWindowBuffer* nativeWindowBuffer;
805 requestConfig.format = formatType;
806 pSurface->RequestBuffer(sBuffer, fence, requestConfig);
807 nativeWindow = OH_NativeWindow_CreateNativeWindow(&pSurface);
808 ASSERT_NE(nativeWindow, nullptr);
809 nativeWindowBuffer = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&sBuffer);
810 ASSERT_NE(nativeWindowBuffer, nullptr);
811 OH_NativeBuffer* nativeBuffer = OH_NativeBufferFromNativeWindowBuffer(nativeWindowBuffer);
812 ASSERT_NE(nativeBuffer, nullptr);
813 OH_NativeBuffer* nativeBufferTmp = nullptr;
814 for (int32_t i = 0; i < 1000; i++) {
815 int32_t ret = OH_NativeBuffer_FromNativeWindowBuffer(nativeWindowBuffer, &nativeBufferTmp);
816 ASSERT_EQ(ret, OHOS::GSERROR_OK);
817 ASSERT_EQ(nativeBuffer, nativeBufferTmp);
818 }
819 void *virAddr = nullptr;
820 OH_NativeBuffer_Planes outPlanes;
821 clock_t startTime, endTime;
822 startTime = clock();
823 for (int32_t i = 0; i < 1000; i++) {
824 int32_t ret = OH_NativeBuffer_MapPlanes(nativeBuffer, &virAddr, &outPlanes);
825 if (ret != GSERROR_HDI_ERROR) {
826 ASSERT_EQ(ret, OHOS::GSERROR_OK);
827 ASSERT_NE(virAddr, nullptr);
828 }
829 }
830 endTime = clock();
831 cout << "OH_NativeBuffer_MapPlanes 1000 times cost time: " << (endTime - startTime) << "ms" << endl;
832 sBuffer = nullptr;
833 cSurface = nullptr;
834 producer = nullptr;
835 pSurface = nullptr;
836 nativeWindow = nullptr;
837 nativeWindowBuffer = nullptr;
838 }
839 }