1 /*
2 * Copyright (C) 2025 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 <iostream>
16 #include <atomic>
17 #include <fstream>
18 #include <thread>
19 #include <queue>
20 #include <string>
21 #include "gtest/gtest.h"
22 #include "image_processing.h"
23 #include "native_color_space_manager.h"
24 #include "nocopyable.h"
25 #include "pixelmap_native.h"
26 #include "native_buffer.h"
27 using namespace std;
28 using namespace OHOS;
29 using namespace testing::ext;
30 namespace {
31 constexpr uint32_t DEFAULT_WIDTH = 3840;
32 constexpr uint32_t DEFAULT_HEIGHT = 2160;
33 constexpr uint32_t PIX_SIZE = DEFAULT_WIDTH * DEFAULT_HEIGHT * 4;
34 uint8_t *g_pixData = nullptr;
35
36 OH_Pixelmap_InitializationOptions *g_createOpts_RGBA = nullptr;
37 OH_Pixelmap_InitializationOptions *g_createOpts_BGRA = nullptr;
38 OH_PixelmapNative *pixelMap_RGBA = nullptr;
39 OH_PixelmapNative *pixelMap_BGRA = nullptr;
InitCreatePixelmapParamRGBA()40 void InitCreatePixelmapParamRGBA()
41 {
42 if (g_createOpts_RGBA == nullptr) {
43 OH_PixelmapInitializationOptions_Create(&g_createOpts_RGBA);
44 OH_PixelmapInitializationOptions_SetWidth(g_createOpts_RGBA, DEFAULT_WIDTH);
45 OH_PixelmapInitializationOptions_SetHeight(g_createOpts_RGBA, DEFAULT_HEIGHT);
46 OH_PixelmapInitializationOptions_SetPixelFormat(g_createOpts_RGBA, NATIVEBUFFER_PIXEL_FMT_RGBA_8888);
47 }
48 }
InitCreatePixelmapParamBGRA()49 void InitCreatePixelmapParamBGRA()
50 {
51 if (g_createOpts_BGRA == nullptr) {
52 OH_PixelmapInitializationOptions_Create(&g_createOpts_BGRA);
53 OH_PixelmapInitializationOptions_SetWidth(g_createOpts_BGRA, DEFAULT_WIDTH);
54 OH_PixelmapInitializationOptions_SetHeight(g_createOpts_BGRA, DEFAULT_HEIGHT);
55 OH_PixelmapInitializationOptions_SetPixelFormat(g_createOpts_BGRA, PIXEL_FORMAT_BGRA_8888);
56 }
57 }
58
59
60 class VpeImageApiTest : public testing::Test {
61 public:
62 // SetUpTestCase: Called before all test cases
63 static void SetUpTestCase(void);
64 // TearDownTestCase: Called after all test case
65 static void TearDownTestCase(void);
66 // SetUp: Called before each test cases
67 void SetUp(void);
68 // TearDown: Called after each test cases
69 void TearDown(void);
70 };
71
72
SetUpTestCase()73 void VpeImageApiTest::SetUpTestCase()
74 {
75 g_pixData = new uint8_t[PIX_SIZE];
76 InitCreatePixelmapParamRGBA();
77 InitCreatePixelmapParamBGRA();
78 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &pixelMap_RGBA);
79 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_BGRA, &pixelMap_BGRA);
80 }
TearDownTestCase()81 void VpeImageApiTest::TearDownTestCase()
82 {
83 if (g_pixData) {
84 delete[] g_pixData;
85 g_pixData = nullptr;
86 }
87 if (g_createOpts_RGBA) {
88 OH_PixelmapInitializationOptions_Release(g_createOpts_RGBA);
89 g_createOpts_RGBA = nullptr;
90 }
91 if (g_createOpts_BGRA) {
92 OH_PixelmapInitializationOptions_Release(g_createOpts_BGRA);
93 g_createOpts_BGRA = nullptr;
94 }
95 }
SetUp()96 void VpeImageApiTest::SetUp()
97 {
98 }
TearDown()99 void VpeImageApiTest::TearDown()
100 {
101 OH_ImageProcessing_DeinitializeEnvironment();
102 }
103
104
105 const ImageProcessing_ColorSpaceInfo CSC_SRC_INFO = {HDR_METADATA_TYPE_NONE,
106 SRGB,
107 PIXEL_FORMAT_RGBA_8888};
108 const ImageProcessing_ColorSpaceInfo CSC_DST_INFO = {HDR_METADATA_TYPE_NONE,
109 DISPLAY_P3,
110 PIXEL_FORMAT_RGBA_8888};
111 const ImageProcessing_ColorSpaceInfo COMPOSE_SRC_INFO = {HDR_METADATA_TYPE_BASE,
112 SRGB,
113 PIXEL_FORMAT_RGBA_8888};
114
115 const ImageProcessing_ColorSpaceInfo COMPOSE_SRC_GAIN_INFO = {HDR_METADATA_TYPE_GAINMAP,
116 SRGB,
117 PIXEL_FORMAT_RGBA_8888};
118 const ImageProcessing_ColorSpaceInfo COMPOSE_DST_INFO = {HDR_METADATA_TYPE_ALTERNATE,
119 BT2020_HLG,
120 PIXEL_FORMAT_RGBA_1010102};
121 const ImageProcessing_ColorSpaceInfo UNSUPPORTED_INFO = {HDR_METADATA_TYPE_NONE,
122 BT601_EBU,
123 PIXEL_FORMAT_BGRA_8888};
124
125 }
126
127 namespace {
128 #ifdef ENABLE_ALL_PROCESS
129 static bool g_suppported = true;
130 #else
131 static bool g_suppported = false;
132 #endif
133
134 /**
135 * @tc.number : VPE_IMAGE_API_TEST_0010
136 * @tc.name : first call OH_ImageProcessing_InitializeEnvironment
137 * @tc.desc : function test
138 */
139 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0010, TestSize.Level0)
140 {
141 ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment();
142 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
143 OH_ImageProcessing_DeinitializeEnvironment();
144 }
145
146 /**
147 * @tc.number : VPE_IMAGE_API_TEST_0020
148 * @tc.name : first call OH_ImageProcessing_DeinitializeEnvironment
149 * @tc.desc : function test
150 */
151 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0020, TestSize.Level0)
152 {
153 ImageProcessing_ErrorCode ret = OH_ImageProcessing_DeinitializeEnvironment();
154 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
155 }
156
157 /**
158 * @tc.number : VPE_IMAGE_API_TEST_0030
159 * @tc.name : first call OH_ImageProcessing_DeinitializeEnvironment after initialize
160 * @tc.desc : function test
161 */
162 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0030, TestSize.Level0)
163 {
164 ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment();
165 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
166 OH_ImageProcessing_DeinitializeEnvironment();
167 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
168 }
169
170 /**
171 * @tc.number : VPE_IMAGE_API_TEST_0040
172 * @tc.name : call OH_ImageProcessing_IsColorSpaceConversionSupported
173 * @tc.desc : function test
174 */
175 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0040, TestSize.Level0)
176 {
177 OH_ImageProcessing_InitializeEnvironment();
178 bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(nullptr, nullptr);
179 ASSERT_FALSE(ret);
180 }
181
182 /**
183 * @tc.number : VPE_IMAGE_API_TEST_0050
184 * @tc.name : call OH_ImageProcessing_IsColorSpaceConversionSupported
185 * @tc.desc : function test
186 */
187 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0050, TestSize.Level0)
188 {
189 OH_ImageProcessing_InitializeEnvironment();
190 bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(&CSC_SRC_INFO, nullptr);
191 ASSERT_FALSE(ret);
192 }
193
194 /**
195 * @tc.number : VPE_IMAGE_API_TEST_0060
196 * @tc.name : call OH_ImageProcessing_IsColorSpaceConversionSupported
197 * @tc.desc : function test
198 */
199 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0060, TestSize.Level0)
200 {
201 OH_ImageProcessing_InitializeEnvironment();
202 bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(nullptr, &CSC_DST_INFO);
203 ASSERT_FALSE(ret);
204 }
205
206 /**
207 * @tc.number : VPE_IMAGE_API_TEST_0070
208 * @tc.name : call OH_ImageProcessing_IsColorSpaceConversionSupported
209 * @tc.desc : function test
210 */
211 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0070, TestSize.Level0)
212 {
213 OH_ImageProcessing_InitializeEnvironment();
214 bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(&CSC_SRC_INFO, &CSC_DST_INFO);
215 if (g_suppported) {
216 ASSERT_TRUE(ret);
217 } else {
218 ASSERT_FALSE(ret);
219 }
220 }
221
222 /**
223 * @tc.number : VPE_IMAGE_API_TEST_0080
224 * @tc.name : call OH_ImageProcessing_IsCompositionSupported
225 * @tc.desc : function test
226 */
227 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0080, TestSize.Level0)
228 {
229 OH_ImageProcessing_InitializeEnvironment();
230 bool ret = OH_ImageProcessing_IsCompositionSupported(nullptr, nullptr, nullptr);
231 ASSERT_FALSE(ret);
232 }
233
234 /**
235 * @tc.number : VPE_IMAGE_API_TEST_0090
236 * @tc.name : call OH_ImageProcessing_IsCompositionSupported
237 * @tc.desc : function test
238 */
239 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0090, TestSize.Level0)
240 {
241 OH_ImageProcessing_InitializeEnvironment();
242 bool ret = OH_ImageProcessing_IsCompositionSupported(&COMPOSE_SRC_INFO, nullptr, nullptr);
243 ASSERT_FALSE(ret);
244 }
245
246 /**
247 * @tc.number : VPE_IMAGE_API_TEST_0100
248 * @tc.name : call OH_ImageProcessing_IsCompositionSupported
249 * @tc.desc : function test
250 */
251 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0100, TestSize.Level0)
252 {
253 OH_ImageProcessing_InitializeEnvironment();
254 bool ret = OH_ImageProcessing_IsCompositionSupported(nullptr, nullptr, &COMPOSE_DST_INFO);
255 ASSERT_FALSE(ret);
256 }
257
258 /**
259 * @tc.number : VPE_IMAGE_API_TEST_0110
260 * @tc.name : call OH_ImageProcessing_IsCompositionSupported
261 * @tc.desc : function test
262 */
263 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0110, TestSize.Level0)
264 {
265 OH_ImageProcessing_InitializeEnvironment();
266 bool ret = OH_ImageProcessing_IsCompositionSupported(nullptr, &COMPOSE_SRC_GAIN_INFO, nullptr);
267 ASSERT_FALSE(ret);
268 }
269
270 /**
271 * @tc.number : VPE_IMAGE_API_TEST_0120
272 * @tc.name : call OH_ImageProcessing_IsCompositionSupported
273 * @tc.desc : function test
274 */
275 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0120, TestSize.Level0)
276 {
277 OH_ImageProcessing_InitializeEnvironment();
278 bool ret = OH_ImageProcessing_IsCompositionSupported(&COMPOSE_SRC_INFO, nullptr, &COMPOSE_DST_INFO);
279 ASSERT_FALSE(ret);
280 }
281
282 /**
283 * @tc.number : VPE_IMAGE_API_TEST_0130
284 * @tc.name : call OH_ImageProcessing_IsCompositionSupported
285 * @tc.desc : function test
286 */
287 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0130, TestSize.Level0)
288 {
289 OH_ImageProcessing_InitializeEnvironment();
290 bool ret = OH_ImageProcessing_IsCompositionSupported(nullptr, &COMPOSE_SRC_GAIN_INFO, &COMPOSE_DST_INFO);
291 ASSERT_FALSE(ret);
292 }
293
294 /**
295 * @tc.number : VPE_IMAGE_API_TEST_0131
296 * @tc.name : call OH_ImageProcessing_IsCompositionSupported
297 * @tc.desc : function test
298 */
299 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0131, TestSize.Level0)
300 {
301 OH_ImageProcessing_InitializeEnvironment();
302 bool ret = OH_ImageProcessing_IsCompositionSupported(&COMPOSE_SRC_INFO, &COMPOSE_SRC_GAIN_INFO, nullptr);
303 ASSERT_FALSE(ret);
304 }
305
306 /**
307 * @tc.number : VPE_IMAGE_API_TEST_0140
308 * @tc.name : call OH_ImageProcessing_IsCompositionSupported
309 * @tc.desc : function test
310 */
311 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0140, TestSize.Level0)
312 {
313 OH_ImageProcessing_InitializeEnvironment();
314 bool ret = OH_ImageProcessing_IsCompositionSupported(&COMPOSE_SRC_INFO, &COMPOSE_SRC_GAIN_INFO, &COMPOSE_DST_INFO);
315 if (g_suppported) {
316 ASSERT_TRUE(ret);
317 } else {
318 ASSERT_FALSE(ret);
319 }
320 }
321
322 /**
323 * @tc.number : VPE_IMAGE_API_TEST_0150
324 * @tc.name : call OH_ImageProcessing_IsDecompositionSupported
325 * @tc.desc : function test
326 */
327 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0150, TestSize.Level0)
328 {
329 OH_ImageProcessing_InitializeEnvironment();
330 bool ret = OH_ImageProcessing_IsDecompositionSupported(nullptr, nullptr, nullptr);
331 ASSERT_FALSE(ret);
332 }
333
334 /**
335 * @tc.number : VPE_IMAGE_API_TEST_0160
336 * @tc.name : call OH_ImageProcessing_IsDecompositionSupported
337 * @tc.desc : function test
338 */
339 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0160, TestSize.Level0)
340 {
341 OH_ImageProcessing_InitializeEnvironment();
342 bool ret = OH_ImageProcessing_IsDecompositionSupported(&COMPOSE_DST_INFO, nullptr, nullptr);
343 ASSERT_FALSE(ret);
344 }
345
346 /**
347 * @tc.number : VPE_IMAGE_API_TEST_0170
348 * @tc.name : call OH_ImageProcessing_IsDecompositionSupported
349 * @tc.desc : function test
350 */
351 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0170, TestSize.Level0)
352 {
353 OH_ImageProcessing_InitializeEnvironment();
354 bool ret = OH_ImageProcessing_IsDecompositionSupported(nullptr, &COMPOSE_SRC_INFO, nullptr);
355 ASSERT_FALSE(ret);
356 }
357
358 /**
359 * @tc.number : VPE_IMAGE_API_TEST_0180
360 * @tc.name : call OH_ImageProcessing_IsDecompositionSupported
361 * @tc.desc : function test
362 */
363 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0180, TestSize.Level0)
364 {
365 OH_ImageProcessing_InitializeEnvironment();
366 bool ret = OH_ImageProcessing_IsDecompositionSupported(nullptr, nullptr, &COMPOSE_SRC_GAIN_INFO);
367 ASSERT_FALSE(ret);
368 }
369
370 /**
371 * @tc.number : VPE_IMAGE_API_TEST_0190
372 * @tc.name : call OH_ImageProcessing_IsDecompositionSupported
373 * @tc.desc : function test
374 */
375 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0190, TestSize.Level0)
376 {
377 OH_ImageProcessing_InitializeEnvironment();
378 bool ret = OH_ImageProcessing_IsDecompositionSupported(&COMPOSE_DST_INFO, nullptr, &COMPOSE_SRC_GAIN_INFO);
379 ASSERT_FALSE(ret);
380 }
381
382 /**
383 * @tc.number : VPE_IMAGE_API_TEST_0200
384 * @tc.name : call OH_ImageProcessing_IsDecompositionSupported
385 * @tc.desc : function test
386 */
387 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0200, TestSize.Level0)
388 {
389 OH_ImageProcessing_InitializeEnvironment();
390 bool ret = OH_ImageProcessing_IsDecompositionSupported(nullptr, &COMPOSE_SRC_INFO, &COMPOSE_SRC_GAIN_INFO);
391 ASSERT_FALSE(ret);
392 }
393
394 /**
395 * @tc.number : VPE_IMAGE_API_TEST_0201
396 * @tc.name : call OH_ImageProcessing_IsDecompositionSupported
397 * @tc.desc : function test
398 */
399 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0201, TestSize.Level0)
400 {
401 OH_ImageProcessing_InitializeEnvironment();
402 bool ret = OH_ImageProcessing_IsDecompositionSupported(&COMPOSE_DST_INFO, &COMPOSE_SRC_INFO, nullptr);
403 ASSERT_FALSE(ret);
404 }
405
406 /**
407 * @tc.number : VPE_IMAGE_API_TEST_0210
408 * @tc.name : call OH_ImageProcessing_IsDecompositionSupported
409 * @tc.desc : function test
410 */
411 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0210, TestSize.Level0)
412 {
413 OH_ImageProcessing_InitializeEnvironment();
414 bool ret = OH_ImageProcessing_IsDecompositionSupported(&COMPOSE_DST_INFO,
415 &COMPOSE_SRC_INFO, &COMPOSE_SRC_GAIN_INFO);
416 if (g_suppported) {
417 ASSERT_TRUE(ret);
418 } else {
419 ASSERT_FALSE(ret);
420 }
421 }
422
423 /**
424 * @tc.number : VPE_IMAGE_API_TEST_0220
425 * @tc.name : call OH_ImageProcessing_IsMetadataGenerationSupported
426 * @tc.desc : function test
427 */
428 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0220, TestSize.Level0)
429 {
430 OH_ImageProcessing_InitializeEnvironment();
431 bool ret = OH_ImageProcessing_IsMetadataGenerationSupported(nullptr);
432 ASSERT_FALSE(ret);
433 }
434
435 /**
436 * @tc.number : VPE_IMAGE_API_TEST_0230
437 * @tc.name : call OH_ImageProcessing_IsMetadataGenerationSupported
438 * @tc.desc : function test
439 */
440 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0230, TestSize.Level0)
441 {
442 OH_ImageProcessing_InitializeEnvironment();
443 const ImageProcessing_ColorSpaceInfo HDR_INFO = {HDR_METADATA_TYPE_ALTERNATE, BT2020_HLG,
444 PIXEL_FORMAT_RGBA_1010102};
445 bool ret = OH_ImageProcessing_IsMetadataGenerationSupported(&HDR_INFO);
446 if (g_suppported) {
447 ASSERT_TRUE(ret);
448 } else {
449 ASSERT_FALSE(ret);
450 }
451 }
452
453 /**
454 * @tc.number : VPE_IMAGE_API_TEST_0240
455 * @tc.name : call OH_ImageProcessing_Create
456 * @tc.desc : function test
457 */
458 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0240, TestSize.Level0)
459 {
460 OH_ImageProcessing_InitializeEnvironment();
461 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(nullptr, INT_MAX);
462 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
463 }
464
465 /**
466 * @tc.number : VPE_IMAGE_API_TEST_0250
467 * @tc.name : call OH_ImageProcessing_Create
468 * @tc.desc : function test
469 */
470 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0250, TestSize.Level0)
471 {
472 OH_ImageProcessing_InitializeEnvironment();
473 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(nullptr,
474 IMAGE_PROCESSING_TYPE_METADATA_GENERATION);
475 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
476 }
477
478 /**
479 * @tc.number : VPE_IMAGE_API_TEST_0260
480 * @tc.name : call OH_ImageProcessing_Create
481 * @tc.desc : function test
482 */
483 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0260, TestSize.Level0)
484 {
485 OH_ImageProcessing_InitializeEnvironment();
486 OH_ImageProcessing* imageProcessor = nullptr;
487 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, INT_MAX);
488 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
489 OH_ImageProcessing_Destroy(imageProcessor);
490 }
491
492 /**
493 * @tc.number : VPE_IMAGE_API_TEST_0270
494 * @tc.name : call OH_ImageProcessing_Create
495 * @tc.desc : function test
496 */
497 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0270, TestSize.Level0)
498 {
499 OH_ImageProcessing_InitializeEnvironment();
500 OH_ImageProcessing* imageProcessor = nullptr;
501 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
502 IMAGE_PROCESSING_TYPE_METADATA_GENERATION);
503 if (g_suppported) {
504 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
505 } else {
506 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
507 }
508 OH_ImageProcessing_Destroy(imageProcessor);
509 }
510
511 /**
512 * @tc.number : VPE_IMAGE_API_TEST_0280
513 * @tc.name : call OH_ImageProcessing_Destroy
514 * @tc.desc : function test
515 */
516 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0280, TestSize.Level0)
517 {
518 OH_ImageProcessing_InitializeEnvironment();
519 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Destroy(nullptr);
520 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
521 }
522
523 /**
524 * @tc.number : VPE_IMAGE_API_TEST_0290
525 * @tc.name : call OH_ImageProcessing_Destroy
526 * @tc.desc : function test
527 */
528 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0290, TestSize.Level0)
529 {
530 OH_ImageProcessing_InitializeEnvironment();
531 OH_ImageProcessing* imageProcessor = nullptr;
532 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
533 IMAGE_PROCESSING_TYPE_METADATA_GENERATION);
534 if (g_suppported) {
535 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
536 ret = OH_ImageProcessing_Destroy(imageProcessor);
537 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
538 }
539 }
540
541 /**
542 * @tc.number : VPE_IMAGE_API_TEST_0450
543 * @tc.name : call OH_ImageProcessing_ConvertColorSpace
544 * @tc.desc : function test
545 */
546 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0450, TestSize.Level0)
547 {
548 OH_ImageProcessing_InitializeEnvironment();
549 ImageProcessing_ErrorCode ret = OH_ImageProcessing_ConvertColorSpace(nullptr,
550 nullptr, nullptr);
551 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
552 }
553
554 /**
555 * @tc.number : VPE_IMAGE_API_TEST_0460
556 * @tc.name : call OH_ImageProcessing_ConvertColorSpace
557 * @tc.desc : function test
558 */
559 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0460, TestSize.Level0)
560 {
561 OH_ImageProcessing_InitializeEnvironment();
562 OH_ImageProcessing* imageProcessor = nullptr;
563 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
564 IMAGE_PROCESSING_TYPE_COLOR_SPACE_CONVERSION);
565 if (g_suppported) {
566 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
567 ret = OH_ImageProcessing_ConvertColorSpace(imageProcessor, nullptr, nullptr);
568 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
569 }
570 OH_ImageProcessing_Destroy(imageProcessor);
571 }
572
573 /**
574 * @tc.number : VPE_IMAGE_API_TEST_0470
575 * @tc.name : call OH_ImageProcessing_ConvertColorSpace
576 * @tc.desc : function test
577 */
578 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0470, TestSize.Level0)
579 {
580 OH_ImageProcessing_InitializeEnvironment();
581 ImageProcessing_ErrorCode ret = OH_ImageProcessing_ConvertColorSpace(nullptr, pixelMap_RGBA, nullptr);
582 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
583 }
584
585 /**
586 * @tc.number : VPE_IMAGE_API_TEST_0480
587 * @tc.name : call OH_ImageProcessing_ConvertColorSpace
588 * @tc.desc : function test
589 */
590 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0480, TestSize.Level0)
591 {
592 OH_ImageProcessing_InitializeEnvironment();
593 ImageProcessing_ErrorCode ret = OH_ImageProcessing_ConvertColorSpace(
594 nullptr, nullptr, pixelMap_RGBA);
595 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
596 }
597
598 /**
599 * @tc.number : VPE_IMAGE_API_TEST_0490
600 * @tc.name : call OH_ImageProcessing_ConvertColorSpace
601 * @tc.desc : function test
602 */
603 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0490, TestSize.Level0)
604 {
605 OH_ImageProcessing_InitializeEnvironment();
606 OH_ImageProcessing* imageProcessor = nullptr;
607 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
608 IMAGE_PROCESSING_TYPE_COLOR_SPACE_CONVERSION);
609 if (g_suppported) {
610 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
611 ret = OH_ImageProcessing_ConvertColorSpace(imageProcessor, nullptr, pixelMap_RGBA);
612 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
613 }
614 OH_ImageProcessing_Destroy(imageProcessor);
615 }
616
617 /**
618 * @tc.number : VPE_IMAGE_API_TEST_0500
619 * @tc.name : call OH_ImageProcessing_ConvertColorSpace
620 * @tc.desc : function test
621 */
622 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0500, TestSize.Level0)
623 {
624 OH_ImageProcessing_InitializeEnvironment();
625 if (g_suppported) {
626 OH_PixelmapNative *src_pixelMap_RGBA = nullptr;
627 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA);
628 OH_PixelmapNative *dst_pixelMap_RGBA = nullptr;
629 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA);
630 ImageProcessing_ErrorCode ret = OH_ImageProcessing_ConvertColorSpace(
631 nullptr, src_pixelMap_RGBA, dst_pixelMap_RGBA);
632 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
633 OH_PixelmapNative_Release(src_pixelMap_RGBA);
634 OH_PixelmapNative_Release(dst_pixelMap_RGBA);
635 }
636 }
637
638 /**
639 * @tc.number : VPE_IMAGE_API_TEST_0530
640 * @tc.name : call OH_ImageProcessing_Compose
641 * @tc.desc : function test
642 */
643 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0530, TestSize.Level0)
644 {
645 OH_ImageProcessing_InitializeEnvironment();
646 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Compose(nullptr, nullptr, nullptr, nullptr);
647 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
648 }
649
650 /**
651 * @tc.number : VPE_IMAGE_API_TEST_0540
652 * @tc.name : call OH_ImageProcessing_Compose
653 * @tc.desc : function test
654 */
655 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0540, TestSize.Level0)
656 {
657 OH_ImageProcessing_InitializeEnvironment();
658 OH_ImageProcessing* imageProcessor = nullptr;
659 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
660 IMAGE_PROCESSING_TYPE_COMPOSITION);
661 if (g_suppported) {
662 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
663 ret = OH_ImageProcessing_Compose(imageProcessor, nullptr, nullptr, nullptr);
664 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
665 }
666 OH_ImageProcessing_Destroy(imageProcessor);
667 }
668
669 /**
670 * @tc.number : VPE_IMAGE_API_TEST_0550
671 * @tc.name : call OH_ImageProcessing_Compose
672 * @tc.desc : function test
673 */
674 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0550, TestSize.Level0)
675 {
676 OH_ImageProcessing_InitializeEnvironment();
677 OH_PixelmapNative *src_pixelMap_RGBA = nullptr;
678 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA);
679 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Compose(nullptr, src_pixelMap_RGBA, nullptr, nullptr);
680 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
681 OH_PixelmapNative_Release(src_pixelMap_RGBA);
682 }
683
684 /**
685 * @tc.number : VPE_IMAGE_API_TEST_0560
686 * @tc.name : call OH_ImageProcessing_Compose
687 * @tc.desc : function test
688 */
689 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0560, TestSize.Level0)
690 {
691 OH_ImageProcessing_InitializeEnvironment();
692 OH_PixelmapNative *src_gain_pixelMap_RGBA = nullptr;
693 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_gain_pixelMap_RGBA);
694 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Compose(nullptr, nullptr, src_gain_pixelMap_RGBA, nullptr);
695 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
696 OH_PixelmapNative_Release(src_gain_pixelMap_RGBA);
697 }
698
699 /**
700 * @tc.number : VPE_IMAGE_API_TEST_0570
701 * @tc.name : call OH_ImageProcessing_Compose
702 * @tc.desc : function test
703 */
704 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0570, TestSize.Level0)
705 {
706 OH_ImageProcessing_InitializeEnvironment();
707 OH_PixelmapNative *dst_pixelMap_RGBA = nullptr;
708 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA);
709 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Compose(nullptr, nullptr, nullptr, dst_pixelMap_RGBA);
710 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
711
712 OH_PixelmapNative_Release(dst_pixelMap_RGBA);
713 }
714
715 /**
716 * @tc.number : VPE_IMAGE_API_TEST_0580
717 * @tc.name : call OH_ImageProcessing_Compose
718 * @tc.desc : function test
719 */
720 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0580, TestSize.Level0)
721 {
722 OH_ImageProcessing_InitializeEnvironment();
723 OH_ImageProcessing* imageProcessor = nullptr;
724 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
725 IMAGE_PROCESSING_TYPE_COMPOSITION);
726 if (g_suppported) {
727 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
728 OH_PixelmapNative *src_pixelMap_RGBA = nullptr;
729 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA);
730 ret = OH_ImageProcessing_Compose(imageProcessor, src_pixelMap_RGBA, nullptr, nullptr);
731 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
732 OH_ImageProcessing_Destroy(imageProcessor);
733 OH_PixelmapNative_Release(src_pixelMap_RGBA);
734 }
735 }
736
737 /**
738 * @tc.number : VPE_IMAGE_API_TEST_0590
739 * @tc.name : call OH_ImageProcessing_Compose
740 * @tc.desc : function test
741 */
742 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0590, TestSize.Level0)
743 {
744 OH_ImageProcessing_InitializeEnvironment();
745 OH_ImageProcessing* imageProcessor = nullptr;
746 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
747 IMAGE_PROCESSING_TYPE_COMPOSITION);
748 if (g_suppported) {
749 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
750 OH_PixelmapNative *src_gain_pixelMap_RGBA = nullptr;
751 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_gain_pixelMap_RGBA);
752 ret = OH_ImageProcessing_Compose(imageProcessor, nullptr, src_gain_pixelMap_RGBA, nullptr);
753 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
754 OH_ImageProcessing_Destroy(imageProcessor);
755 OH_PixelmapNative_Release(src_gain_pixelMap_RGBA);
756 }
757 }
758
759 /**
760 * @tc.number : VPE_IMAGE_API_TEST_0600
761 * @tc.name : call OH_ImageProcessing_Compose
762 * @tc.desc : function test
763 */
764 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0600, TestSize.Level0)
765 {
766 OH_ImageProcessing_InitializeEnvironment();
767 OH_ImageProcessing* imageProcessor = nullptr;
768 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
769 IMAGE_PROCESSING_TYPE_COMPOSITION);
770 if (g_suppported) {
771 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
772 OH_PixelmapNative *dst_pixelMap_RGBA = nullptr;
773 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA);
774 ret = OH_ImageProcessing_Compose(imageProcessor, nullptr, nullptr, dst_pixelMap_RGBA);
775 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
776 OH_ImageProcessing_Destroy(imageProcessor);
777 OH_PixelmapNative_Release(dst_pixelMap_RGBA);
778 }
779 }
780
781 /**
782 * @tc.number : VPE_IMAGE_API_TEST_0610
783 * @tc.name : call OH_ImageProcessing_Compose
784 * @tc.desc : function test
785 */
786 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0610, TestSize.Level0)
787 {
788 OH_ImageProcessing_InitializeEnvironment();
789 OH_ImageProcessing* imageProcessor = nullptr;
790 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
791 IMAGE_PROCESSING_TYPE_COMPOSITION);
792 if (g_suppported) {
793 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
794 OH_PixelmapNative *src_pixelMap_RGBA = nullptr;
795 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA);
796 OH_PixelmapNative *src_gain_pixelMap_RGBA = nullptr;
797 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_gain_pixelMap_RGBA);
798 ret = OH_ImageProcessing_Compose(imageProcessor, src_pixelMap_RGBA, src_gain_pixelMap_RGBA, nullptr);
799 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
800 OH_ImageProcessing_Destroy(imageProcessor);
801 OH_PixelmapNative_Release(src_pixelMap_RGBA);
802 OH_PixelmapNative_Release(src_gain_pixelMap_RGBA);
803 }
804 }
805
806 /**
807 * @tc.number : VPE_IMAGE_API_TEST_0620
808 * @tc.name : call OH_ImageProcessing_Compose
809 * @tc.desc : function test
810 */
811 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0620, TestSize.Level0)
812 {
813 OH_ImageProcessing_InitializeEnvironment();
814 OH_ImageProcessing* imageProcessor = nullptr;
815 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
816 IMAGE_PROCESSING_TYPE_COMPOSITION);
817 if (g_suppported) {
818 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
819 OH_PixelmapNative *src_gain_pixelMap_RGBA = nullptr;
820 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_gain_pixelMap_RGBA);
821 OH_PixelmapNative *dst_pixelMap_RGBA = nullptr;
822 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA);
823 ret = OH_ImageProcessing_Compose(imageProcessor, nullptr, src_gain_pixelMap_RGBA, dst_pixelMap_RGBA);
824 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
825 OH_ImageProcessing_Destroy(imageProcessor);
826 OH_PixelmapNative_Release(src_gain_pixelMap_RGBA);
827 OH_PixelmapNative_Release(dst_pixelMap_RGBA);
828 }
829 }
830
831 /**
832 * @tc.number : VPE_IMAGE_API_TEST_0650
833 * @tc.name : call OH_ImageProcessing_Decompose
834 * @tc.desc : function test
835 */
836 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0650, TestSize.Level0)
837 {
838 OH_ImageProcessing_InitializeEnvironment();
839 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Decompose(nullptr, nullptr, nullptr, nullptr);
840 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
841 }
842
843 /**
844 * @tc.number : VPE_IMAGE_API_TEST_0660
845 * @tc.name : call OH_ImageProcessing_Decompose
846 * @tc.desc : function test
847 */
848 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0660, TestSize.Level0)
849 {
850 OH_ImageProcessing_InitializeEnvironment();
851 OH_ImageProcessing* imageProcessor = nullptr;
852 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
853 IMAGE_PROCESSING_TYPE_DECOMPOSITION);
854 if (g_suppported) {
855 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
856 ret = OH_ImageProcessing_Decompose(imageProcessor, nullptr, nullptr, nullptr);
857 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
858 }
859 OH_ImageProcessing_Destroy(imageProcessor);
860 }
861
862 /**
863 * @tc.number : VPE_IMAGE_API_TEST_0670
864 * @tc.name : call OH_ImageProcessing_Decompose
865 * @tc.desc : function test
866 */
867 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0670, TestSize.Level0)
868 {
869 OH_ImageProcessing_InitializeEnvironment();
870 OH_PixelmapNative *src_pixelMap_RGBA = nullptr;
871 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA);
872 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Decompose(nullptr, src_pixelMap_RGBA, nullptr, nullptr);
873 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
874 OH_PixelmapNative_Release(src_pixelMap_RGBA);
875 }
876
877 /**
878 * @tc.number : VPE_IMAGE_API_TEST_0680
879 * @tc.name : call OH_ImageProcessing_Decompose
880 * @tc.desc : function test
881 */
882 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0680, TestSize.Level0)
883 {
884 OH_ImageProcessing_InitializeEnvironment();
885 OH_PixelmapNative *dst_pixelMap_RGBA = nullptr;
886 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA);
887 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Decompose(nullptr, nullptr, dst_pixelMap_RGBA, nullptr);
888 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
889 OH_PixelmapNative_Release(dst_pixelMap_RGBA);
890 }
891
892 /**
893 * @tc.number : VPE_IMAGE_API_TEST_0690
894 * @tc.name : call OH_ImageProcessing_Decompose
895 * @tc.desc : function test
896 */
897 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0690, TestSize.Level0)
898 {
899 OH_ImageProcessing_InitializeEnvironment();
900 OH_PixelmapNative *dst_gain_pixelMap_RGBA = nullptr;
901 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_gain_pixelMap_RGBA);
902 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Decompose(nullptr, nullptr, nullptr, dst_gain_pixelMap_RGBA);
903 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
904 OH_PixelmapNative_Release(dst_gain_pixelMap_RGBA);
905 }
906
907 /**
908 * @tc.number : VPE_IMAGE_API_TEST_0700
909 * @tc.name : call OH_ImageProcessing_Decompose
910 * @tc.desc : function test
911 */
912 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0700, TestSize.Level0)
913 {
914 OH_ImageProcessing_InitializeEnvironment();
915 OH_ImageProcessing* imageProcessor = nullptr;
916 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
917 IMAGE_PROCESSING_TYPE_DECOMPOSITION);
918 if (g_suppported) {
919 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
920 OH_PixelmapNative *src_pixelMap_RGBA = nullptr;
921 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA);
922 ret = OH_ImageProcessing_Decompose(imageProcessor, src_pixelMap_RGBA, nullptr, nullptr);
923 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
924 OH_PixelmapNative_Release(src_pixelMap_RGBA);
925 }
926 OH_ImageProcessing_Destroy(imageProcessor);
927 }
928
929 /**
930 * @tc.number : VPE_IMAGE_API_TEST_0710
931 * @tc.name : call OH_ImageProcessing_Decompose
932 * @tc.desc : function test
933 */
934 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0710, TestSize.Level0)
935 {
936 OH_ImageProcessing_InitializeEnvironment();
937 OH_ImageProcessing* imageProcessor = nullptr;
938 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
939 IMAGE_PROCESSING_TYPE_DECOMPOSITION);
940 if (g_suppported) {
941 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
942 OH_PixelmapNative *dst_pixelMap_RGBA = nullptr;
943 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA);
944 ret = OH_ImageProcessing_Decompose(imageProcessor, nullptr, dst_pixelMap_RGBA, nullptr);
945 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
946 OH_PixelmapNative_Release(dst_pixelMap_RGBA);
947 }
948 OH_ImageProcessing_Destroy(imageProcessor);
949 }
950
951 /**
952 * @tc.number : VPE_IMAGE_API_TEST_0720
953 * @tc.name : call OH_ImageProcessing_Decompose
954 * @tc.desc : function test
955 */
956 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0720, TestSize.Level0)
957 {
958 OH_ImageProcessing_InitializeEnvironment();
959 OH_ImageProcessing* imageProcessor = nullptr;
960 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
961 IMAGE_PROCESSING_TYPE_DECOMPOSITION);
962 if (g_suppported) {
963 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
964 OH_PixelmapNative *dst_gain_pixelMap_RGBA = nullptr;
965 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_gain_pixelMap_RGBA);
966 ret = OH_ImageProcessing_Decompose(imageProcessor, nullptr, nullptr, dst_gain_pixelMap_RGBA);
967 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
968 OH_PixelmapNative_Release(dst_gain_pixelMap_RGBA);
969 }
970 OH_ImageProcessing_Destroy(imageProcessor);
971 }
972
973 /**
974 * @tc.number : VPE_IMAGE_API_TEST_0730
975 * @tc.name : call OH_ImageProcessing_Decompose
976 * @tc.desc : function test
977 */
978 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0730, TestSize.Level0)
979 {
980 OH_ImageProcessing_InitializeEnvironment();
981 OH_ImageProcessing* imageProcessor = nullptr;
982 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
983 IMAGE_PROCESSING_TYPE_DECOMPOSITION);
984 if (g_suppported) {
985 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
986 OH_PixelmapNative *src_pixelMap_RGBA = nullptr;
987 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA);
988 OH_PixelmapNative *dst_pixelMap_RGBA = nullptr;
989 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA);
990 ret = OH_ImageProcessing_Decompose(imageProcessor, src_pixelMap_RGBA, dst_pixelMap_RGBA, nullptr);
991 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
992 OH_PixelmapNative_Release(src_pixelMap_RGBA);
993 OH_PixelmapNative_Release(dst_pixelMap_RGBA);
994 }
995 OH_ImageProcessing_Destroy(imageProcessor);
996 }
997
998 /**
999 * @tc.number : VPE_IMAGE_API_TEST_0740
1000 * @tc.name : call OH_ImageProcessing_Decompose
1001 * @tc.desc : function test
1002 */
1003 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0740, TestSize.Level0)
1004 {
1005 OH_ImageProcessing_InitializeEnvironment();
1006 OH_ImageProcessing* imageProcessor = nullptr;
1007 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
1008 IMAGE_PROCESSING_TYPE_DECOMPOSITION);
1009 if (g_suppported) {
1010 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
1011 OH_PixelmapNative *dst_pixelMap_RGBA = nullptr;
1012 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA);
1013 OH_PixelmapNative *dst_gain_pixelMap_RGBA = nullptr;
1014 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_gain_pixelMap_RGBA);
1015 ret = OH_ImageProcessing_Decompose(imageProcessor, nullptr,
1016 dst_pixelMap_RGBA, dst_gain_pixelMap_RGBA);
1017 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
1018 OH_PixelmapNative_Release(dst_pixelMap_RGBA);
1019 OH_PixelmapNative_Release(dst_gain_pixelMap_RGBA);
1020 }
1021 OH_ImageProcessing_Destroy(imageProcessor);
1022 }
1023
1024 /**
1025 * @tc.number : VPE_IMAGE_API_TEST_0770
1026 * @tc.name : call OH_ImageProcessing_GenerateMetadata
1027 * @tc.desc : function test
1028 */
1029 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0770, TestSize.Level0)
1030 {
1031 OH_ImageProcessing_InitializeEnvironment();
1032 ImageProcessing_ErrorCode ret = OH_ImageProcessing_GenerateMetadata(nullptr, nullptr);
1033 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE);
1034 }
1035
1036 /**
1037 * @tc.number : VPE_IMAGE_API_TEST_0780
1038 * @tc.name : call OH_ImageProcessing_GenerateMetadata
1039 * @tc.desc : function test
1040 */
1041 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0780, TestSize.Level0)
1042 {
1043 OH_ImageProcessing_InitializeEnvironment();
1044 OH_ImageProcessing* imageProcessor = nullptr;
1045 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
1046 IMAGE_PROCESSING_TYPE_METADATA_GENERATION);
1047 if (g_suppported) {
1048 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
1049 ret = OH_ImageProcessing_GenerateMetadata(imageProcessor, nullptr);
1050 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
1051 }
1052 OH_ImageProcessing_Destroy(imageProcessor);
1053 }
1054
1055 /**
1056 * @tc.number : VPE_IMAGE_API_TEST_0790
1057 * @tc.name : call OH_ImageProcessing_GenerateMetadata by the color space
1058 * of the image is unsupported.
1059 * @tc.desc : function test
1060 */
1061 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0790, TestSize.Level0)
1062 {
1063 OH_ImageProcessing_InitializeEnvironment();
1064 OH_ImageProcessing* imageProcessor = nullptr;
1065 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor,
1066 IMAGE_PROCESSING_TYPE_METADATA_GENERATION);
1067 if (g_suppported) {
1068 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
1069 OH_PixelmapNative *src_pixelMap_BGRA = nullptr;
1070 OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_BGRA, &src_pixelMap_BGRA);
1071 ret = OH_ImageProcessing_GenerateMetadata(imageProcessor, src_pixelMap_BGRA);
1072 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_UNSUPPORTED_PROCESSING);
1073 OH_PixelmapNative_Release(src_pixelMap_BGRA);
1074 }
1075 OH_ImageProcessing_Destroy(imageProcessor);
1076 }
1077
1078 /**
1079 * @tc.number : VPE_IMAGE_API_TEST_0890
1080 * @tc.name : call OH_ImageProcessing_IsColorSpaceConversionSupported
1081 * the the color space conversion is unsupported.
1082 * @tc.desc : function test
1083 */
1084 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0890, TestSize.Level0)
1085 {
1086 OH_ImageProcessing_InitializeEnvironment();
1087 bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(&UNSUPPORTED_INFO, &CSC_DST_INFO);
1088 if (g_suppported) {
1089 ASSERT_FALSE(ret);
1090 }
1091 }
1092
1093 /**
1094 * @tc.number : VPE_IMAGE_API_TEST_0900
1095 * @tc.name : call OH_ImageProcessing_IsCompositionSupported
1096 * the the color space conversion is unsupported.
1097 * @tc.desc : function test
1098 */
1099 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0900, TestSize.Level0)
1100 {
1101 OH_ImageProcessing_InitializeEnvironment();
1102 bool ret = OH_ImageProcessing_IsCompositionSupported(&UNSUPPORTED_INFO,
1103 &COMPOSE_SRC_GAIN_INFO, &COMPOSE_DST_INFO);
1104 if (g_suppported) {
1105 ASSERT_FALSE(ret);
1106 }
1107 }
1108
1109 /**
1110 * @tc.number : VPE_IMAGE_API_TEST_0910
1111 * @tc.name : call OH_ImageProcessing_IsDecompositionSupported
1112 * the the color space conversion is unsupported.
1113 * @tc.desc : function test
1114 */
1115 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0910, TestSize.Level0)
1116 {
1117 OH_ImageProcessing_InitializeEnvironment();
1118 bool ret = OH_ImageProcessing_IsDecompositionSupported(&UNSUPPORTED_INFO,
1119 &COMPOSE_SRC_INFO, &COMPOSE_SRC_GAIN_INFO);
1120 if (g_suppported) {
1121 ASSERT_FALSE(ret);
1122 }
1123 }
1124
1125 /**
1126 * @tc.number : VPE_IMAGE_API_TEST_0920
1127 * @tc.name : call OH_ImageProcessing_IsMetadataGenerationSupported
1128 * the the color space conversion is unsupported.
1129 * @tc.desc : function test
1130 */
1131 HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0920, TestSize.Level0)
1132 {
1133 OH_ImageProcessing_InitializeEnvironment();
1134 bool ret = OH_ImageProcessing_IsMetadataGenerationSupported(&UNSUPPORTED_INFO);
1135 if (g_suppported) {
1136 ASSERT_FALSE(ret);
1137 }
1138 }
1139 }