1 /*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "exif_metadata.h"
18 #include "image_common.h"
19 #include "image_common_impl.h"
20 #include "image_source_native.h"
21 #include "image_utils.h"
22 #include "metadata.h"
23 #include "picture_native.h"
24 #include "pixelmap_native_impl.h"
25 #include "pixel_map.h"
26 #include "pixelmap_native.h"
27 #include "securec.h"
28 using namespace testing::ext;
29 namespace OHOS {
30 namespace Media {
31 class PictureNdkTest : public testing::Test {
32 public:
PictureNdkTest()33 PictureNdkTest() {}
~PictureNdkTest()34 ~PictureNdkTest() {}
35 };
36
37 static const int32_t SIZE_WIDTH = 820;
38 static const int32_t SIZE_HEIGHT = 312;
39 static const int32_t INIT_BUFFER_LENGTH = 8;
40 static const int32_t BUFFER_LENGTH = 255900;
41 static const int32_t SIZE_WIDTH_EXCEED = 20;
42 static const int32_t SIZE_HEIGHT_EXCEED = 50;
43 static const int32_t SIZE_BUFFER = 2017220;
44 static const int32_t BUFFER_SIZE = 256;
45 static const std::string IMAGE_JPEG_PATH = "/data/local/tmp/image/test_picture.jpg";
46 static const int8_t NUM_0 = 0;
47 static const int32_t ERRER_AUXILIARY_PICTURE_TYPE = 20;
48 static const uint32_t ROW_STRIDE = 10;
49 static const Image_MetadataType INVALID_METADATA = static_cast<Image_MetadataType>(-1);
50
ReleasingLocalResources(OH_ImageSourceNative * source,OH_DecodingOptions * opts,OH_DecodingOptionsForPicture * options)51 static void ReleasingLocalResources(OH_ImageSourceNative *source, OH_DecodingOptions *opts,
52 OH_DecodingOptionsForPicture *options)
53 {
54 if (source != nullptr) {
55 OH_ImageSourceNative_Release(source);
56 source = nullptr;
57 }
58 if (opts != nullptr) {
59 OH_DecodingOptions_Release(opts);
60 opts = nullptr;
61 }
62 if (options != nullptr) {
63 OH_DecodingOptionsForPicture_Release(options);
64 options = nullptr;
65 }
66 }
67
CreateNativePicture(std::vector<Image_AuxiliaryPictureType> & ayxTypeList)68 OH_PictureNative *CreateNativePicture(std::vector<Image_AuxiliaryPictureType>& ayxTypeList)
69 {
70 std::string realPath;
71 if (!ImageUtils::PathToRealPath(IMAGE_JPEG_PATH.c_str(), realPath)) {
72 return nullptr;
73 }
74 char filePath[BUFFER_SIZE];
75 if (strcpy_s(filePath, sizeof(filePath), realPath.c_str()) != EOK) {
76 return nullptr;
77 }
78 size_t length = realPath.size();
79 OH_ImageSourceNative *source = nullptr;
80 Image_ErrorCode ret = OH_ImageSourceNative_CreateFromUri(filePath, length, &source);
81 if (source == nullptr) {
82 return nullptr;
83 }
84
85 OH_DecodingOptions *opts = nullptr;
86 OH_PixelmapNative *pixelmap = nullptr;
87 OH_DecodingOptions_Create(&opts);
88 if (opts == nullptr) {
89 ReleasingLocalResources(source, opts, nullptr);
90 return nullptr;
91 }
92 OH_DecodingOptionsForPicture *options = nullptr;
93 ret = OH_DecodingOptionsForPicture_Create(&options);
94 EXPECT_EQ(ret, IMAGE_SUCCESS);
95 if (options == nullptr) {
96 ReleasingLocalResources(source, opts, options);
97 return nullptr;
98 }
99 ret = OH_ImageSourceNative_CreatePixelmap(source, opts, &pixelmap);
100 if (pixelmap == nullptr) {
101 ReleasingLocalResources(source, opts, options);
102 return nullptr;
103 }
104 ret = OH_DecodingOptionsForPicture_SetDesiredAuxiliaryPictures(options, ayxTypeList.data(), ayxTypeList.size());
105 OH_PictureNative *picture = nullptr;
106 ret = OH_PictureNative_CreatePicture(pixelmap, &picture);
107 if (picture == nullptr) {
108 ReleasingLocalResources(source, opts, options);
109 return nullptr;
110 }
111 ret = OH_ImageSourceNative_CreatePicture(source, options, &picture);
112 if (picture == nullptr) {
113 ReleasingLocalResources(source, opts, options);
114 return nullptr;
115 }
116 EXPECT_EQ(ret, IMAGE_SUCCESS);
117 ReleasingLocalResources(source, opts, options);
118 return picture;
119 }
120
CreateAuxiliaryPictureNative()121 OH_AuxiliaryPictureNative *CreateAuxiliaryPictureNative()
122 {
123 std::unique_ptr<uint32_t[]> color = std::make_unique<uint32_t[]>(BUFFER_LENGTH);
124 if (color == nullptr) {
125 return nullptr;
126 }
127 uint32_t colorTmp[INIT_BUFFER_LENGTH] = {0x80, 0x02, 0x04, 0x08, 0x40, 0x02, 0x04, 0x08};
128 if (EOK != memcpy_s(color.get(), INIT_BUFFER_LENGTH, colorTmp, INIT_BUFFER_LENGTH)) {
129 return nullptr;
130 }
131 size_t dataLength = BUFFER_LENGTH;
132 Image_Size size;
133 size.width = SIZE_WIDTH;
134 size.height = SIZE_HEIGHT;
135 OH_AuxiliaryPictureNative *picture = nullptr;
136
137 Image_ErrorCode ret = OH_AuxiliaryPictureNative_Create(reinterpret_cast<uint8_t*>(color.get()), dataLength, &size,
138 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP, &picture);
139 EXPECT_EQ(ret, IMAGE_SUCCESS);
140
141 return picture;
142 }
143
144 /**
145 * @tc.name: OH_AuxiliaryPictureNative_CreateTest001
146 * @tc.desc: Creating OH_AuxiliaPictureNative with all normal parameters.
147 * @tc.type: FUNC
148 */
149 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_CreateTest001, TestSize.Level1)
150 {
151 std::unique_ptr<uint32_t[]> color = std::make_unique<uint32_t[]>(BUFFER_LENGTH);
152 ASSERT_NE(color, nullptr);
153 uint32_t colorTmp[INIT_BUFFER_LENGTH] = {0x80, 0x02, 0x04, 0x08, 0x40, 0x02, 0x04, 0x08};
154 errno_t res = memcpy_s(color.get(), INIT_BUFFER_LENGTH, colorTmp, INIT_BUFFER_LENGTH);
155 ASSERT_EQ(res, EOK);
156 size_t dataLength = BUFFER_LENGTH;
157 Image_Size size;
158 size.width = SIZE_WIDTH;
159 size.height = SIZE_HEIGHT;
160 OH_AuxiliaryPictureNative *picture = nullptr;
161
162 Image_ErrorCode ret = OH_AuxiliaryPictureNative_Create(reinterpret_cast<uint8_t*>(color.get()), dataLength, &size,
163 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP, &picture);
164 EXPECT_EQ(ret, IMAGE_SUCCESS);
165 OH_AuxiliaryPictureNative_Release(picture);
166 picture = nullptr;
167
168 ret = OH_AuxiliaryPictureNative_Create(reinterpret_cast<uint8_t*>(color.get()), dataLength, &size,
169 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_DEPTH_MAP, &picture);
170 EXPECT_EQ(ret, ::IMAGE_SUCCESS);
171 OH_AuxiliaryPictureNative_Release(picture);
172 picture = nullptr;
173
174 ret = OH_AuxiliaryPictureNative_Create(reinterpret_cast<uint8_t*>(color.get()), dataLength, &size,
175 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_FRAGMENT_MAP, &picture);
176 EXPECT_EQ(ret, ::IMAGE_SUCCESS);
177 OH_AuxiliaryPictureNative_Release(picture);
178 picture = nullptr;
179
180 ret = OH_AuxiliaryPictureNative_Create(reinterpret_cast<uint8_t*>(color.get()), dataLength, &size,
181 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_LINEAR_MAP, &picture);
182 EXPECT_EQ(ret, ::IMAGE_SUCCESS);
183 OH_AuxiliaryPictureNative_Release(picture);
184 picture = nullptr;
185
186 ret = OH_AuxiliaryPictureNative_Create(reinterpret_cast<uint8_t*>(color.get()), dataLength, &size,
187 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_UNREFOCUS_MAP, &picture);
188 OH_AuxiliaryPictureNative_Release(picture);
189 picture = nullptr;
190 EXPECT_EQ(ret, ::IMAGE_SUCCESS);
191 }
192
193 /**
194 * @tc.name: OH_AuxiliaryPictureNative_CreateTest002
195 * @tc.desc: Create OH_AuxiliaryPictureNative, pass null parameter, return IMAGE_BAD_PARAMETER.
196 * @tc.type: FUNC
197 */
198 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_CreateTest002, TestSize.Level2)
199 {
200 uint8_t *color = nullptr;
201 size_t dataLength = BUFFER_LENGTH;
202 Image_Size size;
203 size.width = SIZE_WIDTH;
204 size.height = SIZE_HEIGHT;
205 OH_AuxiliaryPictureNative *picture = nullptr;
206 Image_AuxiliaryPictureType type = Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP;
207
208 Image_ErrorCode ret = OH_AuxiliaryPictureNative_Create(color, dataLength, &size, type, &picture);
209 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
210 }
211
212 /**
213 * @tc.name: OH_AuxiliaryPictureNative_CreateTest003
214 * @tc.desc: Create OH_AuxiliaryPictureNative, pass in error parameters, return IMAGE_ALLOC_FAILED.
215 * @tc.type: FUNC
216 */
217 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_CreateTest003, TestSize.Level2)
218 {
219 uint32_t color[INIT_BUFFER_LENGTH] = {0x80, 0x02, 0x04, 0x08, 0x40, 0x02, 0x04, 0x08};
220 size_t dataLength = INIT_BUFFER_LENGTH;
221 Image_Size size;
222 size.width = SIZE_WIDTH_EXCEED;
223 size.height = SIZE_HEIGHT_EXCEED;
224 OH_AuxiliaryPictureNative *picture = nullptr;
225 Image_AuxiliaryPictureType type = Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP;
226
227 Image_ErrorCode ret = OH_AuxiliaryPictureNative_Create(reinterpret_cast<uint8_t*>(color),
228 dataLength, &size, type, &picture);
229 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
230 }
231
232 /**
233 * @tc.name: OH_AuxiliaryPictureNative_CreateTest004
234 * @tc.desc: Pass in a non-existent AuxiliaryPictureType and return an exception.
235 * @tc.type: FUNC
236 */
237 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_CreateTest004, TestSize.Level2)
238 {
239 std::unique_ptr<uint32_t[]> color = std::make_unique<uint32_t[]>(BUFFER_LENGTH);
240 ASSERT_NE(color, nullptr);
241 uint32_t colorTmp[INIT_BUFFER_LENGTH] = { 0x80, 0x02, 0x04, 0x08, 0x40, 0x02, 0x04, 0x08 };
242 errno_t res = memcpy_s(color.get(), INIT_BUFFER_LENGTH, colorTmp, INIT_BUFFER_LENGTH);
243 ASSERT_EQ(res, EOK);
244 size_t dataLength = BUFFER_LENGTH;
245 Image_Size size;
246 size.width = SIZE_WIDTH;
247 size.height = SIZE_HEIGHT;
248 OH_AuxiliaryPictureNative *picture = nullptr;
249 Image_AuxiliaryPictureType type = static_cast<Image_AuxiliaryPictureType>(-1);
250
251 Image_ErrorCode ret = OH_AuxiliaryPictureNative_Create(reinterpret_cast<uint8_t*>(color.get()),
252 dataLength, &size, type, &picture);
253 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
254 }
255
256 /**
257 * @tc.name: OH_AuxiliaryPictureNative_WritePixelsTest001
258 * @tc.desc: Pass in the correct parameters to WritePixels and return success.
259 * @tc.type: FUNC
260 */
261 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_WritePixelsTest001, TestSize.Level1)
262 {
263 OH_AuxiliaryPictureNative *picture = CreateAuxiliaryPictureNative();
264 ASSERT_NE(picture, nullptr);
265 size_t size = SIZE_BUFFER;
266 std::unique_ptr<uint8_t[]> source = std::make_unique<uint8_t[]>(size);
267 ASSERT_NE(source, nullptr);
268
269 Image_ErrorCode ret = OH_AuxiliaryPictureNative_WritePixels(picture, source.get(), size);
270 EXPECT_EQ(ret, IMAGE_SUCCESS);
271 OH_AuxiliaryPictureNative_Release(picture);
272 }
273
274 /**
275 * @tc.name: OH_AuxiliaryPictureNative_WritePixelsTest002
276 * @tc.desc: Passing an exception buff to WritePixels returns an exception.
277 * @tc.type: FUNC
278 */
279 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_WritePixelsTest002, TestSize.Level1)
280 {
281 OH_AuxiliaryPictureNative *picture = CreateAuxiliaryPictureNative();
282 ASSERT_NE(picture, nullptr);
283 size_t size = INIT_BUFFER_LENGTH;
284 std::unique_ptr<uint8_t[]> source = std::make_unique<uint8_t[]>(size);
285
286 Image_ErrorCode ret = OH_AuxiliaryPictureNative_WritePixels(picture, source.get(), size);
287 EXPECT_EQ(ret, IMAGE_COPY_FAILED);
288 OH_AuxiliaryPictureNative_Release(picture);
289 }
290
291 /**
292 * @tc.name: OH_AuxiliaryPictureNative_WritePixelsTest003
293 * @tc.desc: Passing an empty parameter to WritePixels and returning an exception.
294 * @tc.type: FUNC
295 */
296 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_WritePixelsTest003, TestSize.Level2)
297 {
298 OH_AuxiliaryPictureNative *picture = nullptr;
299 uint8_t *source = nullptr;
300 size_t BUFFER_SIZE = NUM_0;
301
302 Image_ErrorCode ret = OH_AuxiliaryPictureNative_WritePixels(picture, source, BUFFER_SIZE);
303 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
304 }
305
306 /**
307 * @tc.name: OH_AuxiliaryPictureNative_ReadPixelsTest001
308 * @tc.desc: Passing a normal buff to ReadPixels returns success.
309 * @tc.type: FUNC
310 */
311 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_ReadPixelsTest001, TestSize.Level1)
312 {
313 OH_AuxiliaryPictureNative *picture = CreateAuxiliaryPictureNative();
314 ASSERT_NE(picture, nullptr);
315 size_t size = SIZE_BUFFER;
316 std::unique_ptr<uint8_t[]> destination = std::make_unique<uint8_t[]>(size);
317 ASSERT_NE(destination, nullptr);
318
319 Image_ErrorCode ret = OH_AuxiliaryPictureNative_ReadPixels(picture, destination.get(), &size);
320 EXPECT_EQ(ret, IMAGE_SUCCESS);
321 OH_AuxiliaryPictureNative_Release(picture);
322 }
323
324 /**
325 * @tc.name: OH_AuxiliaryPictureNative_ReadPixelsTest002
326 * @tc.desc: Passing an exception buff to ReadPixels returns an exception.
327 * @tc.type: FUNC
328 */
329 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_ReadPixelsTest002, TestSize.Level2)
330 {
331 OH_AuxiliaryPictureNative *picture = CreateAuxiliaryPictureNative();
332 ASSERT_NE(picture, nullptr);
333 size_t size = INIT_BUFFER_LENGTH;
334 std::unique_ptr<uint8_t[]> destination = std::make_unique<uint8_t[]>(size);
335
336 Image_ErrorCode ret = OH_AuxiliaryPictureNative_ReadPixels(picture, destination.get(), &size);
337 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
338 OH_AuxiliaryPictureNative_Release(picture);
339 }
340
341 /**
342 * @tc.name: OH_AuxiliaryPictureNative_ReadPixelsTest003
343 * @tc.desc: Pass an empty parameter to ReadPixels and return an exception.
344 * @tc.type: FUNC
345 */
346 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_ReadPixelsTest003, TestSize.Level3)
347 {
348 OH_AuxiliaryPictureNative *picture = nullptr;
349 uint8_t *destination = nullptr;
350 size_t *BUFFER_SIZE = nullptr;
351
352 Image_ErrorCode ret = OH_AuxiliaryPictureNative_ReadPixels(picture, destination, BUFFER_SIZE);
353 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
354 }
355
356 /**
357 * @tc.name: OH_AuxiliaryPictureNative_GetTypeTest001
358 * @tc.desc: The input auxiliary image is GAINMAP, and the returned type is GAINMAP.
359 * @tc.type: FUNC
360 */
361 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_GetTypeTest001, TestSize.Level1)
362 {
363 OH_AuxiliaryPictureNative *picture = CreateAuxiliaryPictureNative();
364 ASSERT_NE(picture, nullptr);
365 Image_AuxiliaryPictureType type;
366
367 Image_ErrorCode ret = OH_AuxiliaryPictureNative_GetType(picture, &type);
368 EXPECT_EQ(ret, IMAGE_SUCCESS);
369 EXPECT_EQ(type, Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP);
370 OH_AuxiliaryPictureNative_Release(picture);
371 }
372
373 /**
374 * @tc.name: OH_AuxiliaryPictureNative_GetTypeTest002
375 * @tc.desc: Pass in an empty parameter and return an empty type.
376 * @tc.type: FUNC
377 */
378 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_GetTypeTest002, TestSize.Level2)
379 {
380 OH_AuxiliaryPictureNative *picture = nullptr;
381 Image_AuxiliaryPictureType *typeptr = nullptr;
382
383 Image_ErrorCode ret = OH_AuxiliaryPictureNative_GetType(picture, typeptr);
384 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
385 EXPECT_EQ(typeptr, nullptr);
386 }
387
388 /**
389 * @tc.name: OH_AuxiliaryPictureNative_GetInfoTest001
390 * @tc.desc: Pass in the correct parameters and compare the type of info with the original type of AuxiliaryPicture.
391 * @tc.type: FUNC
392 */
393 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_GetInfoTest001, TestSize.Level1)
394 {
395 OH_AuxiliaryPictureNative *picture = CreateAuxiliaryPictureNative();
396 ASSERT_NE(picture, nullptr);
397 OH_AuxiliaryPictureInfo *infoptr = nullptr;
398
399 Image_ErrorCode ret = OH_AuxiliaryPictureNative_GetInfo(picture, &infoptr);
400 EXPECT_EQ(ret, IMAGE_SUCCESS);
401
402 Image_AuxiliaryPictureType type;
403 ret = OH_AuxiliaryPictureInfo_GetType(infoptr, &type);
404 EXPECT_EQ(ret, IMAGE_SUCCESS);
405 EXPECT_EQ(type, Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP);
406
407 OH_AuxiliaryPictureInfo_Release(infoptr);
408 OH_AuxiliaryPictureNative_Release(picture);
409 }
410
411 /**
412 * @tc.name: OH_AuxiliaryPictureNative_GetInfoTest002
413 * @tc.desc: Pass in incorrect parameter, get empty.
414 * @tc.type: FUNC
415 */
416 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_GetInfoTest002, TestSize.Level2)
417 {
418 OH_AuxiliaryPictureNative *picture = nullptr;
419 OH_AuxiliaryPictureInfo *infoptr = nullptr;
420
421 Image_ErrorCode ret = OH_AuxiliaryPictureNative_GetInfo(picture, &infoptr);
422 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
423 EXPECT_EQ(infoptr, nullptr);
424 }
425
426 /**
427 * @tc.name: OH_AuxiliaryPictureNative_SetInfoTest001
428 * @tc.desc: Passing in the correct parameter settings info returned a success message.
429 * @tc.type: FUNC
430 */
431 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_SetInfoTest001, TestSize.Level1)
432 {
433 OH_AuxiliaryPictureNative *picture = CreateAuxiliaryPictureNative();
434 ASSERT_NE(picture, nullptr);
435 OH_AuxiliaryPictureInfo *infoptr = nullptr;
436 OH_AuxiliaryPictureInfo_Create(&infoptr);
437
438 Image_ErrorCode ret = OH_AuxiliaryPictureNative_SetInfo(picture, infoptr);
439 Image_ErrorCode expectRet = ImageUtils::GetAPIVersion() > APIVERSION_13 ? IMAGE_BAD_PARAMETER : IMAGE_SUCCESS;
440 EXPECT_EQ(ret, expectRet);
441 OH_AuxiliaryPictureNative_Release(picture);
442 }
443
444 /**
445 * @tc.name: OH_AuxiliaryPictureNative_SetInfoTest002
446 * @tc.desc: Passing empty parameter setting info returns an exception.
447 * @tc.type: FUNC
448 */
449 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_SetInfoTest002, TestSize.Level3)
450 {
451 OH_AuxiliaryPictureNative *picture = nullptr;
452 OH_AuxiliaryPictureInfo *infoptr = nullptr;
453
454 Image_ErrorCode ret = OH_AuxiliaryPictureNative_SetInfo(picture, infoptr);
455 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
456 }
457
458 /**
459 * @tc.name: OH_AuxiliaryPictureNative_GetMetadataTest001
460 * @tc.desc: Pass in a non-existent Metadata Type and return an exception.
461 * @tc.type: FUNC
462 */
463 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_GetMetadataTest001, TestSize.Level2)
464 {
465 OH_AuxiliaryPictureNative *picture = CreateAuxiliaryPictureNative();
466 ASSERT_NE(picture, nullptr);
467 OH_PictureMetadata *metadataptr = nullptr;
468 Image_MetadataType type = static_cast<Image_MetadataType>(9); // wrong type
469
470 Image_ErrorCode ret = OH_AuxiliaryPictureNative_GetMetadata(picture, type, &metadataptr);
471 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
472 EXPECT_EQ(metadataptr, nullptr);
473 OH_AuxiliaryPictureNative_Release(picture);
474 }
475
476 /**
477 * @tc.name: OH_AuxiliaryPictureNative_GetMetadataTest002
478 * @tc.desc: Pass in an empty parameter and return a null pointer.
479 * @tc.type: FUNC
480 */
481 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_GetMetadataTest002, TestSize.Level2)
482 {
483 OH_AuxiliaryPictureNative *picture = nullptr;
484 OH_PictureMetadata *metadataptr = nullptr;
485 Image_MetadataType metadataType = EXIF_METADATA;
486
487 Image_ErrorCode ret = OH_AuxiliaryPictureNative_GetMetadata(picture, metadataType, &metadataptr);
488 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
489 EXPECT_EQ(metadataptr, nullptr);
490 }
491
492 /**
493 * @tc.name: OH_AuxiliaryPictureNative_SetMetadataTest001
494 * @tc.desc: Pass in the normal parameter SetMetadata and return success.
495 * @tc.type: FUNC
496 */
497 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_SetMetadataTest001, TestSize.Level1)
498 {
499 OH_AuxiliaryPictureNative *picture = CreateAuxiliaryPictureNative();
500 ASSERT_NE(picture, nullptr);
501
502 Image_MetadataType metadataType = EXIF_METADATA;
503 OH_PictureMetadata *metadataptr = nullptr;
504 Image_ErrorCode ret = OH_PictureMetadata_Create(metadataType, &metadataptr);
505 EXPECT_EQ(ret, IMAGE_SUCCESS);
506 EXPECT_NE(metadataptr, nullptr);
507
508 ret = OH_AuxiliaryPictureNative_SetMetadata(picture, metadataType, metadataptr);
509 EXPECT_EQ(ret, IMAGE_SUCCESS);
510 OH_PictureMetadata *metadataPtrGet = nullptr;
511 ret = OH_AuxiliaryPictureNative_GetMetadata(picture, metadataType, &metadataPtrGet);
512 EXPECT_EQ(ret, IMAGE_UNSUPPORTED_METADATA);
513 OH_PictureMetadata_Release(metadataptr);
514 OH_PictureMetadata_Release(metadataPtrGet);
515 OH_AuxiliaryPictureNative_Release(picture);
516 }
517
518 /**
519 * @tc.name: OH_AuxiliaryPictureNative_SetMetadataTest002
520 * @tc.desc: Pass in empty parameter SetMetadata, return exception.
521 * @tc.type: FUNC
522 */
523 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_SetMetadataTest002, TestSize.Level2)
524 {
525 OH_AuxiliaryPictureNative *picture = nullptr;
526 OH_PictureMetadata *metadata = nullptr;
527
528 Image_ErrorCode ret = OH_AuxiliaryPictureNative_SetMetadata(picture,
529 Image_MetadataType::FRAGMENT_METADATA, metadata);
530 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
531 }
532
533 /**
534 * @tc.name: OH_PictureNative_CreatePicture001
535 * @tc.desc: Verify that a native picture can be successfully created.
536 * @tc.type: FUNC
537 */
538 HWTEST_F(PictureNdkTest, OH_PictureNative_CreatePicture001, TestSize.Level1)
539 {
540 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
541 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
542 EXPECT_NE(picture, nullptr);
543 OH_PictureNative_Release(picture);
544 }
545
546 /**
547 * @tc.name: OH_PictureNative_CreatePicture002
548 * @tc.desc: Verify error handling when creating a native picture with a null pixelmap.
549 * @tc.type: FUNC
550 */
551 HWTEST_F(PictureNdkTest, OH_PictureNative_CreatePicture002, TestSize.Level3)
552 {
553 OH_PictureNative *picture = nullptr;
554 Image_ErrorCode ret = OH_PictureNative_CreatePicture(nullptr, &picture);
555 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
556 }
557
558 /**
559 * @tc.name: OH_PictureNative_GetMainPixelmap001
560 * @tc.desc: Verify retrieval of the main pixelmap from a native picture.
561 * @tc.type: FUNC
562 */
563 HWTEST_F(PictureNdkTest, OH_PictureNative_GetMainPixelmap001, TestSize.Level1)
564 {
565 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
566 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
567 ASSERT_NE(picture, nullptr);
568 OH_PixelmapNative *mainPixelmap = nullptr;
569
570 Image_ErrorCode ret = OH_PictureNative_GetMainPixelmap(picture, &mainPixelmap);
571 EXPECT_NE(mainPixelmap, nullptr);
572 EXPECT_EQ(ret, IMAGE_SUCCESS);
573 OH_PictureNative_Release(picture);
574 }
575
576 /**
577 * @tc.name: OH_PictureNative_GetMainPixelmap002
578 * @tc.desc: Verify error handling when attempting to retrieve the main pixelmap from a null picture object.
579 * @tc.type: FUNC
580 */
581 HWTEST_F(PictureNdkTest, OH_PictureNative_GetMainPixelmap002, TestSize.Level3)
582 {
583 OH_PixelmapNative *mainPixelmap = nullptr;
584 Image_ErrorCode ret = OH_PictureNative_GetMainPixelmap(nullptr, &mainPixelmap);
585 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
586 }
587
588 /**
589 * @tc.name: OH_PictureNative_GetGainmapPixelmap001
590 * @tc.desc: Verify retrieval of the gainmap pixelmap from a native picture with an auxiliary gainmap set.
591 * @tc.type: FUNC
592 */
593 HWTEST_F(PictureNdkTest, OH_PictureNative_GetGainmapPixelmap001, TestSize.Level1)
594 {
595 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
596 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
597 ASSERT_NE(picture, nullptr);
598 OH_AuxiliaryPictureNative *auxiliaryPicture = CreateAuxiliaryPictureNative();
599
600 Image_ErrorCode ret = OH_PictureNative_SetAuxiliaryPicture(picture,
601 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP, auxiliaryPicture);
602 ASSERT_EQ(ret, IMAGE_SUCCESS);
603
604 OH_PixelmapNative *gainmapPixelmap = nullptr;
605 ret = OH_PictureNative_GetGainmapPixelmap(picture, &gainmapPixelmap);
606 EXPECT_NE(gainmapPixelmap, nullptr);
607 EXPECT_EQ(ret, IMAGE_SUCCESS);
608
609 OH_PictureNative_Release(picture);
610 OH_AuxiliaryPictureNative_Release(auxiliaryPicture);
611 }
612
613 /**
614 * @tc.name: OH_PictureNative_GetGainmapPixelmap002
615 * @tc.desc: Verify that the auxiliary gain map cannot retrieve the gain map pixel map from the local
616 * image using the auxiliary gain map set.
617 * @tc.type: FUNC
618 */
619 HWTEST_F(PictureNdkTest, OH_PictureNative_GetGainmapPixelmap002, TestSize.Level3)
620 {
621 std::vector<Image_AuxiliaryPictureType> auxTypeList = {AUXILIARY_PICTURE_TYPE_FRAGMENT_MAP};
622 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
623 OH_AuxiliaryPictureNative *auxiliaryPicture = CreateAuxiliaryPictureNative();
624
625 OH_PixelmapNative *gainmapPixelmap = nullptr;
626 Image_ErrorCode ret = OH_PictureNative_GetGainmapPixelmap(picture, &gainmapPixelmap);
627 EXPECT_EQ(gainmapPixelmap, nullptr);
628 EXPECT_EQ(ret, IMAGE_ALLOC_FAILED);
629
630 OH_PictureNative_Release(picture);
631 OH_AuxiliaryPictureNative_Release(auxiliaryPicture);
632 }
633
634 /**
635 * @tc.name: OH_PictureNative_GetGainmapPixelmap003
636 * @tc.desc: Verify error handling when attempting to retrieve a gainmap pixelmap from a null picture pointer.
637 * @tc.type: FUNC
638 */
639 HWTEST_F(PictureNdkTest, OH_PictureNative_GetGainmapPixelmap003, TestSize.Level3)
640 {
641 OH_PixelmapNative *gainmapPixelmap = nullptr;
642 Image_ErrorCode ret = OH_PictureNative_GetGainmapPixelmap(nullptr, &gainmapPixelmap);
643 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
644 }
645
646 /**
647 * @tc.name: OH_PictureNative_GetAuxiliaryPicture001
648 * @tc.desc: Verify the functionality of retrieving an auxiliary picture of type gainmap
649 * that has been previously set on a native picture.
650 * @tc.type: FUNC
651 */
652 HWTEST_F(PictureNdkTest, OH_PictureNative_GetAuxiliaryPicture001, TestSize.Level1)
653 {
654 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
655 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
656 OH_AuxiliaryPictureNative *auxiliaryPicture = CreateAuxiliaryPictureNative();
657
658 Image_AuxiliaryPictureType type = Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP;
659 Image_ErrorCode ret = OH_PictureNative_SetAuxiliaryPicture(picture, type, auxiliaryPicture);
660 ASSERT_EQ(ret, IMAGE_SUCCESS);
661
662 OH_AuxiliaryPictureNative *auxPicture = nullptr;
663 ret = OH_PictureNative_GetAuxiliaryPicture(picture, type, &auxPicture);
664 EXPECT_NE(auxPicture, nullptr);
665 EXPECT_EQ(ret, IMAGE_SUCCESS);
666
667 OH_PictureNative_Release(picture);
668 OH_AuxiliaryPictureNative_Release(auxiliaryPicture);
669 }
670
671 /**
672 * @tc.name: OH_PictureNative_GetAuxiliaryPicture002
673 * @tc.desc: The passed AuxiliaryFigureType does not exist, return exception.
674 * @tc.type: FUNC
675 */
676 HWTEST_F(PictureNdkTest, OH_PictureNative_GetAuxiliaryPicture002, TestSize.Level3)
677 {
678 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
679 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
680 OH_AuxiliaryPictureNative *auxiliaryPicture = CreateAuxiliaryPictureNative();
681
682 Image_ErrorCode ret = OH_PictureNative_SetAuxiliaryPicture(picture,
683 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP, auxiliaryPicture);
684 ASSERT_EQ(ret, IMAGE_SUCCESS);
685
686 OH_AuxiliaryPictureNative *auxPicture = nullptr;
687 Image_AuxiliaryPictureType type = static_cast<Image_AuxiliaryPictureType>(-1);
688 ret = OH_PictureNative_GetAuxiliaryPicture(picture, type, &auxPicture);
689 EXPECT_EQ(auxPicture, nullptr);
690 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
691
692 OH_PictureNative_Release(picture);
693 OH_AuxiliaryPictureNative_Release(auxiliaryPicture);
694 }
695
696 /**
697 * @tc.name: OH_PictureNative_GetAuxiliaryPicture003
698 * @tc.desc: Get the desired AuxiliaryFigureType is not set and returns an exception.
699 * @tc.type: FUNC
700 */
701 HWTEST_F(PictureNdkTest, OH_PictureNative_GetAuxiliaryPicture003, TestSize.Level3)
702 {
703 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
704 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
705 OH_AuxiliaryPictureNative *auxiliaryPicture = CreateAuxiliaryPictureNative();
706
707 Image_ErrorCode ret = OH_PictureNative_SetAuxiliaryPicture(picture,
708 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP, auxiliaryPicture);
709 ASSERT_EQ(ret, IMAGE_SUCCESS);
710
711 OH_AuxiliaryPictureNative *auxPicture = nullptr;
712 ret = OH_PictureNative_GetAuxiliaryPicture(picture,
713 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_FRAGMENT_MAP, &auxPicture);
714 EXPECT_EQ(auxPicture, nullptr);
715 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
716
717 OH_PictureNative_Release(picture);
718 OH_AuxiliaryPictureNative_Release(auxiliaryPicture);
719 }
720
721 /**
722 * @tc.name: OH_PictureNative_GetAuxiliaryPicture004
723 * @tc.desc: Verify the behavior of OH_PictureNative_GetAuxiliaryPicture when attempting
724 * to retrieve an auxiliary picture of type GAINMAP from a null picture pointer.
725 * @tc.type: FUNC
726 */
727 HWTEST_F(PictureNdkTest, OH_PictureNative_GetAuxiliaryPicture004, TestSize.Level3)
728 {
729 OH_AuxiliaryPictureNative *auxiliaryPicture = nullptr;
730 Image_ErrorCode ret = OH_PictureNative_GetAuxiliaryPicture(nullptr,
731 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP, &auxiliaryPicture);
732 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
733 }
734
735 /**
736 * @tc.name: OH_PictureNative_SetAuxiliaryPicture001
737 * @tc.desc: Verify the functionality of OH_PictureNative_SetAuxiliaryPicture by creating
738 * a native picture and setting an auxiliary picture of type gainmap.
739 * @tc.type: FUNC
740 */
741 HWTEST_F(PictureNdkTest, OH_PictureNative_SetAuxiliaryPicture001, TestSize.Level1)
742 {
743 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
744 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
745 OH_AuxiliaryPictureNative *auxiliaryPicture = CreateAuxiliaryPictureNative();
746
747 Image_ErrorCode ret = OH_PictureNative_SetAuxiliaryPicture(picture,
748 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP, auxiliaryPicture);
749 EXPECT_EQ(ret, IMAGE_SUCCESS);
750
751 OH_PictureNative_Release(picture);
752 OH_AuxiliaryPictureNative_Release(auxiliaryPicture);
753 }
754
755 /**
756 * @tc.name: OH_PictureNative_SetAuxiliaryPicture002
757 * @tc.desc: Pass in a non-existent AuxiliaryFigureType and return an exception.
758 * @tc.type: FUNC
759 */
760 HWTEST_F(PictureNdkTest, OH_PictureNative_SetAuxiliaryPicture002, TestSize.Level3)
761 {
762 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
763 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
764 OH_AuxiliaryPictureNative *auxiliaryPicture = CreateAuxiliaryPictureNative();
765
766 Image_AuxiliaryPictureType type = static_cast<Image_AuxiliaryPictureType>(-1);
767 Image_ErrorCode ret = OH_PictureNative_SetAuxiliaryPicture(picture, type, auxiliaryPicture);
768 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
769
770 OH_PictureNative_Release(picture);
771 OH_AuxiliaryPictureNative_Release(auxiliaryPicture);
772 }
773
774 /**
775 * @tc.name: OH_PictureNative_SetAuxiliaryPicture003
776 * @tc.desc: Passing in different AuxiliaryPicture Types when creating AuxiliaryPicture, returns an exception.
777 * @tc.type: FUNC
778 */
779 HWTEST_F(PictureNdkTest, OH_PictureNative_SetAuxiliaryPicture003, TestSize.Level3)
780 {
781 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
782 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
783 OH_AuxiliaryPictureNative *auxiliaryPicture = CreateAuxiliaryPictureNative();
784
785 Image_ErrorCode ret = OH_PictureNative_SetAuxiliaryPicture(picture,
786 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_FRAGMENT_MAP, auxiliaryPicture);
787 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
788
789 OH_PictureNative_Release(picture);
790 OH_AuxiliaryPictureNative_Release(auxiliaryPicture);
791 }
792
793 /**
794 * @tc.name: OH_PictureNative_SetAuxiliaryPicture004
795 * @tc.desc: Verify the behavior of OH_PictureNative_SetAuxiliaryPicture when attempting
796 * to set an auxiliary picture of type gainmap on a null picture pointer.
797 * @tc.type: FUNC
798 */
799 HWTEST_F(PictureNdkTest, OH_PictureNative_SetAuxiliaryPicture004, TestSize.Level3)
800 {
801 Image_ErrorCode ret = OH_PictureNative_SetAuxiliaryPicture(nullptr,
802 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP, nullptr);
803 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
804 }
805
806 /**
807 * @tc.name: OH_PictureNative_Release001
808 * @tc.desc: Verify the functionality of OH_PictureNative_Release by creating a native picture
809 * and releasing it successfully using OH_PictureNative_Release.
810 * @tc.type: FUNC
811 */
812 HWTEST_F(PictureNdkTest, OH_PictureNative_Release001, TestSize.Level1)
813 {
814 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
815 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
816 Image_ErrorCode ret = OH_PictureNative_Release(picture);
817 EXPECT_EQ(ret, IMAGE_SUCCESS);
818 }
819
820 /**
821 * @tc.name: OH_PictureNative_Release002
822 * @tc.desc: Verify the behavior of OH_PictureNative_Release when attempting to release
823 * a null pointer to a native picture.
824 * @tc.type: FUNC
825 */
826 HWTEST_F(PictureNdkTest, OH_PictureNative_Release002, TestSize.Level3)
827 {
828 Image_ErrorCode ret = OH_PictureNative_Release(nullptr);
829 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
830 }
831
832 /**
833 * @tc.name: OH_AuxiliaryPictureNative_ReleaseTest001
834 * @tc.desc: Release a valid object and return success.
835 * @tc.type: FUNC
836 */
837 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_ReleaseTest001, TestSize.Level1)
838 {
839 std::unique_ptr<uint32_t[]> color = std::make_unique<uint32_t[]>(BUFFER_LENGTH);
840 ASSERT_NE(color, nullptr);
841 uint32_t colorTmp[INIT_BUFFER_LENGTH] = {0x80, 0x02, 0x04, 0x08, 0x40, 0x02, 0x04, 0x08};
842 errno_t res = memcpy_s(color.get(), INIT_BUFFER_LENGTH, colorTmp, INIT_BUFFER_LENGTH);
843 ASSERT_EQ(res, EOK);
844 size_t dataLength = BUFFER_LENGTH;
845 Image_Size size;
846 size.width = SIZE_WIDTH;
847 size.height = SIZE_HEIGHT;
848 OH_AuxiliaryPictureNative *auxiliaryPictureNative = nullptr;
849
850 Image_ErrorCode ret = OH_AuxiliaryPictureNative_Create(reinterpret_cast<uint8_t *>(color.get()), dataLength, &size,
851 Image_AuxiliaryPictureType::AUXILIARY_PICTURE_TYPE_GAINMAP, &auxiliaryPictureNative);
852 EXPECT_EQ(ret, IMAGE_SUCCESS);
853 EXPECT_NE(auxiliaryPictureNative, nullptr);
854
855 ret = OH_AuxiliaryPictureNative_Release(auxiliaryPictureNative);
856 EXPECT_EQ(ret, IMAGE_SUCCESS);
857 }
858
859 /**
860 * @tc.name: OH_AuxiliaryPictureNative_ReleaseTest002
861 * @tc.desc: Pass in an empty object and return an exception.
862 * @tc.type: FUNC
863 */
864 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureNative_ReleaseTest002, TestSize.Level3)
865 {
866 Image_ErrorCode ret = OH_AuxiliaryPictureNative_Release(nullptr);
867 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
868 }
869
870 /**
871 * @tc.name: OH_AuxiliaryPictureInfo_CreateTest001
872 * @tc.desc: Create an OH_AuxiliaryPictureInfo object using valid parameters.
873 * @tc.type: FUNC
874 */
875 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_CreateTest001, TestSize.Level1)
876 {
877 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
878 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(&auxiliaryPictureInfo);
879 ASSERT_NE(auxiliaryPictureInfo, nullptr);
880 EXPECT_EQ(ret, IMAGE_SUCCESS);
881
882 OH_AuxiliaryPictureInfo_Release(auxiliaryPictureInfo);
883 }
884
885 /**
886 * @tc.name: OH_AuxiliaryPictureInfo_CreateTest002
887 * @tc.desc: Pass in null pointer and return exception.
888 * @tc.type: FUNC
889 */
890 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_CreateTest002, TestSize.Level3)
891 {
892 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(nullptr);
893 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
894 }
895
896 /**
897 * @tc.name: OH_AuxiliaryPictureInfo_SetTypeTest001
898 * @tc.desc: Pass in valid OH_AuxiliaryPictureInfo object and type, and then return success.
899 * @tc.type: FUNC
900 */
901 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_SetTypeTest001, TestSize.Level1)
902 {
903 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
904 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(&auxiliaryPictureInfo);
905 EXPECT_EQ(ret, IMAGE_SUCCESS);
906 ASSERT_NE(auxiliaryPictureInfo, nullptr);
907
908 Image_AuxiliaryPictureType type = AUXILIARY_PICTURE_TYPE_GAINMAP;
909 ret = OH_AuxiliaryPictureInfo_SetType(auxiliaryPictureInfo, type);
910 EXPECT_EQ(ret, IMAGE_SUCCESS);
911
912 OH_AuxiliaryPictureInfo_Release(auxiliaryPictureInfo);
913 }
914
915 /**
916 * @tc.name: OH_AuxiliaryPictureInfo_SetTypeTest002
917 * @tc.desc: Passing in invalid AuxiliaryPictureType, returning exception.
918 * @tc.type: FUNC
919 */
920 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_SetTypeTest002, TestSize.Level3)
921 {
922 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
923 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(&auxiliaryPictureInfo);
924 EXPECT_EQ(ret, IMAGE_SUCCESS);
925 ASSERT_NE(auxiliaryPictureInfo, nullptr);
926
927 Image_AuxiliaryPictureType type = (Image_AuxiliaryPictureType)ERRER_AUXILIARY_PICTURE_TYPE;
928 ret = OH_AuxiliaryPictureInfo_SetType(auxiliaryPictureInfo, type);
929 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
930 }
931
932 /**
933 * @tc.name: OH_AuxiliaryPictureInfo_GetTypeTest001
934 * @tc.desc: Set the type and then get the type. Compare the parameters before and after.
935 * @tc.type: FUNC
936 */
937 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_GetTypeTest001, TestSize.Level1)
938 {
939 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
940 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(&auxiliaryPictureInfo);
941 EXPECT_EQ(ret, IMAGE_SUCCESS);
942 ASSERT_NE(auxiliaryPictureInfo, nullptr);
943
944 Image_AuxiliaryPictureType type = AUXILIARY_PICTURE_TYPE_GAINMAP;
945 Image_AuxiliaryPictureType retType;
946 ret = OH_AuxiliaryPictureInfo_SetType(auxiliaryPictureInfo, type);
947 EXPECT_EQ(ret, IMAGE_SUCCESS);
948 ret = OH_AuxiliaryPictureInfo_GetType(auxiliaryPictureInfo, &retType);
949 EXPECT_EQ(retType, type);
950 EXPECT_EQ(ret, IMAGE_SUCCESS);
951
952 type = AUXILIARY_PICTURE_TYPE_FRAGMENT_MAP;
953 ret = OH_AuxiliaryPictureInfo_SetType(auxiliaryPictureInfo, type);
954 EXPECT_EQ(ret, IMAGE_SUCCESS);
955 ret = OH_AuxiliaryPictureInfo_GetType(auxiliaryPictureInfo, &retType);
956 EXPECT_EQ(retType, type);
957 EXPECT_EQ(ret, IMAGE_SUCCESS);
958
959 OH_AuxiliaryPictureInfo_Release(auxiliaryPictureInfo);
960 }
961
962 /**
963 * @tc.name: OH_AuxiliaryPictureInfo_GetTypeTest002
964 * @tc.desc: Pass in an empty object and return exception.
965 * @tc.type: FUNC
966 */
967 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_GetTypeTest002, TestSize.Level3)
968 {
969 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
970 Image_AuxiliaryPictureType type;
971 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_GetType(auxiliaryPictureInfo, &type);
972 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
973 }
974
975 /**
976 * @tc.name: OH_AuxiliaryPictureInfo_SetSizeTest001
977 * @tc.desc: Pass in valid OH_AuxiliaryPictureInfo object and size, and then return success.
978 * @tc.type: FUNC
979 */
980 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_SetSizeTest001, TestSize.Level1)
981 {
982 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
983 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(&auxiliaryPictureInfo);
984 EXPECT_EQ(ret, IMAGE_SUCCESS);
985 ASSERT_NE(auxiliaryPictureInfo, nullptr);
986
987 Image_Size size;
988 size.height = SIZE_HEIGHT;
989 size.width = SIZE_WIDTH;
990 ret = OH_AuxiliaryPictureInfo_SetSize(auxiliaryPictureInfo, &size);
991 EXPECT_EQ(ret, IMAGE_SUCCESS);
992
993 OH_AuxiliaryPictureInfo_Release(auxiliaryPictureInfo);
994 }
995
996 /**
997 * @tc.name: OH_AuxiliaryPictureInfo_SetSizeTest002
998 * @tc.desc: Pass in an empty object and return exception.
999 * @tc.type: FUNC
1000 */
1001 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_SetSizeTest002, TestSize.Level3)
1002 {
1003 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1004 Image_Size *size = nullptr;
1005
1006 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_SetSize(auxiliaryPictureInfo, size);
1007 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
1008 }
1009
1010 /**
1011 * @tc.name: OH_AuxiliaryPictureInfo_GetSizeTest001
1012 * @tc.desc: Set the size and then get the size. Compare the parameters before and after.
1013 * @tc.type: FUNC
1014 */
1015 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_GetSizeTest001, TestSize.Level1)
1016 {
1017 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1018 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(&auxiliaryPictureInfo);
1019 EXPECT_EQ(ret, IMAGE_SUCCESS);
1020 ASSERT_NE(auxiliaryPictureInfo, nullptr);
1021
1022 Image_Size size;
1023 size.height = SIZE_HEIGHT;
1024 size.width = SIZE_WIDTH;
1025 ret = OH_AuxiliaryPictureInfo_SetSize(auxiliaryPictureInfo, &size);
1026 EXPECT_EQ(ret, IMAGE_SUCCESS);
1027
1028 Image_Size retSize;
1029 ret = OH_AuxiliaryPictureInfo_GetSize(auxiliaryPictureInfo, &retSize);
1030 EXPECT_EQ(retSize.height, SIZE_HEIGHT);
1031 EXPECT_EQ(ret, IMAGE_SUCCESS);
1032
1033 OH_AuxiliaryPictureInfo_Release(auxiliaryPictureInfo);
1034 }
1035
1036 /**
1037 * @tc.name: OH_AuxiliaryPictureInfo_GetSizeTest002
1038 * @tc.desc: Pass in an empty object and return exception.
1039 * @tc.type: FUNC
1040 */
1041 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_GetSizeTest002, TestSize.Level3)
1042 {
1043 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1044 Image_Size retSize;
1045
1046 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_GetSize(auxiliaryPictureInfo, &retSize);
1047 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
1048 }
1049
1050 /**
1051 * @tc.name: OH_AuxiliaryPictureInfo_SetRowStrideTest001
1052 * @tc.desc: Pass in valid OH_AuxiliaryPictureInfo object and RowStride, and then return success.
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_SetRowStrideTest001, TestSize.Level1)
1056 {
1057 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1058 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(&auxiliaryPictureInfo);
1059 EXPECT_EQ(ret, IMAGE_SUCCESS);
1060 ASSERT_NE(auxiliaryPictureInfo, nullptr);
1061
1062 ret = OH_AuxiliaryPictureInfo_SetRowStride(auxiliaryPictureInfo, ROW_STRIDE);
1063 EXPECT_EQ(ret, IMAGE_SUCCESS);
1064
1065 OH_AuxiliaryPictureInfo_Release(auxiliaryPictureInfo);
1066 }
1067
1068 /**
1069 * @tc.name: OH_AuxiliaryPictureInfo_SetRowStrideTest002
1070 * @tc.desc: Pass in an empty object and return exception.
1071 * @tc.type: FUNC
1072 */
1073 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_SetRowStrideTest002, TestSize.Level3)
1074 {
1075 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1076
1077 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_SetRowStride(auxiliaryPictureInfo, ROW_STRIDE);
1078 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
1079 }
1080
1081 /**
1082 * @tc.name: OH_AuxiliaryPictureInfo_GetRowStrideTest001
1083 * @tc.desc: Set the RowStride and then get the RowStride. Compare the parameters before and after.
1084 * @tc.type: FUNC
1085 */
1086 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_GetRowStrideTest001, TestSize.Level1)
1087 {
1088 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1089 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(&auxiliaryPictureInfo);
1090 EXPECT_EQ(ret, IMAGE_SUCCESS);
1091 ASSERT_NE(auxiliaryPictureInfo, nullptr);
1092
1093 ret = OH_AuxiliaryPictureInfo_SetRowStride(auxiliaryPictureInfo, ROW_STRIDE);
1094 EXPECT_EQ(ret, IMAGE_SUCCESS);
1095
1096 uint32_t retRowStride;
1097 ret = OH_AuxiliaryPictureInfo_GetRowStride(auxiliaryPictureInfo, &retRowStride);
1098 EXPECT_EQ(ret, IMAGE_SUCCESS);
1099 EXPECT_EQ(retRowStride, ROW_STRIDE);
1100
1101 OH_AuxiliaryPictureInfo_Release(auxiliaryPictureInfo);
1102 }
1103
1104 /**
1105 * @tc.name: OH_AuxiliaryPictureInfo_GetRowStrideTest002
1106 * @tc.desc: Pass in an empty object and return an exception.
1107 * @tc.type: FUNC
1108 */
1109 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_GetRowStrideTest002, TestSize.Level3)
1110 {
1111 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1112 uint32_t retRowStride;
1113
1114 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_GetRowStride(auxiliaryPictureInfo, &retRowStride);
1115 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
1116 }
1117
1118 /**
1119 * @tc.name: OH_AuxiliaryPictureInfo_SetPixelFormatTest001
1120 * @tc.desc: Pass in valid OH_AuxiliaryPictureInfo object and PixelFormat, and then return success.
1121 * @tc.type: FUNC
1122 */
1123 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_SetPixelFormatTest001, TestSize.Level1)
1124 {
1125 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1126 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(&auxiliaryPictureInfo);
1127 EXPECT_EQ(ret, IMAGE_SUCCESS);
1128 ASSERT_NE(auxiliaryPictureInfo, nullptr);
1129
1130 PIXEL_FORMAT pixelFormat = PIXEL_FORMAT_NV21;
1131 ret = OH_AuxiliaryPictureInfo_SetPixelFormat(auxiliaryPictureInfo, pixelFormat);
1132 EXPECT_EQ(ret, IMAGE_SUCCESS);
1133
1134 OH_AuxiliaryPictureInfo_Release(auxiliaryPictureInfo);
1135 }
1136
1137 /**
1138 * @tc.name: OH_AuxiliaryPictureInfo_SetPixelFormatTest002
1139 * @tc.desc: Pass in an empty object and return an exception.
1140 * @tc.type: FUNC
1141 */
1142 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_SetPixelFormatTest002, TestSize.Level3)
1143 {
1144 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1145 PIXEL_FORMAT pixelFormat = PIXEL_FORMAT_NV21;
1146
1147 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_SetPixelFormat(auxiliaryPictureInfo, pixelFormat);
1148 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
1149 }
1150
1151 /**
1152 * @tc.name: OH_AuxiliaryPictureInfo_GetPixelFormatTest001
1153 * @tc.desc: Set the PixelFormat and then get the PixelFormat. Compare the parameters before and after.
1154 * @tc.type: FUNC
1155 */
1156 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_GetPixelFormatTest001, TestSize.Level1)
1157 {
1158 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1159 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(&auxiliaryPictureInfo);
1160 EXPECT_EQ(ret, IMAGE_SUCCESS);
1161 ASSERT_NE(auxiliaryPictureInfo, nullptr);
1162
1163 PIXEL_FORMAT pixelFormat = PIXEL_FORMAT_NV21;
1164 ret = OH_AuxiliaryPictureInfo_SetPixelFormat(auxiliaryPictureInfo, pixelFormat);
1165 EXPECT_EQ(ret, IMAGE_SUCCESS);
1166
1167 PIXEL_FORMAT retPixelFormat;
1168 ret = OH_AuxiliaryPictureInfo_GetPixelFormat(auxiliaryPictureInfo, &retPixelFormat);
1169 EXPECT_EQ(ret, IMAGE_SUCCESS);
1170 EXPECT_EQ(retPixelFormat, pixelFormat);
1171
1172 OH_AuxiliaryPictureInfo_Release(auxiliaryPictureInfo);
1173 }
1174
1175 /**
1176 * @tc.name: OH_AuxiliaryPictureInfo_GetPixelFormatTest002
1177 * @tc.desc: Pass in an empty object and return an exception.
1178 * @tc.type: FUNC
1179 */
1180 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_GetPixelFormatTest002, TestSize.Level3)
1181 {
1182 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1183 PIXEL_FORMAT retPixelFormat;
1184
1185 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_GetPixelFormat(auxiliaryPictureInfo, &retPixelFormat);
1186 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
1187 }
1188
1189 /**
1190 * @tc.name: OH_AuxiliaryPictureInfo_ReleaseTest001
1191 * @tc.desc: Release a valid object and return success.
1192 * @tc.type: FUNC
1193 */
1194 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_ReleaseTest001, TestSize.Level1)
1195 {
1196 OH_AuxiliaryPictureInfo *auxiliaryPictureInfo = nullptr;
1197 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Create(&auxiliaryPictureInfo);
1198 EXPECT_EQ(ret, IMAGE_SUCCESS);
1199 ASSERT_NE(auxiliaryPictureInfo, nullptr);
1200
1201 ret = OH_AuxiliaryPictureInfo_Release(auxiliaryPictureInfo);
1202 EXPECT_EQ(ret, IMAGE_SUCCESS);
1203 }
1204
1205 /**
1206 * @tc.name: OH_AuxiliaryPictureInfo_ReleaseTest002
1207 * @tc.desc: Pass in an empty object and return an exception.
1208 * @tc.type: FUNC
1209 */
1210 HWTEST_F(PictureNdkTest, OH_AuxiliaryPictureInfo_ReleaseTest002, TestSize.Level3)
1211 {
1212 Image_ErrorCode ret = OH_AuxiliaryPictureInfo_Release(nullptr);
1213 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
1214 }
1215
1216 /**
1217 * @tc.name: OH_PictureNative_SetMetadataTest001
1218 * @tc.desc: test OH_PictureNative_SetMetadata with null pointers.
1219 * @tc.type: FUNC
1220 */
1221 HWTEST_F(PictureNdkTest, OH_PictureNative_SetMetadataTest001, TestSize.Level3)
1222 {
1223 Image_MetadataType metadataType = EXIF_METADATA;
1224 Image_ErrorCode ret = OH_PictureNative_SetMetadata(nullptr, metadataType, nullptr);
1225 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
1226 }
1227
1228 /**
1229 * @tc.name: OH_PictureNative_SetMetadataTest002
1230 * @tc.desc: test OH_PictureNative_SetMetadata with a invalid metadataType.
1231 * @tc.type: FUNC
1232 */
1233 HWTEST_F(PictureNdkTest, OH_PictureNative_SetMetadataTest002, TestSize.Level3)
1234 {
1235 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
1236 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
1237 OH_PictureMetadata *metadata = nullptr;
1238 Image_ErrorCode ret = OH_PictureMetadata_Create(FRAGMENT_METADATA, &metadata);
1239 EXPECT_EQ(ret, IMAGE_SUCCESS);
1240 ret = OH_PictureNative_SetMetadata(picture, INVALID_METADATA, metadata);
1241 EXPECT_EQ(ret, IMAGE_UNSUPPORTED_METADATA);
1242 ret = OH_PictureNative_Release(picture);
1243 EXPECT_EQ(ret, IMAGE_SUCCESS);
1244 }
1245
1246 /**
1247 * @tc.name: OH_PictureNative_GetMetadataTest001
1248 * @tc.desc: test OH_PictureNative_GetMetadata with null pointers.
1249 * @tc.type: FUNC
1250 */
1251 HWTEST_F(PictureNdkTest, OH_PictureNative_GetMetadataTest001, TestSize.Level3)
1252 {
1253 Image_MetadataType metadataType = EXIF_METADATA;
1254 Image_ErrorCode ret = OH_PictureNative_GetMetadata(nullptr, metadataType, nullptr);
1255 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
1256 }
1257
1258 /**
1259 * @tc.name: OH_PictureNative_GetMetadataTest002
1260 * @tc.desc: test OH_PictureNative_GetMetadata with a invalid metadataType.
1261 * @tc.type: FUNC
1262 */
1263 HWTEST_F(PictureNdkTest, OH_PictureNative_GetMetadataTest002, TestSize.Level3)
1264 {
1265 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
1266 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
1267 OH_PictureMetadata *metadata = nullptr;
1268 Image_ErrorCode ret = OH_PictureNative_GetMetadata(picture, INVALID_METADATA, &metadata);
1269 EXPECT_EQ(ret, IMAGE_UNSUPPORTED_METADATA);
1270 ret = OH_PictureNative_Release(picture);
1271 EXPECT_EQ(ret, IMAGE_SUCCESS);
1272 }
1273
1274 /**
1275 * @tc.name: OH_PictureNative_SetAndGetMetadataTest001
1276 * @tc.desc: Tests setting and getting metadata on a native picture.
1277 * The test checks if the metadata is set and get successfully on the picture.
1278 * @tc.type: FUNC
1279 */
1280 HWTEST_F(PictureNdkTest, OH_PictureNative_SetAndGetMetadataTest001, TestSize.Level1)
1281 {
1282 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
1283 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
1284 Image_MetadataType metadataType = EXIF_METADATA;
1285 OH_PictureMetadata *metadata = nullptr;
1286 Image_ErrorCode ret = OH_PictureMetadata_Create(metadataType, &metadata);
1287 EXPECT_EQ(ret, IMAGE_SUCCESS);
1288
1289 ret = OH_PictureNative_SetMetadata(picture, metadataType, metadata);
1290 EXPECT_EQ(ret, IMAGE_SUCCESS);
1291
1292 OH_PictureMetadata *metadataGet = nullptr;
1293 ret = OH_PictureNative_GetMetadata(picture, metadataType, &metadataGet);
1294 EXPECT_EQ(ret, IMAGE_SUCCESS);
1295
1296 ret = OH_PictureNative_Release(picture);
1297 EXPECT_EQ(ret, IMAGE_SUCCESS);
1298 ret = OH_PictureMetadata_Release(metadata);
1299 EXPECT_EQ(ret, IMAGE_SUCCESS);
1300 }
1301
1302 /**
1303 * @tc.name: OH_PictureNative_SetAndGetMetadataTest003
1304 * @tc.desc: Tests setting and getting gif metadata on a native picture.
1305 * The test checks if the metadata is set and get successfully on the picture.
1306 * @tc.type: FUNC
1307 */
1308 HWTEST_F(PictureNdkTest, OH_PictureNative_SetAndGetMetadataTest003, TestSize.Level1)
1309 {
1310 std::vector<Image_AuxiliaryPictureType> auxTypeList = {};
1311 OH_PictureNative *picture = CreateNativePicture(auxTypeList);
1312 Image_MetadataType metadataType = GIF_METADATA;
1313 OH_PictureMetadata *metadata = nullptr;
1314 Image_ErrorCode ret = OH_PictureMetadata_Create(metadataType, &metadata);
1315 EXPECT_EQ(ret, IMAGE_SUCCESS);
1316
1317 ret = OH_PictureNative_SetMetadata(picture, metadataType, metadata);
1318 EXPECT_EQ(ret, IMAGE_SUCCESS);
1319
1320 OH_PictureMetadata *metadataGet = nullptr;
1321 ret = OH_PictureNative_GetMetadata(picture, metadataType, &metadataGet);
1322 EXPECT_EQ(ret, IMAGE_SUCCESS);
1323 EXPECT_NE(metadataGet, nullptr);
1324
1325 ret = OH_PictureNative_Release(picture);
1326 EXPECT_EQ(ret, IMAGE_SUCCESS);
1327 ret = OH_PictureMetadata_Release(metadata);
1328 EXPECT_EQ(ret, IMAGE_SUCCESS);
1329 }
1330 } // namespace Media
1331 } // namespace OHOS
