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 "image_effect_capi_unittest.h"
17#include "image_effect.h"
18#include "image_effect_filter.h"
19#include "pixelmap_native_impl.h"
20#include "efilter_factory.h"
21#include "brightness_efilter.h"
22#include "contrast_efilter.h"
23#include "test_common.h"
24#include "native_window.h"
25#include "external_loader.h"
26#include "crop_efilter.h"
27#include "test_pixel_map_utils.h"
28
29#define MAX_TEST_ADD_EFILTE_NUMS 120
30
31using namespace testing::ext;
32using ::testing::A;
33using ::testing::InSequence;
34using ::testing::Mock;
35using namespace OHOS::Media::Effect::Test;
36
37static std::string g_jpgHdrPath;
38
39namespace {
40    constexpr uint32_t CROP_FACTOR = 2;
41}
42
43namespace OHOS {
44namespace Media {
45namespace Effect {
46void ImageEffectCApiUnittest::SetUpTestCase()
47{
48    g_jpgHdrPath = std::string("/data/test/resource/image_effect_hdr_test1.jpg");
49    consumerSurface_ = Surface::CreateSurfaceAsConsumer("UnitTest");
50    sptr<IBufferProducer> producer = consumerSurface_->GetProducer();
51    ohSurface_ = Surface::CreateSurfaceAsProducer(producer);
52    nativeWindow_ = CreateNativeWindowFromSurface(&ohSurface_);
53}
54
55void ImageEffectCApiUnittest::TearDownTestCase()
56{
57    if (nativeWindow_ != nullptr) {
58        DestoryNativeWindow(nativeWindow_);
59        nativeWindow_ = nullptr;
60    }
61    consumerSurface_ = nullptr;
62    ohSurface_ = nullptr;
63}
64
65void ImageEffectCApiUnittest::SetUp()
66{
67    mockPixelMap_ = std::make_shared<MockPixelMap>();
68    pixelmapNative_ = new OH_PixelmapNative(mockPixelMap_);
69    ExternLoader::Instance()->InitExt();
70    EFilterFactory::Instance()->functions_.clear();
71    EFilterFactory::Instance()->RegisterEFilter<BrightnessEFilter>(BRIGHTNESS_EFILTER);
72    EFilterFactory::Instance()->RegisterEFilter<ContrastEFilter>(CONTRAST_EFILTER);
73    EFilterFactory::Instance()->RegisterEFilter<CropEFilter>(CROP_EFILTER);
74    EFilterFactory::Instance()->delegates_.clear();
75    filterInfo_ = OH_EffectFilterInfo_Create();
76    OH_EffectFilterInfo_SetFilterName(filterInfo_, BRIGHTNESS_EFILTER);
77    ImageEffect_BufferType bufferTypes[] = { ImageEffect_BufferType::EFFECT_BUFFER_TYPE_PIXEL };
78    OH_EffectFilterInfo_SetSupportedBufferTypes(filterInfo_, sizeof(bufferTypes) / sizeof(ImageEffect_BufferType),
79        bufferTypes);
80    ImageEffect_Format formats[] = { ImageEffect_Format::EFFECT_PIXEL_FORMAT_RGBA8888,
81        ImageEffect_Format::EFFECT_PIXEL_FORMAT_NV12, ImageEffect_Format::EFFECT_PIXEL_FORMAT_NV21};
82    OH_EffectFilterInfo_SetSupportedFormats(filterInfo_, sizeof(formats) / sizeof(ImageEffect_Format), formats);
83}
84
85void ImageEffectCApiUnittest::TearDown()
86{
87    delete pixelmapNative_;
88    pixelmapNative_ = nullptr;
89    mockPixelMap_ = nullptr;
90    if (filterInfo_ != nullptr) {
91        OH_EffectFilterInfo_Release(filterInfo_);
92        filterInfo_ = nullptr;
93    }
94}
95
96/**
97 * Feature: ImageEffect
98 * Function: Test image_effect capi unittest example
99 * SubFunction: NA
100 * FunctionPoints: NA
101 * EnvConditions: NA
102 * CaseDescription: Test image_effect capi unittest example
103 */
104HWTEST_F(ImageEffectCApiUnittest, Image_effect_capi_unittest_001, TestSize.Level1)
105{
106    InSequence s;
107
108    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
109    ASSERT_NE(imageEffect, nullptr);
110
111    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
112    ASSERT_NE(filter, nullptr);
113
114    ImageEffect_Any value;
115    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
116    value.dataValue.floatValue = 100.f;
117    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
118    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
119
120    errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
121    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
122
123    errorCode = OH_ImageEffect_Start(imageEffect);
124    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
125
126    errorCode = OH_ImageEffect_Release(imageEffect);
127    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
128}
129
130/**
131 * Feature: ImageEffect
132 * Function: Test OH_ImageEffect_Create with normal parameter
133 * SubFunction: NA
134 * FunctionPoints: NA
135 * EnvConditions: NA
136 * CaseDescription: Test OH_ImageEffect_Create with normal parameter
137 */
138HWTEST_F(ImageEffectCApiUnittest, OHImageEffectCreate001, TestSize.Level1)
139{
140    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectCreate001 start";
141
142    OH_ImageEffect *nativeImageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
143    ASSERT_NE(nativeImageEffect, nullptr) << "OH_ImageEffect_Create failed";
144
145    GTEST_LOG_(INFO) << "OHImageEffectCreate001 success! result: " << nativeImageEffect;
146    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectCreate001 END";
147}
148
149/**
150 * Feature: ImageEffect
151 * Function: Test OH_ImageEffect_Create with empty parameter
152 * SubFunction: NA
153 * FunctionPoints: NA
154 * EnvConditions: NA
155 * CaseDescription: Test OH_ImageEffect_Create with empty parameter
156 */
157HWTEST_F(ImageEffectCApiUnittest, OHImageEffectCreate002, TestSize.Level1)
158{
159    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectCreate002 start";
160
161    OH_ImageEffect *nativeImageEffect = OH_ImageEffect_Create(nullptr);
162    ASSERT_NE(nativeImageEffect, nullptr) << "OH_ImageEffect_Create failed";
163
164    GTEST_LOG_(INFO) << "OHImageEffectCreate002 success! result: " << nativeImageEffect;
165    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectCreate002 END";
166}
167
168/**
169 * Feature: ImageEffect
170 * Function: Test OH_ImageEffect_Configure with normal parameter
171 * SubFunction: NA
172 * FunctionPoints: NA
173 * EnvConditions: NA
174 * CaseDescription: Test OH_ImageEffect_Configure with normal parameter
175 */
176HWTEST_F(ImageEffectCApiUnittest, OHImageEffectConfigure001, TestSize.Level1)
177{
178    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectConfigure001 start";
179
180    OH_ImageEffect *nativeImageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
181    const char *key = "runningType";
182    ImageEffect_Any value;
183    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32;
184    value.dataValue.int32Value = 2;
185    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Configure(nativeImageEffect, key, &value);
186    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Configure failed";
187
188    GTEST_LOG_(INFO) << "OHImageEffectConfigure001 success! result: " << errorCode;
189    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectConfigure001 END";
190}
191
192/**
193 * Feature: ImageEffect
194 * Function: Test OH_ImageEffect_Configure with all empty parameter
195 * SubFunction: NA
196 * FunctionPoints: NA
197 * EnvConditions: NA
198 * CaseDescription: Test OH_ImageEffect_Configure with all empty parameter
199 */
200HWTEST_F(ImageEffectCApiUnittest, OHImageEffectConfigure002, TestSize.Level1)
201{
202    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectConfigure002 start";
203
204    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Configure(nullptr, nullptr, nullptr);
205    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Configure failed";
206
207    GTEST_LOG_(INFO) << "OHImageEffectConfigure002 success! result: " << errorCode;
208    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectConfigure002 END";
209}
210
211/**
212 * Feature: ImageEffect
213 * Function: Test OH_ImageEffect_Configure with empty OH_ImageEffect
214 * SubFunction: NA
215 * FunctionPoints: NA
216 * EnvConditions: NA
217 * CaseDescription: Test OH_ImageEffect_Configure with empty OH_ImageEffect
218 */
219HWTEST_F(ImageEffectCApiUnittest, OHImageEffectConfigure003, TestSize.Level1)
220{
221    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectConfigure003 start";
222
223    const char *key = KEY_FILTER_INTENSITY;
224    ImageEffect_Any value;
225    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32;
226    value.dataValue.int32Value = 1;
227    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Configure(nullptr, key, &value);
228    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Configure failed";
229
230    GTEST_LOG_(INFO) << "OHImageEffectConfigure003 success! result: " << errorCode;
231    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectConfigure003 END";
232}
233
234/**
235 * Feature: ImageEffect
236 * Function: Test OH_EffectFilter_Create with normal parameter
237 * SubFunction: NA
238 * FunctionPoints: NA
239 * EnvConditions: NA
240 * CaseDescription: Test OH_EffectFilter_Create with normal parameter
241 */
242HWTEST_F(ImageEffectCApiUnittest, OHEFilterCreate001, TestSize.Level1)
243{
244    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterCreate001 start";
245
246    OH_EffectFilter *nativeEFilter = OH_EffectFilter_Create(BRIGHTNESS_EFILTER);
247    ASSERT_NE(nativeEFilter, nullptr) << "OH_EffectFilter_Create failed";
248
249    GTEST_LOG_(INFO) << "OHEFilterCreate001 success! result: " << nativeEFilter;
250    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterCreate001 END";
251}
252
253/**
254 * Feature: ImageEffect
255 * Function: Test OH_EffectFilter_Create with not exist parameter
256 * SubFunction: NA
257 * FunctionPoints: NA
258 * EnvConditions: NA
259 * CaseDescription: Test OH_EffectFilter_Create with not exist parameter
260 */
261HWTEST_F(ImageEffectCApiUnittest, OHEFilterCreate002, TestSize.Level1)
262{
263    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterCreate002 start";
264
265    OH_EffectFilter *nativeEFilter = OH_EffectFilter_Create("TestEFilter");
266    ASSERT_EQ(nativeEFilter, nullptr) << "OH_EffectFilter_Create failed";
267
268    GTEST_LOG_(INFO) << "OHEFilterCreate002 success! result: " << nativeEFilter;
269    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterCreate002 END";
270}
271
272/**
273 * Feature: ImageEffect
274 * Function: Test OH_EffectFilter_Create with empty parameter
275 * SubFunction: NA
276 * FunctionPoints: NA
277 * EnvConditions: NA
278 * CaseDescription: Test OH_EffectFilter_Create with empty parameter
279 */
280HWTEST_F(ImageEffectCApiUnittest, OHEFilterCreate003, TestSize.Level1)
281{
282    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterCreate003 start";
283
284    OH_EffectFilter *nativeEFilter = OH_EffectFilter_Create(nullptr);
285    ASSERT_EQ(nativeEFilter, nullptr) << "OH_EffectFilter_Create failed";
286
287    GTEST_LOG_(INFO) << "OHEFilterCreate003 success! result: " << nativeEFilter;
288    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterCreate003 END";
289}
290
291/**
292 * Feature: ImageEffect
293 * Function: Test OH_ImageEffect_AddFilter with normal parameter
294 * SubFunction: NA
295 * FunctionPoints: NA
296 * EnvConditions: NA
297 * CaseDescription: Test OH_ImageEffect_AddFilter with normal parameter
298 */
299HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter001, TestSize.Level1)
300{
301    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter001 start";
302
303    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
304    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
305    ASSERT_NE(filter, nullptr) << "OH_ImageEffect_AddFilter failed";
306
307    GTEST_LOG_(INFO) << "OHImageEffectAddFilter001 success! result: " << filter;
308    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter001 END";
309}
310
311/**
312 * Feature: ImageEffect
313 * Function: Test OH_ImageEffect_AddFilter with all empty parameter
314 * SubFunction: NA
315 * FunctionPoints: NA
316 * EnvConditions: NA
317 * CaseDescription: Test OH_ImageEffect_AddFilter with all empty parameter
318 */
319HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter002, TestSize.Level1)
320{
321    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter002 start";
322
323    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(nullptr, nullptr);
324    ASSERT_EQ(filter, nullptr) << "OH_ImageEffect_AddFilter failed";
325
326    GTEST_LOG_(INFO) << "OHImageEffectAddFilter002 success! result: " << filter;
327    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter002 END";
328}
329
330/**
331 * Feature: ImageEffect
332 * Function: Test OH_ImageEffect_AddFilter with empty OH_ImageEffect parameter
333 * SubFunction: NA
334 * FunctionPoints: NA
335 * EnvConditions: NA
336 * CaseDescription: Test OH_ImageEffect_AddFilter with empty OH_ImageEffect parameter
337 */
338HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter003, TestSize.Level1)
339{
340    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter003 start";
341
342    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(nullptr, BRIGHTNESS_EFILTER);
343    ASSERT_EQ(filter, nullptr) << "OH_ImageEffect_AddFilter failed";
344
345    GTEST_LOG_(INFO) << "OHImageEffectAddFilter003 success! result: " << filter;
346    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter003 END";
347}
348
349/**
350 * Feature: ImageEffect
351 * Function: Test OH_ImageEffect_AddFilter with empty OH_EffectFilter parameter
352 * SubFunction: NA
353 * FunctionPoints: NA
354 * EnvConditions: NA
355 * CaseDescription: Test OH_ImageEffect_AddFilter with empty OH_EffectFilter parameter
356 */
357HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter004, TestSize.Level1)
358{
359    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter004 start";
360
361    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
362    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, nullptr);
363    ASSERT_EQ(filter, nullptr) << "OH_ImageEffect_AddFilter failed";
364
365    GTEST_LOG_(INFO) << "OHImageEffectAddFilter004 success! result: " << filter;
366    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter004 END";
367}
368
369/**
370 * Feature: ImageEffect
371 * Function: Test OH_ImageEffect_AddFilter with not exist OH_EffectFilter parameter
372 * SubFunction: NA
373 * FunctionPoints: NA
374 * EnvConditions: NA
375 * CaseDescription: Test OH_ImageEffect_AddFilter with not exist OH_EffectFilter parameter
376 */
377HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter005, TestSize.Level1)
378{
379    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter005 start";
380
381    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
382    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, "TestEFilter");
383    ASSERT_EQ(filter, nullptr) << "OH_ImageEffect_AddFilter failed";
384
385    GTEST_LOG_(INFO) << "OHImageEffectAddFilter005 success! result: " << filter;
386    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter005 END";
387}
388
389/**
390 * Feature: ImageEffect
391 * Function: Test OH_ImageEffect_AddFilter out of max nums
392 * SubFunction: NA
393 * FunctionPoints: NA
394 * EnvConditions: NA
395 * CaseDescription: Test OH_ImageEffect_AddFilter out of max nums
396 */
397HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter006, TestSize.Level1)
398{
399    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter006 start";
400
401    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
402    OH_EffectFilter *filter = nullptr;
403    for (int i = 0; i < MAX_TEST_ADD_EFILTE_NUMS; i++) {
404        filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
405    }
406    filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
407    ASSERT_EQ(filter, nullptr) << "OH_ImageEffect_AddFilter failed";
408
409    GTEST_LOG_(INFO) << "OHImageEffectAddFilter006 success! result: " << filter;
410    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectAddFilter006 END";
411}
412
413/**
414 * Feature: ImageEffect
415 * Function: Test OH_ImageEffect_RemoveFilter with normal parameter
416 * SubFunction: NA
417 * FunctionPoints: NA
418 * EnvConditions: NA
419 * CaseDescription: Test OH_ImageEffect_RemoveFilter with normal parameter
420 */
421HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRemoveFilter001, TestSize.Level1)
422{
423    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRemoveFilter001 start";
424
425    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
426    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
427    GTEST_LOG_(INFO) << "OHImageEffectRemoveFilter001 OH_ImageEffect_AddFilter success! filter: " << filter;
428    int32_t result = OH_ImageEffect_RemoveFilter(imageEffect, BRIGHTNESS_EFILTER);
429    ASSERT_EQ(result, 1) << "OH_ImageEffect_RemoveFilter failed";
430
431    GTEST_LOG_(INFO) << "OHImageEffectRemoveFilter001 success! result: " << result;
432    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRemoveFilter001 END";
433}
434
435/**
436 * Feature: ImageEffect
437 * Function: Test OH_ImageEffect_RemoveFilter with all empty parameter
438 * SubFunction: NA
439 * FunctionPoints: NA
440 * EnvConditions: NA
441 * CaseDescription: Test OH_ImageEffect_RemoveFilter with all empty parameter
442 */
443HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRemoveFilter002, TestSize.Level1)
444{
445    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRemoveFilter002 start";
446
447    int32_t result = OH_ImageEffect_RemoveFilter(nullptr, nullptr);
448    ASSERT_EQ(result, 0) << "OH_ImageEffect_RemoveFilter failed";
449
450    GTEST_LOG_(INFO) << "OHImageEffectRemoveFilter002 success! result: " << result;
451    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRemoveFilter002 END";
452}
453
454/**
455 * Feature: ImageEffect
456 * Function: Test OH_ImageEffect_RemoveFilter with empty OH_ImageEffect parameter
457 * SubFunction: NA
458 * FunctionPoints: NA
459 * EnvConditions: NA
460 * CaseDescription: Test OH_ImageEffect_RemoveFilter with empty OH_ImageEffect parameter
461 */
462HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRemoveFilter003, TestSize.Level1)
463{
464    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRemoveFilter003 start";
465
466    int32_t result = OH_ImageEffect_RemoveFilter(nullptr, BRIGHTNESS_EFILTER);
467    ASSERT_EQ(result, 0) << "OH_ImageEffect_RemoveFilter failed";
468
469    GTEST_LOG_(INFO) << "OHImageEffectRemoveFilter003 success! result: " << result;
470    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRemoveFilter003 END";
471}
472
473/**
474 * Feature: ImageEffect
475 * Function: Test OH_ImageEffect_RemoveFilter with empty OH_EffectFilter parameter
476 * SubFunction: NA
477 * FunctionPoints: NA
478 * EnvConditions: NA
479 * CaseDescription: Test OH_ImageEffect_RemoveFilter with empty OH_EffectFilter parameter
480 */
481HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRemoveFilter004, TestSize.Level1)
482{
483    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRemoveFilter004 start";
484
485    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
486    int32_t result = OH_ImageEffect_RemoveFilter(imageEffect, nullptr);
487    ASSERT_EQ(result, 0) << "OH_ImageEffect_RemoveFilter failed";
488
489    GTEST_LOG_(INFO) << "OHImageEffectRemoveFilter004 success! result: " << result;
490    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRemoveFilter004 END";
491}
492
493/**
494 * Feature: ImageEffect
495 * Function: Test OH_ImageEffect_RemoveFilter with not exist OH_EffectFilter parameter
496 * SubFunction: NA
497 * FunctionPoints: NA
498 * EnvConditions: NA
499 * CaseDescription: Test OH_ImageEffect_RemoveFilter with not exist OH_EffectFilter parameter
500 */
501HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRemoveFilter005, TestSize.Level1)
502{
503    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRemoveFilter005 start";
504
505    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
506    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
507    GTEST_LOG_(INFO) << "OHImageEffectRemoveFilter005 OH_ImageEffect_AddFilter success! filter: " << filter;
508    int32_t result = OH_ImageEffect_RemoveFilter(imageEffect, "TestEFilter");
509    ASSERT_EQ(result, 0) << "OH_ImageEffect_RemoveFilter failed";
510
511    GTEST_LOG_(INFO) << "OHImageEffectRemoveFilter005 success! result: " << result;
512    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRemoveFilter005 END";
513}
514
515/**
516 * Feature: ImageEffect
517 * Function: Test Add Remove Replace Filter
518 * SubFunction: NA
519 * FunctionPoints: NA
520 * EnvConditions: NA
521 * CaseDescription: Test Add Remove Replace Filter
522 */
523HWTEST_F(ImageEffectCApiUnittest, OHImageEffectCRUDFilter001, TestSize.Level1)
524{
525    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
526    ASSERT_NE(imageEffect, nullptr);
527
528    OH_EffectFilter *contrastFilter = OH_EffectFilter_Create(CONTRAST_EFILTER);
529    ASSERT_NE(contrastFilter, nullptr);
530    OH_EffectFilter *brightnessFilter = OH_EffectFilter_Create(BRIGHTNESS_EFILTER);
531    ASSERT_NE(brightnessFilter, nullptr);
532
533    // 0: contrastFilter, 1: brightnessFilter, 2: cropFilter
534    ImageEffect_ErrorCode errorCode = OH_ImageEffect_AddFilterByFilter(imageEffect, contrastFilter);
535    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
536    OH_EffectFilter *cropFilter = OH_ImageEffect_InsertFilter(imageEffect, 1, CROP_EFILTER);
537    ASSERT_NE(cropFilter, nullptr);
538    errorCode = OH_ImageEffect_InsertFilterByFilter(imageEffect, 1, brightnessFilter);
539    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
540    int32_t filterCnt = OH_ImageEffect_GetFilterCount(imageEffect);
541    ASSERT_EQ(filterCnt, 3);
542
543    // 0: brightnessFilter1, 1: brightnessFilter, 2: cropFilter
544    OH_EffectFilter *brightnessFilter1 = OH_ImageEffect_ReplaceFilter(imageEffect, 0, BRIGHTNESS_EFILTER);
545    ASSERT_NE(brightnessFilter1, nullptr);
546    filterCnt = OH_ImageEffect_GetFilterCount(imageEffect);
547    ASSERT_EQ(filterCnt, 3);
548
549    // 0: brightnessFilter, 1: contrastFilter, 2: cropFilter
550    errorCode = OH_ImageEffect_ReplaceFilterByFilter(imageEffect, 1, contrastFilter);
551    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
552    errorCode = OH_ImageEffect_ReplaceFilterByFilter(imageEffect, 0, brightnessFilter);
553    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
554    filterCnt = OH_ImageEffect_GetFilterCount(imageEffect);
555    ASSERT_EQ(filterCnt, 3);
556
557    // 0: contrastFilter
558    int32_t removeNum = OH_ImageEffect_RemoveFilter(imageEffect, BRIGHTNESS_EFILTER);
559    ASSERT_EQ(removeNum, 1);
560    errorCode = OH_ImageEffect_RemoveFilterByIndex(imageEffect, 2);
561    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
562    errorCode = OH_ImageEffect_RemoveFilterByIndex(imageEffect, 1);
563    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
564    filterCnt = OH_ImageEffect_GetFilterCount(imageEffect);
565    ASSERT_EQ(filterCnt, 1);
566
567    errorCode = OH_ImageEffect_Release(imageEffect);
568    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
569
570    errorCode = OH_EffectFilter_Release(contrastFilter);
571    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
572    errorCode = OH_EffectFilter_Release(brightnessFilter);
573    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
574}
575
576/**
577 * Feature: ImageEffect
578 * Function: Test OH_EffectFilter_SetValue with normal parameter
579 * SubFunction: NA
580 * FunctionPoints: NA
581 * EnvConditions: NA
582 * CaseDescription: Test OH_EffectFilter_SetValue with normal parameter
583 */
584HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue001, TestSize.Level1)
585{
586    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue001 start";
587    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
588    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
589    const char *key = KEY_FILTER_INTENSITY;
590    ImageEffect_Any value;
591    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
592    value.dataValue.floatValue = static_cast<float>(12);
593    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, key, &value);
594    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_SetValue failed";
595
596    GTEST_LOG_(INFO) << "OHEFilterSetValue001 success! result: " << errorCode;
597    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue001 END";
598}
599
600/**
601 * Feature: ImageEffect
602 * Function: Test OH_EffectFilter_SetValue with all empty parameter
603 * SubFunction: NA
604 * FunctionPoints: NA
605 * EnvConditions: NA
606 * CaseDescription: Test OH_EffectFilter_SetValue with all empty parameter
607 */
608HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue002, TestSize.Level1)
609{
610    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue002 start";
611
612    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(nullptr, nullptr, nullptr);
613    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_SetValue failed";
614
615    GTEST_LOG_(INFO) << "OHEFilterSetValue002 success! result: " << errorCode;
616    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue002 END";
617}
618
619/**
620 * Feature: ImageEffect
621 * Function: Test OH_EffectFilter_SetValue with unexpected ImageEffect_Any.dataType parameter
622 * SubFunction: NA
623 * FunctionPoints: NA
624 * EnvConditions: NA
625 * CaseDescription: Test OH_EffectFilter_SetValue with unexpected ImageEffect_Any.dataType parameter
626 */
627HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue003, TestSize.Level1)
628{
629    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue003 start";
630
631    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
632    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
633    const char *key = KEY_FILTER_INTENSITY;
634    ImageEffect_Any value;
635    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_UNKNOWN;
636    value.dataValue.charValue = 'A';
637    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, key, &value);
638    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_SetValue failed";
639
640    GTEST_LOG_(INFO) << "OHEFilterSetValue003 success! result: " << errorCode;
641    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue003 END";
642}
643
644/**
645 * Feature: ImageEffect
646 * Function: Test OH_EffectFilter_SetValue with not exist key parameter
647 * SubFunction: NA
648 * FunctionPoints: NA
649 * EnvConditions: NA
650 * CaseDescription: Test OH_EffectFilter_SetValue with not exist key parameter
651 */
652HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue004, TestSize.Level1)
653{
654    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue004 start";
655
656    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
657    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
658    const char *key = "test";
659    ImageEffect_Any value;
660    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
661    value.dataValue.floatValue = static_cast<float>(12);
662    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, key, &value);
663    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_SetValue failed";
664
665    GTEST_LOG_(INFO) << "OHEFilterSetValue004 success! result: " << errorCode;
666    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue004 END";
667}
668
669/**
670 * Feature: ImageEffect
671 * Function: Test OH_EffectFilter_SetValue with empty key parameter
672 * SubFunction: NA
673 * FunctionPoints: NA
674 * EnvConditions: NA
675 * CaseDescription: Test OH_EffectFilter_SetValue with empty key parameter
676 */
677HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue005, TestSize.Level1)
678{
679    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue005 start";
680
681    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
682    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
683    ImageEffect_Any value;
684    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
685    value.dataValue.floatValue = static_cast<float>(12);
686    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, nullptr, &value);
687    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_SetValue failed";
688
689    GTEST_LOG_(INFO) << "OHEFilterSetValue005 success! result: " << errorCode;
690    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue005 END";
691}
692
693/**
694 * Feature: ImageEffect
695 * Function: Test OH_EffectFilter_SetValue with empty ImageEffect_Any parameter
696 * SubFunction: NA
697 * FunctionPoints: NA
698 * EnvConditions: NA
699 * CaseDescription: Test OH_EffectFilter_SetValue with empty ImageEffect_Any parameter
700 */
701HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue006, TestSize.Level1)
702{
703    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue006 start";
704
705    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
706    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
707    const char *key = KEY_FILTER_INTENSITY;
708    ImageEffect_Any value;
709    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, key, &value);
710    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_SetValue failed";
711
712    GTEST_LOG_(INFO) << "OHEFilterSetValue006 success! result: " << errorCode;
713    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterSetValue006 END";
714}
715
716/**
717 * Feature: ImageEffect
718 * Function: Test OH_EffectFilter_GetValue with normal parameter
719 * SubFunction: NA
720 * FunctionPoints: NA
721 * EnvConditions: NA
722 * CaseDescription: Test OH_EffectFilter_GetValue with normal parameter
723 */
724HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue001, TestSize.Level1)
725{
726    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue001 start";
727
728    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
729    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
730    const char *key = KEY_FILTER_INTENSITY;
731    ImageEffect_Any value;
732    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
733    value.dataValue.floatValue = static_cast<float>(12);
734    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, key, &value);
735    ImageEffect_Any result;
736    errorCode = OH_EffectFilter_GetValue(filter, key, &result);
737    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_GetValue failed";
738    ASSERT_EQ(result.dataValue.floatValue, static_cast<float>(12)) << "OH_EffectFilter_GetValue failed";
739
740    GTEST_LOG_(INFO) << "OHEFilterGetValue001 success! result: " << errorCode;
741    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue001 END";
742}
743
744/**
745 * Feature: ImageEffect
746 * Function: Test OH_EffectFilter_GetValue with all empty parameter
747 * SubFunction: NA
748 * FunctionPoints: NA
749 * EnvConditions: NA
750 * CaseDescription: Test OH_EffectFilter_GetValue with all empty parameter
751 */
752HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue002, TestSize.Level1)
753{
754    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue002 start";
755
756    ImageEffect_ErrorCode errorCode = OH_EffectFilter_GetValue(nullptr, nullptr, nullptr);
757    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_GetValue failed";
758
759    GTEST_LOG_(INFO) << "OHEFilterGetValue002 success! result: " << errorCode;
760    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue002 END";
761}
762
763/**
764 * Feature: ImageEffect
765 * Function: Test OH_EffectFilter_GetValue with not exist key parameter
766 * SubFunction: NA
767 * FunctionPoints: NA
768 * EnvConditions: NA
769 * CaseDescription: Test OH_EffectFilter_GetValue with not exist key parameter
770 */
771HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue003, TestSize.Level1)
772{
773    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue003 start";
774
775    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
776    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
777    const char *key = KEY_FILTER_INTENSITY;
778    ImageEffect_Any value;
779    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
780    value.dataValue.floatValue = static_cast<float>(12);
781    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, key, &value);
782    ImageEffect_Any result;
783    errorCode = OH_EffectFilter_GetValue(filter, "test", &result);
784    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_GetValue failed";
785    ASSERT_NE(result.dataValue.floatValue, static_cast<float>(12)) << "OH_EffectFilter_GetValue failed";
786
787    GTEST_LOG_(INFO) << "OHEFilterGetValue003 success! result: " << errorCode;
788    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue003 END";
789}
790
791/**
792 * Feature: ImageEffect
793 * Function: Test OH_EffectFilter_GetValue with empty OH_EffectFilter parameter
794 * SubFunction: NA
795 * FunctionPoints: NA
796 * EnvConditions: NA
797 * CaseDescription: Test OH_EffectFilter_GetValue with empty OH_EffectFilter parameter
798 */
799HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue004, TestSize.Level1)
800{
801    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue004 start";
802
803    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
804    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
805    const char *key = KEY_FILTER_INTENSITY;
806    ImageEffect_Any value;
807    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
808    value.dataValue.floatValue = static_cast<float>(12);
809    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, key, &value);
810    ImageEffect_Any result;
811    errorCode = OH_EffectFilter_GetValue(nullptr, KEY_FILTER_INTENSITY, &result);
812    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_GetValue failed";
813    ASSERT_NE(result.dataValue.floatValue, static_cast<float>(12)) << "OH_EffectFilter_GetValue failed";
814
815    GTEST_LOG_(INFO) << "OHEFilterGetValue004 success! result: " << errorCode;
816    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue004 END";
817}
818
819/**
820 * Feature: ImageEffect
821 * Function: Test OH_EffectFilter_GetValue with unobstructed OH_EffectFilter_SetValue func
822 * SubFunction: NA
823 * FunctionPoints: NA
824 * EnvConditions: NA
825 * CaseDescription: Test OH_EffectFilter_GetValue with unobstructed OH_EffectFilter_SetValue func
826 */
827HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue005, TestSize.Level1)
828{
829    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue005 start";
830
831    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
832    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
833    const char *key = KEY_FILTER_INTENSITY;
834    ImageEffect_Any value;
835    ImageEffect_ErrorCode errorCode = OH_EffectFilter_GetValue(filter, key, &value);
836    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_GetValue failed";
837    ASSERT_EQ(value.dataValue.floatValue, 0) << "OH_EffectFilter_GetValue failed";
838
839    GTEST_LOG_(INFO) << "OHEFilterGetValue005 success! result: " << errorCode;
840    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue005 END";
841}
842
843/**
844 * Feature: ImageEffect
845 * Function: Test OH_EffectFilter_GetValue by FILTER_NAME
846 * SubFunction: NA
847 * FunctionPoints: NA
848 * EnvConditions: NA
849 * CaseDescription: Test OH_EffectFilter_GetValue by FILTER_NAME
850 */
851HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue006, TestSize.Level1)
852{
853    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue006 start";
854    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
855    ASSERT_NE(imageEffect, nullptr);
856    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
857    ASSERT_NE(filter, nullptr);
858    const char *key = "FILTER_NAME";
859    ImageEffect_Any value;
860    ImageEffect_ErrorCode errorCode = OH_EffectFilter_GetValue(filter, key, &value);
861    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_GetValue failed";
862    ASSERT_EQ(value.dataType, ImageEffect_DataType::EFFECT_DATA_TYPE_PTR) << "OH_EffectFilter_GetValue failed";
863    ASSERT_NE(value.dataValue.ptrValue, nullptr) << "OH_EffectFilter_GetValue failed";
864    ASSERT_STREQ(static_cast<char *>(value.dataValue.ptrValue), BRIGHTNESS_EFILTER) <<
865        "OH_EffectFilter_GetValue failed";
866
867    GTEST_LOG_(INFO) << "OHEFilterGetValue006 success! result: " << errorCode;
868    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterGetValue006 END";
869}
870
871/**
872 * Feature: ImageEffect
873 * Function: Test OH_EffectFilter_Render with normal parameter
874 * SubFunction: NA
875 * FunctionPoints: NA
876 * EnvConditions: NA
877 * CaseDescription: Test OH_EffectFilter_Render with normal parameter
878 */
879HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender001, TestSize.Level1)
880{
881    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender001 start";
882
883    OH_EffectFilter *filter = OH_EffectFilter_Create(BRIGHTNESS_EFILTER);
884    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Render(filter, pixelmapNative_, pixelmapNative_);
885    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_Render failed";
886
887    GTEST_LOG_(INFO) << "OHEFilterRender001 success! result: " << errorCode;
888    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender001 END";
889}
890
891/**
892 * Feature: ImageEffect
893 * Function: Test OH_EffectFilter_Render with all empty parameter
894 * SubFunction: NA
895 * FunctionPoints: NA
896 * EnvConditions: NA
897 * CaseDescription: Test OH_EffectFilter_Render with all empty parameter
898 */
899HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender002, TestSize.Level1)
900{
901    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender002 start";
902
903    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Render(nullptr, nullptr, nullptr);
904    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_Render failed";
905
906    GTEST_LOG_(INFO) << "OHEFilterRender002 success! result: " << errorCode;
907    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender002 END";
908}
909
910/**
911 * Feature: ImageEffect
912 * Function: Test OH_EffectFilter_Render with empty OH_EffectFilter parameter
913 * SubFunction: NA
914 * FunctionPoints: NA
915 * EnvConditions: NA
916 * CaseDescription: Test OH_EffectFilter_Render with empty OH_EffectFilter parameter
917 */
918HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender003, TestSize.Level1)
919{
920    InSequence s;
921    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender003 start";
922
923    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Render(nullptr, pixelmapNative_, pixelmapNative_);
924    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_Render failed";
925
926    GTEST_LOG_(INFO) << "OHEFilterRender003 success! result: " << errorCode;
927    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender003 END";
928}
929
930/**
931 * Feature: ImageEffect
932 * Function: Test OH_EffectFilter_Render with empty inputPixelmap, outputPixelmap parameter
933 * SubFunction: NA
934 * FunctionPoints: NA
935 * EnvConditions: NA
936 * CaseDescription: Test OH_EffectFilter_Render with empty inputPixelmap, outputPixelmap parameter
937 */
938HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender004, TestSize.Level1)
939{
940    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender004 start";
941
942    OH_EffectFilter *filter = OH_EffectFilter_Create(BRIGHTNESS_EFILTER);
943    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Render(filter, nullptr, nullptr);
944    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_Render failed";
945
946    GTEST_LOG_(INFO) << "OHEFilterRender004 success! result: " << errorCode;
947    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender004 END";
948}
949
950/**
951 * Feature: ImageEffect
952 * Function: Test OH_EffectFilter_Render with empty outputPixelmap parameter
953 * SubFunction: NA
954 * FunctionPoints: NA
955 * EnvConditions: NA
956 * CaseDescription: Test OH_EffectFilter_Render with empty outputPixelmap parameter
957 */
958HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender005, TestSize.Level1)
959{
960    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender005 start";
961    InSequence s;
962
963    OH_EffectFilter *filter = OH_EffectFilter_Create(BRIGHTNESS_EFILTER);
964
965    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Render(filter, pixelmapNative_, nullptr);
966    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_Render failed";
967
968    GTEST_LOG_(INFO) << "OHEFilterRender005 success! result: " << errorCode;
969    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender005 END";
970}
971
972/**
973 * Feature: ImageEffect
974 * Function: Test OH_EffectFilter_Render with empty inputPixelmap parameter
975 * SubFunction: NA
976 * FunctionPoints: NA
977 * EnvConditions: NA
978 * CaseDescription: Test OH_EffectFilter_Render with empty inputPixelmap parameter
979 */
980HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender006, TestSize.Level1)
981{
982    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender006 start";
983    InSequence s;
984
985    OH_EffectFilter *filter = OH_EffectFilter_Create(BRIGHTNESS_EFILTER);
986    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Render(filter, nullptr, pixelmapNative_);
987    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_Render failed";
988
989    GTEST_LOG_(INFO) << "OHEFilterRender006 success! result: " << errorCode;
990    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRender006 END";
991}
992
993/**
994 * Feature: ImageEffect
995 * Function: Test OH_EffectFilter_Release with normal parameter
996 * SubFunction: NA
997 * FunctionPoints: NA
998 * EnvConditions: NA
999 * CaseDescription: Test OH_EffectFilter_Release with normal parameter
1000 */
1001HWTEST_F(ImageEffectCApiUnittest, OHEFilterRelease001, TestSize.Level1)
1002{
1003    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRelease001 start";
1004
1005    OH_EffectFilter *filter = OH_EffectFilter_Create(BRIGHTNESS_EFILTER);
1006    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Release(filter);
1007    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_Release failed";
1008
1009    GTEST_LOG_(INFO) << "OHEFilterRelease001 success! result: " << errorCode;
1010    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRelease001 END";
1011}
1012
1013/**
1014 * Feature: ImageEffect
1015 * Function: Test OH_EffectFilter_Release with empty parameter
1016 * SubFunction: NA
1017 * FunctionPoints: NA
1018 * EnvConditions: NA
1019 * CaseDescription: Test OH_EffectFilter_Release with empty parameter
1020 */
1021HWTEST_F(ImageEffectCApiUnittest, OHEFilterRelease002, TestSize.Level1)
1022{
1023    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRelease002 start";
1024
1025    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Release(nullptr);
1026    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_Release failed";
1027
1028    GTEST_LOG_(INFO) << "OHEFilterRelease002 success! result: " << errorCode;
1029    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRelease002 END";
1030}
1031
1032/**
1033 * Feature: ImageEffect
1034 * Function: Test OH_EffectFilter_Release with not exist OH_EffectFilter parameter
1035 * SubFunction: NA
1036 * FunctionPoints: NA
1037 * EnvConditions: NA
1038 * CaseDescription: Test OH_EffectFilter_Release with not exist OH_EffectFilter parameter
1039 */
1040HWTEST_F(ImageEffectCApiUnittest, OHEFilterRelease003, TestSize.Level1)
1041{
1042    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRelease003 start";
1043
1044    OH_EffectFilter *filter = OH_EffectFilter_Create("TestEFilter");
1045    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Release(filter);
1046    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_Release failed";
1047
1048    GTEST_LOG_(INFO) << "OHEFilterRelease003 success! result: " << errorCode;
1049    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRelease003 END";
1050}
1051
1052/**
1053 * Feature: ImageEffect
1054 * Function: Test ImageEffectSingleFilter with normal parameter
1055 * SubFunction: NA
1056 * FunctionPoints: NA
1057 * EnvConditions: NA
1058 * CaseDescription: Test ImageEffectSingleFilter with normal parameter
1059 */
1060HWTEST_F(ImageEffectCApiUnittest, ImageEffectSingleFilterUnittest001, TestSize.Level1)
1061{
1062    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSingleFilterUnittest001 start";
1063    InSequence s;
1064
1065    OH_EffectFilter *filter = OH_EffectFilter_Create(BRIGHTNESS_EFILTER);
1066    ASSERT_NE(filter, nullptr) << "ImageEffectSingleFilterUnittest001 OH_EffectFilter_Create failed";
1067    ImageEffect_Any value;
1068    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1069    value.dataValue.floatValue = 100.f;
1070    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1071    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1072        "ImageEffectSingleFilterUnittest001 OH_EffectFilter_SetValue failed";
1073
1074    errorCode = OH_EffectFilter_Render(filter, pixelmapNative_, pixelmapNative_);
1075    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1076        "ImageEffectSingleFilterUnittest001 OH_EffectFilter_Render failed";
1077
1078    errorCode = OH_EffectFilter_Release(filter);
1079    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1080        "ImageEffectSingleFilterUnittest001 OH_EffectFilter_Release failed";
1081
1082    GTEST_LOG_(INFO) << "ImageEffectSingleFilterUnittest001 success! result: " << errorCode;
1083    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSingleFilterUnittest001 END";
1084}
1085
1086/**
1087 * Feature: ImageEffect
1088 * Function: Test ImageEffectSingleFilter submethod OH_EffectFilter_Create with not exist OH_EffectFilter parameter
1089 * SubFunction: NA
1090 * FunctionPoints: NA
1091 * EnvConditions: NA
1092 * CaseDescription: Test ImageEffectSingleFilter submethod OH_EffectFilter_Create with not exist OH_EffectFilter
1093 * parameter
1094 */
1095HWTEST_F(ImageEffectCApiUnittest, ImageEffectSingleFilterUnittest002, TestSize.Level1)
1096{
1097    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSingleFilterUnittest002 start";
1098    InSequence s;
1099
1100    OH_EffectFilter *filter = OH_EffectFilter_Create("TestEFilter");
1101    ASSERT_EQ(filter, nullptr) << "ImageEffectSingleFilterUnittest002 OH_EffectFilter_Create failed";
1102    ImageEffect_Any value;
1103    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1104    value.dataValue.floatValue = 100.f;
1105    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1106    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1107        "ImageEffectSingleFilterUnittest002 OH_EffectFilter_SetValue failed";
1108
1109    errorCode = OH_EffectFilter_Render(filter, pixelmapNative_, pixelmapNative_);
1110    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1111        "ImageEffectSingleFilterUnittest002 OH_EffectFilter_Render failed";
1112
1113    errorCode = OH_EffectFilter_Release(filter);
1114    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1115        "ImageEffectSingleFilterUnittest002 OH_EffectFilter_Release failed";
1116
1117    GTEST_LOG_(INFO) << "ImageEffectSingleFilterUnittest002 success! result: " << errorCode;
1118    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSingleFilterUnittest002 END";
1119}
1120
1121/**
1122 * Feature: ImageEffect
1123 * Function: Test ImageEffectSingleFilter submethod OH_EffectFilter_SetValue with not exist key parameter
1124 * SubFunction: NA
1125 * FunctionPoints: NA
1126 * EnvConditions: NA
1127 * CaseDescription: Test ImageEffectSingleFilter submethod OH_EffectFilter_SetValue with not exist key parameter
1128 */
1129HWTEST_F(ImageEffectCApiUnittest, ImageEffectSingleFilterUnittest003, TestSize.Level1)
1130{
1131    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSingleFilterUnittest003 start";
1132    InSequence s;
1133
1134    OH_EffectFilter *filter = OH_EffectFilter_Create(BRIGHTNESS_EFILTER);
1135    ASSERT_NE(filter, nullptr) << "ImageEffectSingleFilterUnittest003 OH_EffectFilter_Create failed";
1136    ImageEffect_Any value;
1137    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1138    value.dataValue.floatValue = 100.f;
1139    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, "testRatio", &value);
1140    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1141        "ImageEffectSingleFilterUnittest003 OH_EffectFilter_SetValue failed";
1142
1143    errorCode = OH_EffectFilter_Render(filter, pixelmapNative_, pixelmapNative_);
1144    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1145        "ImageEffectSingleFilterUnittest003 OH_EffectFilter_Render failed";
1146
1147    errorCode = OH_EffectFilter_Release(filter);
1148    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1149        "ImageEffectSingleFilterUnittest003 OH_EffectFilter_Release failed";
1150
1151    GTEST_LOG_(INFO) << "ImageEffectSingleFilterUnittest003 success! result: " << errorCode;
1152    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSingleFilterUnittest003 END";
1153}
1154
1155/**
1156 * Feature: ImageEffect
1157 * Function: Test ImageEffectSingleFilter submethod OH_EffectFilter_Render unobstructed
1158 * SubFunction: NA
1159 * FunctionPoints: NA
1160 * EnvConditions: NA
1161 * CaseDescription: Test ImageEffectSingleFilter submethod OH_EffectFilter_Render unobstructed
1162 */
1163HWTEST_F(ImageEffectCApiUnittest, ImageEffectSingleFilterUnittest004, TestSize.Level1)
1164{
1165    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSingleFilterUnittest004 start";
1166
1167    OH_EffectFilter *filter = OH_EffectFilter_Create(BRIGHTNESS_EFILTER);
1168    ASSERT_NE(filter, nullptr) << "ImageEffectSingleFilterUnittest004 OH_EffectFilter_Create failed";
1169    ImageEffect_Any value;
1170    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1171    value.dataValue.floatValue = 100.f;
1172    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1173    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1174        "ImageEffectSingleFilterUnittest004 OH_EffectFilter_SetValue failed";
1175
1176    errorCode = OH_EffectFilter_Release(filter);
1177    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1178        "ImageEffectSingleFilterUnittest004 OH_EffectFilter_Release failed";
1179
1180    GTEST_LOG_(INFO) << "ImageEffectSingleFilterUnittest004 success! result: " << errorCode;
1181    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSingleFilterUnittest004 END";
1182}
1183
1184/**
1185 * Feature: ImageEffect
1186 * Function: Test ImageEffectSingleFilter with normal parameter
1187 * SubFunction: NA
1188 * FunctionPoints: NA
1189 * EnvConditions: NA
1190 * CaseDescription: Test ImageEffectSingleFilter with normal parameter
1191 */
1192HWTEST_F(ImageEffectCApiUnittest, ImageEffectSingleFilterUnittest005, TestSize.Level1)
1193{
1194    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSingleFilterUnittest005 start";
1195    InSequence s;
1196
1197    std::shared_ptr<OH_PixelmapNative> pixelmapNative = std::make_shared<OH_PixelmapNative>(nullptr);
1198    std::unique_ptr<PixelMap> pixelMap = TestPixelMapUtils::ParsePixelMapByPath(g_jpgHdrPath);
1199    ASSERT_NE(pixelMap, nullptr);
1200    pixelmapNative->pixelmap_ = std::move(pixelMap);
1201
1202    OH_EffectFilter *filter = OH_EffectFilter_Create(CROP_EFILTER);
1203    ASSERT_NE(filter, nullptr) << "ImageEffectSingleFilterUnittest005 OH_EffectFilter_Create failed";
1204
1205    uint32_t x1 = static_cast<uint32_t>(pixelmapNative->pixelmap_->GetWidth() / CROP_FACTOR);
1206    uint32_t y1 = static_cast<uint32_t>(pixelmapNative->pixelmap_->GetHeight() / CROP_FACTOR);
1207    uint32_t areaInfo[] = { 0, 0, x1, y1};
1208    ImageEffect_Any value;
1209    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_PTR;
1210    value.dataValue.ptrValue = static_cast<void *>(areaInfo);
1211    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_REGION, &value);
1212    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1213        "ImageEffectSingleFilterUnittest005 OH_EffectFilter_SetValue failed";
1214
1215    errorCode = OH_EffectFilter_Render(filter, pixelmapNative_, pixelmapNative_);
1216    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1217        "ImageEffectSingleFilterUnittest003 OH_EffectFilter_Render failed";
1218
1219    errorCode = OH_EffectFilter_Release(filter);
1220    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1221        "ImageEffectSingleFilterUnittest005 OH_EffectFilter_Release failed";
1222
1223    GTEST_LOG_(INFO) << "ImageEffectSingleFilterUnittest005 success! result: " << errorCode;
1224    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSingleFilterUnittest005 END";
1225}
1226
1227
1228/**
1229 * Feature: ImageEffect
1230 * Function: Test OH_ImageEffect_SetInputPixelmap with normal parameter
1231 * SubFunction: NA
1232 * FunctionPoints: NA
1233 * EnvConditions: NA
1234 * CaseDescription: Test OH_ImageEffect_SetInputPixelmap with normal parameter
1235 */
1236HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputPixelmap001, TestSize.Level1)
1237{
1238    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputPixelmap001 start";
1239    InSequence s;
1240
1241    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1242    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
1243    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetInputPixelmap failed";
1244
1245    GTEST_LOG_(INFO) << "OHImageEffectSetInputPixelmap001 success! result: " << errorCode;
1246    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputPixelmap001 END";
1247}
1248
1249/**
1250 * Feature: ImageEffect
1251 * Function: Test OH_ImageEffect_SetInputPixelmap with all empty parameter
1252 * SubFunction: NA
1253 * FunctionPoints: NA
1254 * EnvConditions: NA
1255 * CaseDescription: Test OH_ImageEffect_SetInputPixelmap with all empty parameter
1256 */
1257HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputPixelmap002, TestSize.Level1)
1258{
1259    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputPixelmap002 start";
1260
1261    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputPixelmap(nullptr, nullptr);
1262    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetInputPixelmap failed";
1263
1264    GTEST_LOG_(INFO) << "OHImageEffectSetInputPixelmap002 success! result: " << errorCode;
1265    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputPixelmap002 END";
1266}
1267
1268/**
1269 * Feature: ImageEffect
1270 * Function: Test OH_ImageEffect_SetInputPixelmap with empty OH_PixelmapNative parameter
1271 * SubFunction: NA
1272 * FunctionPoints: NA
1273 * EnvConditions: NA
1274 * CaseDescription: Test OH_ImageEffect_SetInputPixelmap with empty OH_PixelmapNative parameter
1275 */
1276HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputPixelmap003, TestSize.Level1)
1277{
1278    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputPixelmap003 start";
1279    InSequence s;
1280
1281    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1282    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, nullptr);
1283    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetInputPixelmap failed";
1284
1285    GTEST_LOG_(INFO) << "OHImageEffectSetInputPixelmap003 success! result: " << errorCode;
1286    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputPixelmap003 END";
1287}
1288
1289/**
1290 * Feature: ImageEffect
1291 * Function: Test OH_ImageEffect_SetInputPixelmap with empty OH_ImageEffect parameter
1292 * SubFunction: NA
1293 * FunctionPoints: NA
1294 * EnvConditions: NA
1295 * CaseDescription: Test OH_ImageEffect_SetInputPixelmap with empty OH_ImageEffect parameter
1296 */
1297HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputPixelmap004, TestSize.Level1)
1298{
1299    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputPixelmap004 start";
1300    InSequence s;
1301
1302    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputPixelmap(nullptr, pixelmapNative_);
1303    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetInputPixelmap failed";
1304
1305    GTEST_LOG_(INFO) << "OHImageEffectSetInputPixelmap004 success! result: " << errorCode;
1306    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputPixelmap004 END";
1307}
1308
1309/**
1310 * Feature: ImageEffect
1311 * Function: Test OH_ImageEffect_SetOutputPixelmap with normal parameter
1312 * SubFunction: NA
1313 * FunctionPoints: NA
1314 * EnvConditions: NA
1315 * CaseDescription: Test OH_ImageEffect_SetOutputPixelmap with normal parameter
1316 */
1317HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputPixelMap001, TestSize.Level1)
1318{
1319    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputPixelMap001 start";
1320    InSequence s;
1321
1322    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1323    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, pixelmapNative_);
1324    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputPixelmap failed";
1325
1326    GTEST_LOG_(INFO) << "OHImageEffectSetOutputPixelMap001 success! result: " << errorCode;
1327    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputPixelMap001 END";
1328}
1329
1330/**
1331 * Feature: ImageEffect
1332 * Function: Test OH_ImageEffect_SetOutputPixelmap with all empty parameter
1333 * SubFunction: NA
1334 * FunctionPoints: NA
1335 * EnvConditions: NA
1336 * CaseDescription: Test OH_ImageEffect_SetOutputPixelmap with all empty parameter
1337 */
1338HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputPixelMap002, TestSize.Level1)
1339{
1340    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputPixelMap002 start";
1341
1342    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetOutputPixelmap(nullptr, nullptr);
1343    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputPixelmap failed";
1344
1345    GTEST_LOG_(INFO) << "OHImageEffectSetOutputPixelMap002 success! result: " << errorCode;
1346    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputPixelMap002 END";
1347}
1348
1349/**
1350 * Feature: ImageEffect
1351 * Function: Test OH_ImageEffect_SetOutputPixelmap with empty OH_PixelmapNative parameter
1352 * SubFunction: NA
1353 * FunctionPoints: NA
1354 * EnvConditions: NA
1355 * CaseDescription: Test OH_ImageEffect_SetOutputPixelmap with empty OH_PixelmapNative parameter
1356 */
1357HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputPixelMap003, TestSize.Level1)
1358{
1359    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputPixelMap003 start";
1360
1361    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1362    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, nullptr);
1363    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputPixelmap failed";
1364
1365    GTEST_LOG_(INFO) << "OHImageEffectSetOutputPixelMap003 success! result: " << errorCode;
1366    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputPixelMap003 END";
1367}
1368
1369/**
1370 * Feature: ImageEffect
1371 * Function: Test OH_ImageEffect_SetOutputPixelmap with empty OH_ImageEffect parameter
1372 * SubFunction: NA
1373 * FunctionPoints: NA
1374 * EnvConditions: NA
1375 * CaseDescription: Test OH_ImageEffect_SetOutputPixelmap with empty OH_ImageEffect parameter
1376 */
1377HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputPixelMap004, TestSize.Level1)
1378{
1379    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputPixelMap004 start";
1380    InSequence s;
1381
1382    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetOutputPixelmap(nullptr, pixelmapNative_);
1383    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputPixelmap failed";
1384
1385    GTEST_LOG_(INFO) << "OHImageEffectSetOutputPixelMap004 success! result: " << errorCode;
1386    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputPixelMap004 END";
1387}
1388
1389/**
1390 * Feature: ImageEffect
1391 * Function: Test OH_ImageEffect_Start with normal parameter
1392 * SubFunction: NA
1393 * FunctionPoints: NA
1394 * EnvConditions: NA
1395 * CaseDescription: Test OH_ImageEffect_Start with normal parameter
1396 */
1397HWTEST_F(ImageEffectCApiUnittest, OHImageEffectStart001, TestSize.Level1)
1398{
1399    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectStart001 start";
1400
1401    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1402    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Start(imageEffect);
1403    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Start failed";
1404
1405    GTEST_LOG_(INFO) << "OHImageEffectStart001 success! result: " << errorCode;
1406    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectStart001 END";
1407}
1408
1409/**
1410 * Feature: ImageEffect
1411 * Function: Test OH_ImageEffect_Start with empty parameter
1412 * SubFunction: NA
1413 * FunctionPoints: NA
1414 * EnvConditions: NA
1415 * CaseDescription: Test OH_ImageEffect_Start with empty parameter
1416 */
1417HWTEST_F(ImageEffectCApiUnittest, OHImageEffectStart002, TestSize.Level1)
1418{
1419    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectStart002 start";
1420
1421    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Start(nullptr);
1422    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Start failed";
1423
1424    GTEST_LOG_(INFO) << "OHImageEffectStart002 success! result: " << errorCode;
1425    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectStart002 END";
1426}
1427
1428/**
1429 * Feature: ImageEffect
1430 * Function: Test OH_ImageEffect_Release with normal parameter
1431 * SubFunction: NA
1432 * FunctionPoints: NA
1433 * EnvConditions: NA
1434 * CaseDescription: Test OH_ImageEffect_Release with normal parameter
1435 */
1436HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRelease001, TestSize.Level1)
1437{
1438    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRelease001 start";
1439
1440    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1441    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Release(imageEffect);
1442    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OHImageEffectRelease001 failed";
1443
1444    GTEST_LOG_(INFO) << "OHImageEffectRelease001 success! result: " << errorCode;
1445    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRelease001 END";
1446}
1447
1448/**
1449 * Feature: ImageEffect
1450 * Function: Test OH_ImageEffect_Release with empty parameter
1451 * SubFunction: NA
1452 * FunctionPoints: NA
1453 * EnvConditions: NA
1454 * CaseDescription: Test OH_ImageEffect_Release with empty parameter
1455 */
1456HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRelease002, TestSize.Level1)
1457{
1458    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRelease002 start";
1459
1460    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Release(nullptr);
1461    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Release002 failed";
1462
1463    GTEST_LOG_(INFO) << "OHImageEffectRelease002 success! result: " << errorCode;
1464    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRelease002 END";
1465}
1466
1467/**
1468 * Feature: ImageEffect
1469 * Function: Test ImageEffectStandardFilter with normal parameter
1470 * SubFunction: NA
1471 * FunctionPoints: NA
1472 * EnvConditions: NA
1473 * CaseDescription: Test ImageEffectStandardFilter with normal parameter
1474 */
1475HWTEST_F(ImageEffectCApiUnittest, ImageEffectStandardFilterUnittest001, TestSize.Level1)
1476{
1477    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectStandardFilterUnittest001 start";
1478    InSequence s;
1479
1480    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1481    ASSERT_NE(imageEffect, nullptr) << "ImageEffectStandardFilterUnittest001 OH_ImageEffect_Create failed";
1482
1483    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
1484    ASSERT_NE(filter, nullptr) << "ImageEffectStandardFilterUnittest001 OH_ImageEffect_AddFilter failed";
1485
1486    ImageEffect_Any value;
1487    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1488    value.dataValue.floatValue = 200.f;
1489    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1490    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1491        "ImageEffectStandardFilterUnittest001 OH_EffectFilter_SetValue failed";
1492
1493    ImageEffect_Any result;
1494    errorCode = OH_EffectFilter_GetValue(filter, KEY_FILTER_INTENSITY, &result);
1495    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_GetValue failed";
1496    ASSERT_EQ(result.dataType, ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT) <<
1497        "OH_EffectFilter_GetValue dataType failed";
1498    ASSERT_EQ(result.dataValue.floatValue, 100.f) << "OH_EffectFilter_GetValue dataValue failed";
1499
1500    errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
1501    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1502        "ImageEffectStandardFilterUnittest001 OH_ImageEffect_SetInputPixelmap failed";
1503
1504    std::shared_ptr<PixelMap> outputPixelmap = std::make_shared<MockPixelMap>();
1505    std::shared_ptr<OH_PixelmapNative> outputPixelmapNative = std::make_shared<OH_PixelmapNative>(outputPixelmap);
1506    errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, outputPixelmapNative.get());
1507    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1508        "ImageEffectStandardFilterUnittest001 OH_ImageEffect_SetOutputPixelmap failed";
1509
1510    errorCode = OH_ImageEffect_Start(imageEffect);
1511    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1512        "ImageEffectStandardFilterUnittest001 OH_ImageEffect_Start failed";
1513
1514    errorCode = OH_ImageEffect_Release(imageEffect);
1515    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1516        "ImageEffectStandardFilterUnittest001 OH_ImageEffect_Release failed";
1517
1518    GTEST_LOG_(INFO) << "ImageEffectStandardFilterUnittest001 success! result: " << errorCode;
1519    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectStandardFilterUnittest001 END";
1520}
1521
1522/**
1523 * Feature: ImageEffect
1524 * Function: Test ImageEffectStandardFilter submethod OH_ImageEffect_AddFilter with not exist OH_EffectFilter parameter
1525 * SubFunction: NA
1526 * FunctionPoints: NA
1527 * EnvConditions: NA
1528 * CaseDescription: Test ImageEffectStandardFilter submethod OH_ImageEffect_AddFilter with not exist OH_EffectFilter
1529 * parameter
1530 */
1531HWTEST_F(ImageEffectCApiUnittest, ImageEffectStandardFilterUnittest002, TestSize.Level1)
1532{
1533    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectStandardFilterUnittest002 start";
1534    InSequence s;
1535
1536    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1537    ASSERT_NE(imageEffect, nullptr) << "ImageEffectStandardFilterUnittest002 OH_ImageEffect_Create failed";
1538
1539    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, "TestEFilter");
1540    ASSERT_EQ(filter, nullptr) << "ImageEffectStandardFilterUnittest002 OH_ImageEffect_AddFilter failed";
1541
1542    ImageEffect_Any value;
1543    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1544    value.dataValue.floatValue = 100.f;
1545    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1546    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1547        "ImageEffectStandardFilterUnittest002 OH_EffectFilter_SetValue failed";
1548
1549    errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
1550    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1551        "ImageEffectStandardFilterUnittest002 OH_ImageEffect_SetInputPixelmap failed";
1552    errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, pixelmapNative_);
1553    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1554        "ImageEffectStandardFilterUnittest002 OH_ImageEffect_SetOutputPixelmap failed";
1555
1556    errorCode = OH_ImageEffect_Start(imageEffect);
1557    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1558        "ImageEffectStandardFilterUnittest002 OH_ImageEffect_Start failed";
1559
1560    errorCode = OH_ImageEffect_Release(imageEffect);
1561    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1562        "ImageEffectStandardFilterUnittest002 OH_ImageEffect_Release failed";
1563
1564    GTEST_LOG_(INFO) << "ImageEffectStandardFilterUnittest002 success! result: " << errorCode;
1565    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectStandardFilterUnittest002 END";
1566}
1567
1568/**
1569 * Feature: ImageEffect
1570 * Function: Test ImageEffectStandardFilter submethod OH_EffectFilter_SetValue with not exist key parameter
1571 * SubFunction: NA
1572 * FunctionPoints: NA
1573 * EnvConditions: NA
1574 * CaseDescription: Test ImageEffectStandardFilter submethod OH_EffectFilter_SetValue with not exist key parameter
1575 */
1576HWTEST_F(ImageEffectCApiUnittest, ImageEffectStandardFilterUnittest003, TestSize.Level1)
1577{
1578    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectStandardFilterUnittest003 start";
1579    InSequence s;
1580
1581    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1582    ASSERT_NE(imageEffect, nullptr) << "ImageEffectStandardFilterUnittest003 OH_ImageEffect_Create failed";
1583
1584    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
1585    ASSERT_NE(filter, nullptr) << "ImageEffectStandardFilterUnittest003 OH_ImageEffect_AddFilter failed";
1586
1587    ImageEffect_Any value;
1588    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1589    value.dataValue.floatValue = 100.f;
1590    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, "test", &value);
1591    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1592        "ImageEffectStandardFilterUnittest003 OH_EffectFilter_SetValue failed";
1593
1594    errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
1595    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1596        "ImageEffectStandardFilterUnittest003 OH_ImageEffect_SetInputPixelmap failed";
1597    errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, pixelmapNative_);
1598    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1599        "ImageEffectStandardFilterUnittest003 OH_ImageEffect_SetOutputPixelmap failed";
1600
1601    errorCode = OH_ImageEffect_Start(imageEffect);
1602    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1603        "ImageEffectStandardFilterUnittest003 OH_ImageEffect_Start failed";
1604
1605    errorCode = OH_ImageEffect_Release(imageEffect);
1606    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1607        "ImageEffectStandardFilterUnittest003 OH_ImageEffect_Release failed";
1608
1609    GTEST_LOG_(INFO) << "ImageEffectStandardFilterUnittest003 success! result: " << errorCode;
1610    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectStandardFilterUnittest003 END";
1611}
1612
1613/**
1614 * Feature: ImageEffect
1615 * Function: Test ImageEffectStandardFilter submethod OH_ImageEffect_Start with empty parameter
1616 * SubFunction: NA
1617 * FunctionPoints: NA
1618 * EnvConditions: NA
1619 * CaseDescription: Test ImageEffectStandardFilter submethod OH_ImageEffect_Start with empty parameter
1620 */
1621HWTEST_F(ImageEffectCApiUnittest, ImageEffectStandardFilterUnittest004, TestSize.Level1)
1622{
1623    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectStandardFilterUnittest004 start";
1624    InSequence s;
1625
1626    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1627    ASSERT_NE(imageEffect, nullptr) << "ImageEffectStandardFilterUnittest004 OH_ImageEffect_Create failed";
1628
1629    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
1630    ASSERT_NE(filter, nullptr) << "ImageEffectStandardFilterUnittest004 OH_ImageEffect_AddFilter failed";
1631
1632    ImageEffect_Any value;
1633    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1634    value.dataValue.floatValue = 100.f;
1635    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1636    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1637        "ImageEffectStandardFilterUnittest004 OH_EffectFilter_SetValue failed";
1638
1639    errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
1640    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1641        "ImageEffectStandardFilterUnittest004 OH_ImageEffect_SetInputPixelmap failed";
1642    errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, pixelmapNative_);
1643    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1644        "ImageEffectStandardFilterUnittest004 OH_ImageEffect_SetOutputPixelmap failed";
1645
1646    errorCode = OH_ImageEffect_Start(nullptr);
1647    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1648        "ImageEffectStandardFilterUnittest004 OH_ImageEffect_Start failed";
1649
1650    errorCode = OH_ImageEffect_Release(imageEffect);
1651    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1652        "ImageEffectStandardFilterUnittest004 OH_ImageEffect_Release failed";
1653
1654    GTEST_LOG_(INFO) << "ImageEffectStandardFilterUnittest004 success! result: " << errorCode;
1655    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectStandardFilterUnittest004 END";
1656}
1657
1658/**
1659 * Feature: ImageEffect
1660 * Function: Test ImageEffectStandardFilter submethod OH_ImageEffect_Release with empty parameter
1661 * SubFunction: NA
1662 * FunctionPoints: NA
1663 * EnvConditions: NA
1664 * CaseDescription: Test ImageEffectStandardFilter submethod OH_ImageEffect_Release with empty parameter
1665 */
1666HWTEST_F(ImageEffectCApiUnittest, ImageEffectStandardFilterUnittest005, TestSize.Level1)
1667{
1668    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectStandardFilterUnittest005 start";
1669    InSequence s;
1670
1671    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1672    ASSERT_NE(imageEffect, nullptr) << "ImageEffectStandardFilterUnittest005 OH_ImageEffect_Create failed";
1673
1674    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
1675    ASSERT_NE(filter, nullptr) << "ImageEffectStandardFilterUnittest005 OH_ImageEffect_AddFilter failed";
1676
1677    ImageEffect_Any value;
1678    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1679    value.dataValue.floatValue = 100.f;
1680    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1681    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1682        "ImageEffectStandardFilterUnittest005 OH_EffectFilter_SetValue failed";
1683
1684    errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
1685    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1686        "ImageEffectStandardFilterUnittest005 OH_ImageEffect_SetInputPixelmap failed";
1687    errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, pixelmapNative_);
1688    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1689        "ImageEffectStandardFilterUnittest005 OH_ImageEffect_SetOutputPixelmap failed";
1690
1691    errorCode = OH_ImageEffect_Start(imageEffect);
1692    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1693        "ImageEffectStandardFilterUnittest005 OH_ImageEffect_Start failed";
1694
1695    errorCode = OH_ImageEffect_Release(nullptr);
1696    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1697        "ImageEffectStandardFilterUnittest004 OH_ImageEffect_Release failed";
1698
1699    GTEST_LOG_(INFO) << "ImageEffectStandardFilterUnittest005 success! result: " << errorCode;
1700    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectStandardFilterUnittest005 END";
1701}
1702
1703/**
1704 * Feature: ImageEffect
1705 * Function: Test OH_EffectFilter_Register with normal parameter
1706 * SubFunction: NA
1707 * FunctionPoints: NA
1708 * EnvConditions: NA
1709 * CaseDescription: Test OH_EffectFilter_Register with normal parameter
1710 */
1711HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister001, TestSize.Level1)
1712{
1713    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister001 start";
1714
1715    ImageEffect_FilterDelegate delegate = {
1716        .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; },
1717        .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1718            pushData(filter, src);
1719            return true;
1720        },
1721        .save = [](OH_EffectFilter *filter, char **info) { return true; },
1722        .restore = [](const char *info) { return OH_EffectFilter_Create("CustomBrightnessEFilter"); }
1723    };
1724
1725    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate);
1726    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1727        "OHEFilterRegister001 OH_EffectFilter_Register failed";
1728
1729    GTEST_LOG_(INFO) << "OHEFilterRegister001 success! result: " << errorCode;
1730    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister001 END";
1731}
1732
1733/**
1734 * Feature: ImageEffect
1735 * Function: Test OH_EffectFilter_Register with ImageEffect_FilterDelegate not exist OH_EffectFilter parameter
1736 * SubFunction: NA
1737 * FunctionPoints: NA
1738 * EnvConditions: NA
1739 * CaseDescription: Test OH_EffectFilter_Register with ImageEffect_FilterDelegate not exist OH_EffectFilter parameter
1740 */
1741HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister002, TestSize.Level1)
1742{
1743    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister002 start";
1744
1745    ImageEffect_FilterDelegate delegate = {
1746        .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; },
1747        .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1748            pushData(filter, src);
1749            return true;
1750        },
1751        .save = [](OH_EffectFilter *filter, char **info) { return true; },
1752        .restore = [](const char *info) { return OH_EffectFilter_Create("CustomTestEFilter"); }
1753    };
1754
1755    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate);
1756    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1757        "OHEFilterRegister002 OH_EffectFilter_Register failed";
1758
1759    GTEST_LOG_(INFO) << "OHEFilterRegister002 success! result: " << errorCode;
1760    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister002 END";
1761}
1762
1763/**
1764 * Feature: ImageEffect
1765 * Function: Test OH_EffectFilter_Register with ImageEffect_FilterDelegate all false parameter
1766 * SubFunction: NA
1767 * FunctionPoints: NA
1768 * EnvConditions: NA
1769 * CaseDescription: Test OH_EffectFilter_Register with ImageEffect_FilterDelegate all false parameter
1770 */
1771HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister003, TestSize.Level1)
1772{
1773    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister003 start";
1774
1775    ImageEffect_FilterDelegate delegate = {
1776        .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return false; },
1777        .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1778            return false;
1779        },
1780        .save = [](OH_EffectFilter *filter, char **info) { return false; },
1781        .restore = [](const char *info) { return OH_EffectFilter_Create("CustomBrightnessEFilter"); }
1782    };
1783
1784    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate);
1785    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1786        "OHEFilterRegister003 OH_EffectFilter_Register failed";
1787
1788    GTEST_LOG_(INFO) << "OHEFilterRegister003 success! result: " << errorCode;
1789    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister003 END";
1790}
1791
1792/**
1793 * Feature: ImageEffect
1794 * Function: Test OH_EffectFilter_Register with OH_EffectInfo not exist OH_EffectFilter parameter
1795 * SubFunction: NA
1796 * FunctionPoints: NA
1797 * EnvConditions: NA
1798 * CaseDescription: Test OH_EffectFilter_Register with OH_EffectInfo not exist OH_EffectFilter parameter
1799 */
1800HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister004, TestSize.Level1)
1801{
1802    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister004 start";
1803
1804    ImageEffect_FilterDelegate delegate = {
1805        .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; },
1806        .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1807            pushData(filter, src);
1808            return true;
1809        },
1810        .save = [](OH_EffectFilter *filter, char **info) { return true; },
1811        .restore = [](const char *info) { return OH_EffectFilter_Create("CustomBrightnessEFilter"); }
1812    };
1813
1814    ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate);
1815    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1816        "OHEFilterRegister004 OH_EffectFilter_Register failed";
1817
1818    GTEST_LOG_(INFO) << "OHEFilterRegister004 success! result: " << errorCode;
1819    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister004 END";
1820}
1821
1822/**
1823 * Feature: ImageEffect
1824 * Function: Test OH_EffectFilter_LookupFilterInfo with normal parameter
1825 * SubFunction: NA
1826 * FunctionPoints: NA
1827 * EnvConditions: NA
1828 * CaseDescription: Test OH_EffectFilter_LookupFilterInfo with normal parameter
1829 */
1830HWTEST_F(ImageEffectCApiUnittest, OHEFilterLookupFilterInfo001, TestSize.Level1)
1831{
1832    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterLookupFilterInfo001 start";
1833
1834    OH_EffectFilterInfo *filterInfo = OH_EffectFilterInfo_Create();
1835    ImageEffect_ErrorCode errorCode = OH_EffectFilter_LookupFilterInfo(BRIGHTNESS_EFILTER, filterInfo);
1836    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_LookupFilterInfo failed";
1837    OH_EffectFilterInfo_Release(filterInfo);
1838    GTEST_LOG_(INFO) << "OHEFilterLookupFilterInfo001 success! result: " << errorCode;
1839    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterLookupFilterInfo001 END";
1840}
1841
1842/**
1843 * Feature: ImageEffect
1844 * Function: Test OH_EffectFilter_LookupFilterInfo with empty key parameter
1845 * SubFunction: NA
1846 * FunctionPoints: NA
1847 * EnvConditions: NA
1848 * CaseDescription: Test OH_EffectFilter_LookupFilterInfo with empty key parameter
1849 */
1850HWTEST_F(ImageEffectCApiUnittest, OHEFilterLookupFilterInfo002, TestSize.Level1)
1851{
1852    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterLookupFilterInfo002 start";
1853
1854    OH_EffectFilterInfo *filterInfo = OH_EffectFilterInfo_Create();
1855    ImageEffect_ErrorCode errorCode = OH_EffectFilter_LookupFilterInfo(nullptr, filterInfo);
1856    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OHEFilterLookupFilterInfo failed";
1857    OH_EffectFilterInfo_Release(filterInfo);
1858    GTEST_LOG_(INFO) << "OHEFilterLookupFilterInfo002 success! result: " << errorCode;
1859    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterLookupFilterInfo002 END";
1860}
1861
1862/**
1863 * Feature: ImageEffect
1864 * Function: Test OH_EffectFilter_LookupFilterInfo with not esist key parameter
1865 * SubFunction: NA
1866 * FunctionPoints: NA
1867 * EnvConditions: NA
1868 * CaseDescription: Test OH_EffectFilter_LookupFilterInfo with not esist key parameter
1869 */
1870HWTEST_F(ImageEffectCApiUnittest, OHEFilterLookupFilterInfo003, TestSize.Level1)
1871{
1872    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterLookupFilterInfo003 start";
1873
1874    OH_EffectFilterInfo *filterInfo = OH_EffectFilterInfo_Create();
1875    ImageEffect_ErrorCode errorCode = OH_EffectFilter_LookupFilterInfo("TestEFilter", filterInfo);
1876    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OHEFilterLookupFilterInfo003 failed";
1877    OH_EffectFilterInfo_Release(filterInfo);
1878    GTEST_LOG_(INFO) << "OHEFilterLookupFilterInfo003 success! result: " << errorCode;
1879    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterLookupFilterInfo003 END";
1880}
1881
1882/**
1883 * Feature: ImageEffect
1884 * Function: Test OH_EffectFilter_LookupFilterInfo with all empty parameter
1885 * SubFunction: NA
1886 * FunctionPoints: NA
1887 * EnvConditions: NA
1888 * CaseDescription: Test OH_EffectFilter_LookupFilterInfo with all empty parameter
1889 */
1890HWTEST_F(ImageEffectCApiUnittest, OHEFilterLookupFilterInfo004, TestSize.Level1)
1891{
1892    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterLookupFilterInfo004 start";
1893
1894    ImageEffect_ErrorCode errorCode = OH_EffectFilter_LookupFilterInfo(nullptr, nullptr);
1895    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_LookupFilterInfo failed";
1896
1897    GTEST_LOG_(INFO) << "OHEFilterLookupFilterInfo004 success! result: " << errorCode;
1898    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterLookupFilterInfo004 END";
1899}
1900
1901/**
1902 * Feature: ImageEffect
1903 * Function: Test OH_EffectFilter_LookupFilterInfo with empty OH_EffectInfo parameter
1904 * SubFunction: NA
1905 * FunctionPoints: NA
1906 * EnvConditions: NA
1907 * CaseDescription: Test OH_EffectFilter_LookupFilterInfo with empty OH_EffectInfo parameter
1908 */
1909HWTEST_F(ImageEffectCApiUnittest, OHEFilterLookupFilterInfo005, TestSize.Level1)
1910{
1911    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterLookupFilterInfo005 start";
1912
1913    ImageEffect_ErrorCode errorCode = OH_EffectFilter_LookupFilterInfo(BRIGHTNESS_EFILTER, nullptr);
1914    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_EffectFilter_LookupFilterInfo failed";
1915
1916    GTEST_LOG_(INFO) << "OHEFilterLookupFilterInfo005 success! result: " << errorCode;
1917    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterLookupFilterInfo005 END";
1918}
1919
1920/**
1921 * Feature: ImageEffect
1922 * Function: Test OH_ImageEffect_Stop with normal parameter
1923 * SubFunction: NA
1924 * FunctionPoints: NA
1925 * EnvConditions: NA
1926 * CaseDescription: Test OH_ImageEffect_Stop with normal parameter
1927 */
1928HWTEST_F(ImageEffectCApiUnittest, OHImageEffectStop001, TestSize.Level1)
1929{
1930    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectStop001 start";
1931
1932    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1933    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Stop(imageEffect);
1934    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Stop failed";
1935
1936    GTEST_LOG_(INFO) << "OHImageEffectStop001 success! result: " << errorCode;
1937    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectStop001 END";
1938}
1939
1940/**
1941 * Feature: ImageEffect
1942 * Function: Test OH_ImageEffect_Stop with empty parameter
1943 * SubFunction: NA
1944 * FunctionPoints: NA
1945 * EnvConditions: NA
1946 * CaseDescription: Test OH_ImageEffect_Stop with empty parameter
1947 */
1948HWTEST_F(ImageEffectCApiUnittest, OHImageEffectStop002, TestSize.Level1)
1949{
1950    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectStop002 start";
1951
1952    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Stop(nullptr);
1953    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Stop failed";
1954
1955    GTEST_LOG_(INFO) << "OHImageEffectStop002 success! result: " << errorCode;
1956    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectStop002 END";
1957}
1958
1959/**
1960 * Feature: ImageEffect
1961 * Function: Test OH_ImageEffect_Save with normal parameter
1962 * SubFunction: NA
1963 * FunctionPoints: NA
1964 * EnvConditions: NA
1965 * CaseDescription: Test OH_ImageEffect_Save with normal parameter
1966 */
1967HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSave001, TestSize.Level1)
1968{
1969    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSave001 start";
1970
1971    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1972    char *imageEffectInfo = nullptr;
1973    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
1974
1975    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Save failed";
1976
1977    GTEST_LOG_(INFO) << "OHImageEffectSave001 success! result: " << errorCode;
1978    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSave001 END";
1979}
1980
1981/**
1982 * Feature: ImageEffect
1983 * Function: Test OH_ImageEffect_Save with empty OH_ImageEffect parameter
1984 * SubFunction: NA
1985 * FunctionPoints: NA
1986 * EnvConditions: NA
1987 * CaseDescription: Test OH_ImageEffect_Save with empty OH_ImageEffect parameter
1988 */
1989HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSave002, TestSize.Level1)
1990{
1991    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSave002 start";
1992
1993    char *imageEffectInfo = nullptr;
1994    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Save(nullptr, &imageEffectInfo);
1995
1996    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Save failed";
1997
1998    GTEST_LOG_(INFO) << "OHImageEffectSave002 success! result: " << errorCode;
1999    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSave002 END";
2000}
2001
2002/**
2003 * Feature: ImageEffect
2004 * Function: Test OH_ImageEffect_Restore with normal parameter
2005 * SubFunction: NA
2006 * FunctionPoints: NA
2007 * EnvConditions: NA
2008 * CaseDescription: Test OH_ImageEffect_Restore with normal parameter
2009 */
2010HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRestore001, TestSize.Level1)
2011{
2012    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRestore001 start";
2013
2014    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2015    ASSERT_NE(imageEffect, nullptr) << "OH_ImageEffect_Restore failed";
2016    char *imageEffectInfo = nullptr;
2017    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2018    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Restore failed";
2019    imageEffect = OH_ImageEffect_Restore(imageEffectInfo);
2020    ASSERT_NE(imageEffect, nullptr) << "OH_ImageEffect_Restore failed";
2021
2022    GTEST_LOG_(INFO) << "OHImageEffectRestore001 success! result: " << errorCode;
2023    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRestore001 END";
2024}
2025
2026/**
2027 * Feature: ImageEffect
2028 * Function: Test OH_ImageEffect_Restore submethods OH_ImageEffect_Save with empty OH_ImageEffect parameter
2029 * SubFunction: NA
2030 * FunctionPoints: NA
2031 * EnvConditions: NA
2032 * CaseDescription: Test OH_ImageEffect_Restore submethods OH_ImageEffect_Save with empty OH_ImageEffect parameter
2033 */
2034HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRestore002, TestSize.Level1)
2035{
2036    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRestore002 start";
2037
2038    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2039    ASSERT_NE(imageEffect, nullptr) << "OH_ImageEffect_Restore failed";
2040    char *imageEffectInfo = nullptr;
2041    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Save(nullptr, &imageEffectInfo);
2042    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Restore failed";
2043    imageEffect = OH_ImageEffect_Restore(imageEffectInfo);
2044    ASSERT_EQ(imageEffect, nullptr) << "OH_ImageEffect_Restore failed";
2045
2046    GTEST_LOG_(INFO) << "OHImageEffectRestore002 success! result: " << errorCode;
2047    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRestore002 END";
2048}
2049
2050/**
2051 * Feature: ImageEffect
2052 * Function: Test OH_ImageEffect_Restore with empty parameter
2053 * SubFunction: NA
2054 * FunctionPoints: NA
2055 * EnvConditions: NA
2056 * CaseDescription: Test OH_ImageEffect_Restore with empty parameter
2057 */
2058HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRestore003, TestSize.Level1)
2059{
2060    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRestore003 start";
2061
2062    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2063    ASSERT_NE(imageEffect, nullptr) << "OH_ImageEffect_Restore failed";
2064    char *imageEffectInfo = nullptr;
2065    ImageEffect_ErrorCode errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2066    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_Restore failed";
2067    imageEffect = OH_ImageEffect_Restore(nullptr);
2068    ASSERT_EQ(imageEffect, nullptr) << "OH_ImageEffect_Restore failed";
2069
2070    GTEST_LOG_(INFO) << "OHImageEffectRestore003 success! result: " << errorCode;
2071    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectRestore003 END";
2072}
2073
2074/**
2075 * Feature: ImageEffect
2076 * Function: Test OH_ImageEffect_SetOutputSurface with normal parameter
2077 * SubFunction: NA
2078 * FunctionPoints: NA
2079 * EnvConditions: NA
2080 * CaseDescription: Test OH_ImageEffect_SetOutputSurface with normal parameter
2081 */
2082HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputSurface001, TestSize.Level1)
2083{
2084    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface001 start";
2085
2086    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2087    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetOutputSurface(imageEffect, nativeWindow_);
2088
2089    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputSurface failed";
2090
2091    GTEST_LOG_(INFO) << "OHImageEffectSetOutputSurface001 success! result: " << errorCode;
2092    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface001 END";
2093}
2094
2095/**
2096 * Feature: ImageEffect
2097 * Function: Test OH_ImageEffect_SetOutputSurface with all empty parameter
2098 * SubFunction: NA
2099 * FunctionPoints: NA
2100 * EnvConditions: NA
2101 * CaseDescription: Test OH_ImageEffect_SetOutputSurface with all empty parameter
2102 */
2103HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputSurface002, TestSize.Level1)
2104{
2105    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface002 start";
2106
2107    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetOutputSurface(nullptr, nullptr);
2108
2109    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputSurface failed";
2110
2111    GTEST_LOG_(INFO) << "OHImageEffectSetOutputSurface002 success! result: " << errorCode;
2112    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface002 END";
2113}
2114
2115/**
2116 * Feature: ImageEffect
2117 * Function: Test OH_ImageEffect_SetOutputSurface with empty OH_ImageEffect parameter
2118 * SubFunction: NA
2119 * FunctionPoints: NA
2120 * EnvConditions: NA
2121 * CaseDescription: Test OH_ImageEffect_SetOutputSurface with empty OH_ImageEffect parameter
2122 */
2123HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputSurface003, TestSize.Level1)
2124{
2125    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface003 start";
2126
2127    OHNativeWindow *nativeWindow = new OHNativeWindow();
2128    nativeWindow->surface = nullptr;
2129    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetOutputSurface(nullptr, nativeWindow);
2130
2131    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputSurface failed";
2132
2133    GTEST_LOG_(INFO) << "OHImageEffectSetOutputSurface003 success! result: " << errorCode;
2134    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface003 END";
2135}
2136
2137/**
2138 * Feature: ImageEffect
2139 * Function: Test OH_ImageEffect_SetOutputSurface with empty surfaceId parameter
2140 * SubFunction: NA
2141 * FunctionPoints: NA
2142 * EnvConditions: NA
2143 * CaseDescription: Test OH_ImageEffect_SetOutputSurface with empty surfaceId parameter
2144 */
2145HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputSurface004, TestSize.Level1)
2146{
2147    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface004 start";
2148
2149    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2150    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetOutputSurface(imageEffect, nullptr);
2151
2152    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputSurface failed";
2153
2154    GTEST_LOG_(INFO) << "OHImageEffectSetOutputSurface004 success! result: " << errorCode;
2155    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface004 END";
2156}
2157
2158/**
2159 * Feature: ImageEffect
2160 * Function: Test OH_ImageEffect_GetInputSurface with normal parameter
2161 * SubFunction: NA
2162 * FunctionPoints: NA
2163 * EnvConditions: NA
2164 * CaseDescription: Test OH_ImageEffect_GetInputSurface with normal parameter
2165 */
2166HWTEST_F(ImageEffectCApiUnittest, OHImageEffectGetInputSurface001, TestSize.Level1)
2167{
2168    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface001 start";
2169
2170    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2171    OHNativeWindow *nativeWindow = nullptr;
2172    ImageEffect_ErrorCode errorCode = OH_ImageEffect_GetInputSurface(imageEffect, &nativeWindow);
2173
2174    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_GetInputSurface failed";
2175    ASSERT_NE(nativeWindow, nullptr) << "OH_ImageEffect_GetInputSurface failed";
2176
2177    GTEST_LOG_(INFO) << "OHImageEffectGetInputSurface001 success! result: " << errorCode;
2178    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface001 END";
2179}
2180
2181/**
2182 * Feature: ImageEffect
2183 * Function: Test OH_ImageEffect_GetInputSurface with empty OH_ImageEffect parameter
2184 * SubFunction: NA
2185 * FunctionPoints: NA
2186 * EnvConditions: NA
2187 * CaseDescription: Test OH_ImageEffect_GetInputSurface with empty OH_ImageEffect parameter
2188 */
2189HWTEST_F(ImageEffectCApiUnittest, OHImageEffectGetInputSurface002, TestSize.Level1)
2190{
2191    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface002 start";
2192
2193    OHNativeWindow *nativeWindow = nullptr;
2194    ImageEffect_ErrorCode errorCode = OH_ImageEffect_GetInputSurface(nullptr, &nativeWindow);
2195
2196    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_GetInputSurface failed";
2197    ASSERT_EQ(nativeWindow, nullptr) << "OH_ImageEffect_GetInputSurface failed";
2198
2199    GTEST_LOG_(INFO) << "OHImageEffectGetInputSurface002 success! result: " << errorCode;
2200    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface002 END";
2201}
2202
2203/**
2204 * Feature: ImageEffect
2205 * Function: Test ImageEffectSaveAndRestore with normal parameter
2206 * SubFunction: NA
2207 * FunctionPoints: NA
2208 * EnvConditions: NA
2209 * CaseDescription: Test ImageEffectSaveAndRestore with normal parameter
2210 */
2211HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest001, TestSize.Level1)
2212{
2213    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest001 start";
2214
2215    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2216    ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Create failed";
2217
2218    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
2219    ASSERT_NE(filter, nullptr) << "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_AddFilter failed";
2220
2221    ImageEffect_Any value;
2222    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2223    value.dataValue.floatValue = 100.f;
2224    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2225    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2226        "ImageEffectSaveAndRestoreUnittest001 OH_EffectFilter_SetValue failed";
2227
2228    char *imageEffectInfo = nullptr;
2229    errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2230    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2231        "ImageEffectSaveAndRestoreUnittest001 OH_EffectFilter_SetValue failed";
2232
2233    ASSERT_NE(imageEffectInfo, nullptr) << "ImageEffectSaveAndRestoreUnittest001 imageEffectInfo is null";
2234    std::string info = imageEffectInfo;
2235
2236    errorCode = OH_ImageEffect_Release(imageEffect);
2237    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2238        "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Release failed";
2239
2240    imageEffect = OH_ImageEffect_Restore(info.c_str());
2241    ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Restore failed";
2242
2243    OH_EffectFilter *restoreFilter = OH_ImageEffect_GetFilter(imageEffect, 0);
2244    ASSERT_NE(restoreFilter, nullptr) << "ImageEffectSaveAndRestoreUnittest001: OH_ImageEffect_GetFilter failed";
2245
2246    ImageEffect_Any restoreValue;
2247    OH_EffectFilter_GetValue(restoreFilter, KEY_FILTER_INTENSITY, &restoreValue);
2248    ASSERT_FLOAT_EQ(restoreValue.dataValue.floatValue, 100.f) <<
2249        "ImageEffectSaveAndRestoreUnittest001 OH_EffectFilter_GetValue failed";
2250
2251    errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
2252        ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2253        "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_SetInputPixelmap failed";
2254
2255    errorCode = OH_ImageEffect_Start(imageEffect);
2256    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2257        "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Start failed";
2258
2259    errorCode = OH_ImageEffect_Release(imageEffect);
2260    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2261        "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Release failed";
2262
2263    GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest001 success! result: " << errorCode;
2264    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest001 END";
2265}
2266
2267/**
2268 * Feature: ImageEffect
2269 * Function: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_Create
2270 * SubFunction: NA
2271 * FunctionPoints: NA
2272 * EnvConditions: NA
2273 * CaseDescription: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_Create
2274 */
2275HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest002, TestSize.Level1)
2276{
2277    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest002 start";
2278
2279    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(nullptr, BRIGHTNESS_EFILTER);
2280    ASSERT_EQ(filter, nullptr) << "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_AddFilter failed";
2281
2282    ImageEffect_Any value;
2283    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2284    value.dataValue.floatValue = 100.f;
2285    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2286    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2287        "ImageEffectSaveAndRestoreUnittest002 OH_EffectFilter_SetValue failed";
2288
2289    char *imageEffectInfo = nullptr;
2290    errorCode = OH_ImageEffect_Save(nullptr, &imageEffectInfo);
2291    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2292        "ImageEffectSaveAndRestoreUnittest002 OH_EffectFilter_SetValue failed";
2293
2294    errorCode = OH_ImageEffect_Release(nullptr);
2295    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2296        "ImageEffectSaveAndRestoreUnittest00 OH_ImageEffect_Release failed";
2297
2298    errorCode = OH_ImageEffect_SetInputPixelmap(nullptr, pixelmapNative_);
2299    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2300        "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_SetInputPixelmap failed";
2301
2302    errorCode = OH_ImageEffect_Start(nullptr);
2303    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2304        "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_Start failed";
2305
2306    errorCode = OH_ImageEffect_Release(nullptr);
2307    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2308        "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_Release failed";
2309
2310    GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest002 success! result: " << errorCode;
2311    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest002 END";
2312}
2313
2314/**
2315 * Feature: ImageEffect
2316 * Function: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_AddFilter
2317 * SubFunction: NA
2318 * FunctionPoints: NA
2319 * EnvConditions: NA
2320 * CaseDescription: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_AddFilter
2321 */
2322HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest003, TestSize.Level1)
2323{
2324    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest003 start";
2325
2326    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2327    ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Create failed";
2328
2329    ImageEffect_Any value;
2330    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2331    value.dataValue.floatValue = 100.f;
2332    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(nullptr, KEY_FILTER_INTENSITY, &value);
2333    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2334        "ImageEffectSaveAndRestoreUnittest003 OH_EffectFilter_SetValue failed";
2335
2336    char *imageEffectInfo = nullptr;
2337    errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2338    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2339        "ImageEffectSaveAndRestoreUnittest003 OH_EffectFilter_SetValue failed";
2340    ASSERT_NE(imageEffectInfo, nullptr);
2341    std::string infoStr = imageEffectInfo;
2342
2343    errorCode = OH_ImageEffect_Release(imageEffect);
2344    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2345        "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Release failed";
2346
2347    imageEffect = OH_ImageEffect_Restore(infoStr.c_str());
2348    ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest00 OH_ImageEffect_Restore failed";
2349
2350    errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
2351        ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2352        "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_SetInputPixelmap failed";
2353
2354    errorCode = OH_ImageEffect_Start(imageEffect);
2355    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2356        "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Start failed";
2357
2358    errorCode = OH_ImageEffect_Release(imageEffect);
2359    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2360        "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Release failed";
2361
2362    GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest003 success! result: " << errorCode;
2363    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest003 END";
2364}
2365
2366/**
2367 * Feature: ImageEffect
2368 * Function: Test ImageEffectSaveAndRestore with empty inputPixelmap parameter
2369 * SubFunction: NA
2370 * FunctionPoints: NA
2371 * EnvConditions: NA
2372 * CaseDescription: Test ImageEffectSaveAndRestore with empty inputPixelmap parameter
2373 */
2374HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest004, TestSize.Level1)
2375{
2376    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest004 start";
2377
2378    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2379    ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Create failed";
2380
2381    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
2382    ASSERT_NE(filter, nullptr) << "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_AddFilter failed";
2383
2384    ImageEffect_Any value;
2385    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2386    value.dataValue.floatValue = 100.f;
2387    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2388    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2389        "ImageEffectSaveAndRestoreUnittest004 OH_EffectFilter_SetValue failed";
2390
2391    char *imageEffectInfo = nullptr;
2392    errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2393    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2394        "ImageEffectSaveAndRestoreUnittest004 OH_EffectFilter_SetValue failed";
2395
2396    ASSERT_NE(imageEffectInfo, nullptr);
2397    std::string info = imageEffectInfo;
2398
2399    errorCode = OH_ImageEffect_Release(imageEffect);
2400    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2401        "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Release failed";
2402
2403    imageEffect = OH_ImageEffect_Restore(info.c_str());
2404    ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Restore failed";
2405
2406    errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, nullptr);
2407    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2408        "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_SetInputPixelmap failed";
2409
2410    errorCode = OH_ImageEffect_Start(imageEffect);
2411    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2412        "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Start failed";
2413
2414    errorCode = OH_ImageEffect_Release(imageEffect);
2415    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2416        "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Release failed";
2417
2418    GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest004 success! result: " << errorCode;
2419    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest004 END";
2420}
2421
2422/**
2423 * Feature: ImageEffect
2424 * Function: Test ImageEffectSaveAndRestore with ContrastEFilter normal parameter
2425 * SubFunction: NA
2426 * FunctionPoints: NA
2427 * EnvConditions: NA
2428 * CaseDescription: Test ImageEffectSaveAndRestore with ContrastEFilter normal parameter
2429 */
2430HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest005, TestSize.Level1)
2431{
2432    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2433    ASSERT_NE(imageEffect, nullptr);
2434
2435    OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, CONTRAST_EFILTER);
2436    ASSERT_NE(filter, nullptr);
2437
2438    ImageEffect_Any value;
2439    value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2440    value.dataValue.floatValue = 200.f;
2441    ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2442    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2443
2444    ImageEffect_Any result;
2445    errorCode = OH_EffectFilter_GetValue(filter, KEY_FILTER_INTENSITY, &result);
2446    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2447    ASSERT_EQ(result.dataType, ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT);
2448    ASSERT_EQ(result.dataValue.floatValue, 100.f);
2449
2450    char *imageEffectInfo = nullptr;
2451    errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2452    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2453
2454    ASSERT_NE(imageEffectInfo, nullptr);
2455    std::string info = imageEffectInfo;
2456
2457    errorCode = OH_ImageEffect_Release(imageEffect);
2458    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2459
2460    imageEffect = OH_ImageEffect_Restore(info.c_str());
2461    ASSERT_NE(imageEffect, nullptr);
2462
2463    errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
2464    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2465
2466    std::shared_ptr<PixelMap> outputPixelmap = std::make_shared<MockPixelMap>();
2467    std::shared_ptr<OH_PixelmapNative> outputPixelmapNative = std::make_shared<OH_PixelmapNative>(outputPixelmap);
2468    errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, outputPixelmapNative.get());
2469    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2470
2471    errorCode = OH_ImageEffect_Start(imageEffect);
2472    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2473
2474    errorCode = OH_ImageEffect_Release(imageEffect);
2475    ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2476}
2477
2478/**
2479 * Feature: ImageEffect
2480 * Function: Test OH_ImageEffect_SetInputUri with empty uri parameter
2481 * SubFunction: NA
2482 * FunctionPoints: NA
2483 * EnvConditions: NA
2484 * CaseDescription: Test OH_ImageEffect_SetInputUri with empty uri parameter
2485 */
2486HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputUri001, TestSize.Level1)
2487{
2488    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputUri001 start";
2489    OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2490    ASSERT_NE(imageEffect, nullptr) << "OHImageEffectSetInputUri001 OH_ImageEffect_Create failed";
2491
2492    ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputUri(imageEffect, nullptr);
2493    ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetInputUri failed";
2494
2495    GTEST_LOG_(INFO) << "OHImageEffectSetInputUri001 success! result: " << errorCode;
2496    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputUri001 END";
2497}
2498
2499/**
2500 * Feature: ImageEffect
2501 * Function: Test OH_ImageEffect_FiltersSize with empty parameter
2502 * SubFunction: NA
2503 * FunctionPoints: NA
2504 * EnvConditions: NA
2505 * CaseDescription: Test OH_ImageEffect_FiltersSize with empty parameter
2506 */
2507HWTEST_F(ImageEffectCApiUnittest, OHImageEffectFiltersSize001, TestSize.Level1)
2508{
2509    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectFiltersSize001 start";
2510    int32_t res = OH_ImageEffect_GetFilterCount(nullptr);
2511    ASSERT_EQ(res, 0) << "OHImageEffectFiltersSize001 OH_ImageEffect_FiltersSize failed";
2512
2513    GTEST_LOG_(INFO) << "OHImageEffectFiltersSize001 success! result: " << res;
2514    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectFiltersSize001 END";
2515}
2516
2517/**
2518 * Feature: ImageEffect
2519 * Function: Test OH_ImageEffect_GetFilter with empty parameter
2520 * SubFunction: NA
2521 * FunctionPoints: NA
2522 * EnvConditions: NA
2523 * CaseDescription: Test OH_ImageEffect_GetFilter with empty parameter
2524 */
2525HWTEST_F(ImageEffectCApiUnittest, OH_ImageEffect_GetFilter001, TestSize.Level1)
2526{
2527    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter001 start";
2528    OH_EffectFilter *filter = OH_ImageEffect_GetFilter(nullptr, 0);
2529    ASSERT_EQ(filter, nullptr) << "OH_ImageEffect_GetFilter001 OH_ImageEffect_GetFilter failed";
2530
2531    GTEST_LOG_(INFO) << "OH_ImageEffect_GetFilter001 success! result: " << filter;
2532    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter001 END";
2533}
2534
2535/**
2536 * Feature: ImageEffect
2537 * Function: Test OH_ImageEffect_GetFilter with empty parameter and negative index
2538 * SubFunction: NA
2539 * FunctionPoints: NA
2540 * EnvConditions: NA
2541 * CaseDescription: Test OH_ImageEffect_GetFilter with empty parameter and negative index
2542 */
2543HWTEST_F(ImageEffectCApiUnittest, OH_ImageEffect_GetFilter002, TestSize.Level1)
2544{
2545    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter002 start";
2546    OH_EffectFilter *filter = OH_ImageEffect_GetFilter(nullptr, -1);
2547    ASSERT_EQ(filter, nullptr) << "OH_ImageEffect_GetFilter002 OH_ImageEffect_GetFilter failed";
2548
2549    GTEST_LOG_(INFO) << "OH_ImageEffect_GetFilter002 success! result: " << filter;
2550    GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter002 END";
2551}
2552} // namespace Effect
2553} // namespace Media
2554} // namespace OHOS