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
31 using namespace testing::ext;
32 using ::testing::A;
33 using ::testing::InSequence;
34 using ::testing::Mock;
35 using namespace OHOS::Media::Effect::Test;
36
37 static std::string g_jpgHdrPath;
38
39 namespace {
40 constexpr uint32_t CROP_FACTOR = 2;
41 }
42
43 namespace OHOS {
44 namespace Media {
45 namespace Effect {
SetUpTestCase()46 void 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
TearDownTestCase()55 void ImageEffectCApiUnittest::TearDownTestCase()
56 {
57 if (nativeWindow_ != nullptr) {
58 DestoryNativeWindow(nativeWindow_);
59 nativeWindow_ = nullptr;
60 }
61 consumerSurface_ = nullptr;
62 ohSurface_ = nullptr;
63 }
64
SetUp()65 void 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
TearDown()85 void 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 */
104 HWTEST_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 */
138 HWTEST_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 */
157 HWTEST_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 */
176 HWTEST_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 */
200 HWTEST_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 */
219 HWTEST_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 */
242 HWTEST_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 */
261 HWTEST_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 */
280 HWTEST_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 */
299 HWTEST_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 */
319 HWTEST_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 */
338 HWTEST_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 */
357 HWTEST_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 */
377 HWTEST_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 */
397 HWTEST_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 */
421 HWTEST_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 */
443 HWTEST_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 */
462 HWTEST_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 */
481 HWTEST_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 */
501 HWTEST_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 */
523 HWTEST_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 */
584 HWTEST_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 */
608 HWTEST_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 */
627 HWTEST_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 */
652 HWTEST_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 */
677 HWTEST_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 */
701 HWTEST_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 */
724 HWTEST_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 */
752 HWTEST_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 */
771 HWTEST_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 */
799 HWTEST_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 */
827 HWTEST_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 */
851 HWTEST_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 */
879 HWTEST_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 */
899 HWTEST_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 */
918 HWTEST_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 */
938 HWTEST_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 */
958 HWTEST_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 */
980 HWTEST_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 */
1001 HWTEST_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 */
1021 HWTEST_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 */
1040 HWTEST_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 */
1060 HWTEST_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 */
1095 HWTEST_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 */
1129 HWTEST_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 */
1163 HWTEST_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 */
1192 HWTEST_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 */
1236 HWTEST_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 */
1257 HWTEST_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 */
1276 HWTEST_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 */
1297 HWTEST_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 */
1317 HWTEST_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 */
1338 HWTEST_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 */
1357 HWTEST_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 */
1377 HWTEST_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 */
1397 HWTEST_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 */
1417 HWTEST_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 */
1436 HWTEST_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 */
1456 HWTEST_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 */
1475 HWTEST_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 */
1531 HWTEST_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 */
1576 HWTEST_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 */
1621 HWTEST_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 */
1666 HWTEST_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 */
1711 HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister001, TestSize.Level1)
1712 {
1713 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister001 start";
1714
1715 ImageEffect_FilterDelegate delegate = {
__anon84fd30b80202() 1716 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; },
__anon84fd30b80302() 1717 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1718 pushData(filter, src);
1719 return true;
1720 },
__anon84fd30b80402() 1721 .save = [](OH_EffectFilter *filter, char **info) { return true; },
__anon84fd30b80502() 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 */
1741 HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister002, TestSize.Level1)
1742 {
1743 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister002 start";
1744
1745 ImageEffect_FilterDelegate delegate = {
__anon84fd30b80602() 1746 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; },
__anon84fd30b80702() 1747 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1748 pushData(filter, src);
1749 return true;
1750 },
__anon84fd30b80802() 1751 .save = [](OH_EffectFilter *filter, char **info) { return true; },
__anon84fd30b80902() 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 */
1771 HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister003, TestSize.Level1)
1772 {
1773 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister003 start";
1774
1775 ImageEffect_FilterDelegate delegate = {
__anon84fd30b80a02() 1776 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return false; },
__anon84fd30b80b02() 1777 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1778 return false;
1779 },
__anon84fd30b80c02() 1780 .save = [](OH_EffectFilter *filter, char **info) { return false; },
__anon84fd30b80d02() 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 */
1800 HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister004, TestSize.Level1)
1801 {
1802 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister004 start";
1803
1804 ImageEffect_FilterDelegate delegate = {
__anon84fd30b80e02() 1805 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; },
__anon84fd30b80f02() 1806 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1807 pushData(filter, src);
1808 return true;
1809 },
__anon84fd30b81002() 1810 .save = [](OH_EffectFilter *filter, char **info) { return true; },
__anon84fd30b81102() 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 */
1830 HWTEST_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 */
1850 HWTEST_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 */
1870 HWTEST_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 */
1890 HWTEST_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 */
1909 HWTEST_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 */
1928 HWTEST_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 */
1948 HWTEST_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 */
1967 HWTEST_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 */
1989 HWTEST_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 */
2010 HWTEST_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 */
2034 HWTEST_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 */
2058 HWTEST_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 */
2082 HWTEST_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 */
2103 HWTEST_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 */
2123 HWTEST_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 delete nativeWindow;
2131 nativeWindow = nullptr;
2132
2133 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputSurface failed";
2134
2135 GTEST_LOG_(INFO) << "OHImageEffectSetOutputSurface003 success! result: " << errorCode;
2136 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface003 END";
2137 }
2138
2139 /**
2140 * Feature: ImageEffect
2141 * Function: Test OH_ImageEffect_SetOutputSurface with empty surfaceId parameter
2142 * SubFunction: NA
2143 * FunctionPoints: NA
2144 * EnvConditions: NA
2145 * CaseDescription: Test OH_ImageEffect_SetOutputSurface with empty surfaceId parameter
2146 */
2147 HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputSurface004, TestSize.Level1)
2148 {
2149 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface004 start";
2150
2151 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2152 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetOutputSurface(imageEffect, nullptr);
2153
2154 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputSurface failed";
2155
2156 GTEST_LOG_(INFO) << "OHImageEffectSetOutputSurface004 success! result: " << errorCode;
2157 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface004 END";
2158 }
2159
2160 /**
2161 * Feature: ImageEffect
2162 * Function: Test OH_ImageEffect_GetInputSurface with normal parameter
2163 * SubFunction: NA
2164 * FunctionPoints: NA
2165 * EnvConditions: NA
2166 * CaseDescription: Test OH_ImageEffect_GetInputSurface with normal parameter
2167 */
2168 HWTEST_F(ImageEffectCApiUnittest, OHImageEffectGetInputSurface001, TestSize.Level1)
2169 {
2170 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface001 start";
2171
2172 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2173 OHNativeWindow *nativeWindow = nullptr;
2174 ImageEffect_ErrorCode errorCode = OH_ImageEffect_GetInputSurface(imageEffect, &nativeWindow);
2175
2176 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_GetInputSurface failed";
2177 ASSERT_NE(nativeWindow, nullptr) << "OH_ImageEffect_GetInputSurface failed";
2178
2179 GTEST_LOG_(INFO) << "OHImageEffectGetInputSurface001 success! result: " << errorCode;
2180 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface001 END";
2181 }
2182
2183 /**
2184 * Feature: ImageEffect
2185 * Function: Test OH_ImageEffect_GetInputSurface with empty OH_ImageEffect parameter
2186 * SubFunction: NA
2187 * FunctionPoints: NA
2188 * EnvConditions: NA
2189 * CaseDescription: Test OH_ImageEffect_GetInputSurface with empty OH_ImageEffect parameter
2190 */
2191 HWTEST_F(ImageEffectCApiUnittest, OHImageEffectGetInputSurface002, TestSize.Level1)
2192 {
2193 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface002 start";
2194
2195 OHNativeWindow *nativeWindow = nullptr;
2196 ImageEffect_ErrorCode errorCode = OH_ImageEffect_GetInputSurface(nullptr, &nativeWindow);
2197
2198 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_GetInputSurface failed";
2199 ASSERT_EQ(nativeWindow, nullptr) << "OH_ImageEffect_GetInputSurface failed";
2200
2201 GTEST_LOG_(INFO) << "OHImageEffectGetInputSurface002 success! result: " << errorCode;
2202 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface002 END";
2203 }
2204
2205 /**
2206 * Feature: ImageEffect
2207 * Function: Test ImageEffectSaveAndRestore with normal parameter
2208 * SubFunction: NA
2209 * FunctionPoints: NA
2210 * EnvConditions: NA
2211 * CaseDescription: Test ImageEffectSaveAndRestore with normal parameter
2212 */
2213 HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest001, TestSize.Level1)
2214 {
2215 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest001 start";
2216
2217 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2218 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Create failed";
2219
2220 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
2221 ASSERT_NE(filter, nullptr) << "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_AddFilter failed";
2222
2223 ImageEffect_Any value;
2224 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2225 value.dataValue.floatValue = 100.f;
2226 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2227 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2228 "ImageEffectSaveAndRestoreUnittest001 OH_EffectFilter_SetValue failed";
2229
2230 char *imageEffectInfo = nullptr;
2231 errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2232 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2233 "ImageEffectSaveAndRestoreUnittest001 OH_EffectFilter_SetValue failed";
2234
2235 ASSERT_NE(imageEffectInfo, nullptr) << "ImageEffectSaveAndRestoreUnittest001 imageEffectInfo is null";
2236 std::string info = imageEffectInfo;
2237
2238 errorCode = OH_ImageEffect_Release(imageEffect);
2239 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2240 "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Release failed";
2241
2242 imageEffect = OH_ImageEffect_Restore(info.c_str());
2243 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Restore failed";
2244
2245 OH_EffectFilter *restoreFilter = OH_ImageEffect_GetFilter(imageEffect, 0);
2246 ASSERT_NE(restoreFilter, nullptr) << "ImageEffectSaveAndRestoreUnittest001: OH_ImageEffect_GetFilter failed";
2247
2248 ImageEffect_Any restoreValue;
2249 OH_EffectFilter_GetValue(restoreFilter, KEY_FILTER_INTENSITY, &restoreValue);
2250 ASSERT_FLOAT_EQ(restoreValue.dataValue.floatValue, 100.f) <<
2251 "ImageEffectSaveAndRestoreUnittest001 OH_EffectFilter_GetValue failed";
2252
2253 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
2254 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2255 "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_SetInputPixelmap failed";
2256
2257 errorCode = OH_ImageEffect_Start(imageEffect);
2258 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2259 "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Start failed";
2260
2261 errorCode = OH_ImageEffect_Release(imageEffect);
2262 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2263 "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Release failed";
2264
2265 GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest001 success! result: " << errorCode;
2266 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest001 END";
2267 }
2268
2269 /**
2270 * Feature: ImageEffect
2271 * Function: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_Create
2272 * SubFunction: NA
2273 * FunctionPoints: NA
2274 * EnvConditions: NA
2275 * CaseDescription: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_Create
2276 */
2277 HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest002, TestSize.Level1)
2278 {
2279 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest002 start";
2280
2281 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(nullptr, BRIGHTNESS_EFILTER);
2282 ASSERT_EQ(filter, nullptr) << "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_AddFilter failed";
2283
2284 ImageEffect_Any value;
2285 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2286 value.dataValue.floatValue = 100.f;
2287 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2288 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2289 "ImageEffectSaveAndRestoreUnittest002 OH_EffectFilter_SetValue failed";
2290
2291 char *imageEffectInfo = nullptr;
2292 errorCode = OH_ImageEffect_Save(nullptr, &imageEffectInfo);
2293 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2294 "ImageEffectSaveAndRestoreUnittest002 OH_EffectFilter_SetValue failed";
2295
2296 errorCode = OH_ImageEffect_Release(nullptr);
2297 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2298 "ImageEffectSaveAndRestoreUnittest00 OH_ImageEffect_Release failed";
2299
2300 errorCode = OH_ImageEffect_SetInputPixelmap(nullptr, pixelmapNative_);
2301 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2302 "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_SetInputPixelmap failed";
2303
2304 errorCode = OH_ImageEffect_Start(nullptr);
2305 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2306 "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_Start failed";
2307
2308 errorCode = OH_ImageEffect_Release(nullptr);
2309 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2310 "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_Release failed";
2311
2312 GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest002 success! result: " << errorCode;
2313 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest002 END";
2314 }
2315
2316 /**
2317 * Feature: ImageEffect
2318 * Function: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_AddFilter
2319 * SubFunction: NA
2320 * FunctionPoints: NA
2321 * EnvConditions: NA
2322 * CaseDescription: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_AddFilter
2323 */
2324 HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest003, TestSize.Level1)
2325 {
2326 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest003 start";
2327
2328 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2329 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Create failed";
2330
2331 ImageEffect_Any value;
2332 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2333 value.dataValue.floatValue = 100.f;
2334 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(nullptr, KEY_FILTER_INTENSITY, &value);
2335 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2336 "ImageEffectSaveAndRestoreUnittest003 OH_EffectFilter_SetValue failed";
2337
2338 char *imageEffectInfo = nullptr;
2339 errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2340 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2341 "ImageEffectSaveAndRestoreUnittest003 OH_EffectFilter_SetValue failed";
2342 ASSERT_NE(imageEffectInfo, nullptr);
2343 std::string infoStr = imageEffectInfo;
2344
2345 errorCode = OH_ImageEffect_Release(imageEffect);
2346 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2347 "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Release failed";
2348
2349 imageEffect = OH_ImageEffect_Restore(infoStr.c_str());
2350 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest00 OH_ImageEffect_Restore failed";
2351
2352 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
2353 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2354 "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_SetInputPixelmap failed";
2355
2356 errorCode = OH_ImageEffect_Start(imageEffect);
2357 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2358 "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Start failed";
2359
2360 errorCode = OH_ImageEffect_Release(imageEffect);
2361 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2362 "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Release failed";
2363
2364 GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest003 success! result: " << errorCode;
2365 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest003 END";
2366 }
2367
2368 /**
2369 * Feature: ImageEffect
2370 * Function: Test ImageEffectSaveAndRestore with empty inputPixelmap parameter
2371 * SubFunction: NA
2372 * FunctionPoints: NA
2373 * EnvConditions: NA
2374 * CaseDescription: Test ImageEffectSaveAndRestore with empty inputPixelmap parameter
2375 */
2376 HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest004, TestSize.Level1)
2377 {
2378 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest004 start";
2379
2380 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2381 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Create failed";
2382
2383 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
2384 ASSERT_NE(filter, nullptr) << "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_AddFilter failed";
2385
2386 ImageEffect_Any value;
2387 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2388 value.dataValue.floatValue = 100.f;
2389 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2390 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2391 "ImageEffectSaveAndRestoreUnittest004 OH_EffectFilter_SetValue failed";
2392
2393 char *imageEffectInfo = nullptr;
2394 errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2395 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2396 "ImageEffectSaveAndRestoreUnittest004 OH_EffectFilter_SetValue failed";
2397
2398 ASSERT_NE(imageEffectInfo, nullptr);
2399 std::string info = imageEffectInfo;
2400
2401 errorCode = OH_ImageEffect_Release(imageEffect);
2402 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2403 "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Release failed";
2404
2405 imageEffect = OH_ImageEffect_Restore(info.c_str());
2406 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Restore failed";
2407
2408 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, nullptr);
2409 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2410 "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_SetInputPixelmap failed";
2411
2412 errorCode = OH_ImageEffect_Start(imageEffect);
2413 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2414 "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Start failed";
2415
2416 errorCode = OH_ImageEffect_Release(imageEffect);
2417 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2418 "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Release failed";
2419
2420 GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest004 success! result: " << errorCode;
2421 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest004 END";
2422 }
2423
2424 /**
2425 * Feature: ImageEffect
2426 * Function: Test ImageEffectSaveAndRestore with ContrastEFilter normal parameter
2427 * SubFunction: NA
2428 * FunctionPoints: NA
2429 * EnvConditions: NA
2430 * CaseDescription: Test ImageEffectSaveAndRestore with ContrastEFilter normal parameter
2431 */
2432 HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest005, TestSize.Level1)
2433 {
2434 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2435 ASSERT_NE(imageEffect, nullptr);
2436
2437 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, CONTRAST_EFILTER);
2438 ASSERT_NE(filter, nullptr);
2439
2440 ImageEffect_Any value;
2441 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2442 value.dataValue.floatValue = 200.f;
2443 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2444 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2445
2446 ImageEffect_Any result;
2447 errorCode = OH_EffectFilter_GetValue(filter, KEY_FILTER_INTENSITY, &result);
2448 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2449 ASSERT_EQ(result.dataType, ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT);
2450 ASSERT_EQ(result.dataValue.floatValue, 100.f);
2451
2452 char *imageEffectInfo = nullptr;
2453 errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2454 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2455
2456 ASSERT_NE(imageEffectInfo, nullptr);
2457 std::string info = imageEffectInfo;
2458
2459 errorCode = OH_ImageEffect_Release(imageEffect);
2460 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2461
2462 imageEffect = OH_ImageEffect_Restore(info.c_str());
2463 ASSERT_NE(imageEffect, nullptr);
2464
2465 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
2466 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2467
2468 std::shared_ptr<PixelMap> outputPixelmap = std::make_shared<MockPixelMap>();
2469 std::shared_ptr<OH_PixelmapNative> outputPixelmapNative = std::make_shared<OH_PixelmapNative>(outputPixelmap);
2470 errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, outputPixelmapNative.get());
2471 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2472
2473 errorCode = OH_ImageEffect_Start(imageEffect);
2474 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2475
2476 errorCode = OH_ImageEffect_Release(imageEffect);
2477 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2478 }
2479
2480 /**
2481 * Feature: ImageEffect
2482 * Function: Test OH_ImageEffect_SetInputUri with empty uri parameter
2483 * SubFunction: NA
2484 * FunctionPoints: NA
2485 * EnvConditions: NA
2486 * CaseDescription: Test OH_ImageEffect_SetInputUri with empty uri parameter
2487 */
2488 HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputUri001, TestSize.Level1)
2489 {
2490 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputUri001 start";
2491 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2492 ASSERT_NE(imageEffect, nullptr) << "OHImageEffectSetInputUri001 OH_ImageEffect_Create failed";
2493
2494 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputUri(imageEffect, nullptr);
2495 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetInputUri failed";
2496
2497 GTEST_LOG_(INFO) << "OHImageEffectSetInputUri001 success! result: " << errorCode;
2498 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputUri001 END";
2499 }
2500
2501 /**
2502 * Feature: ImageEffect
2503 * Function: Test OH_ImageEffect_FiltersSize with empty parameter
2504 * SubFunction: NA
2505 * FunctionPoints: NA
2506 * EnvConditions: NA
2507 * CaseDescription: Test OH_ImageEffect_FiltersSize with empty parameter
2508 */
2509 HWTEST_F(ImageEffectCApiUnittest, OHImageEffectFiltersSize001, TestSize.Level1)
2510 {
2511 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectFiltersSize001 start";
2512 int32_t res = OH_ImageEffect_GetFilterCount(nullptr);
2513 ASSERT_EQ(res, 0) << "OHImageEffectFiltersSize001 OH_ImageEffect_FiltersSize failed";
2514
2515 GTEST_LOG_(INFO) << "OHImageEffectFiltersSize001 success! result: " << res;
2516 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectFiltersSize001 END";
2517 }
2518
2519 /**
2520 * Feature: ImageEffect
2521 * Function: Test OH_ImageEffect_GetFilter with empty parameter
2522 * SubFunction: NA
2523 * FunctionPoints: NA
2524 * EnvConditions: NA
2525 * CaseDescription: Test OH_ImageEffect_GetFilter with empty parameter
2526 */
2527 HWTEST_F(ImageEffectCApiUnittest, OH_ImageEffect_GetFilter001, TestSize.Level1)
2528 {
2529 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter001 start";
2530 OH_EffectFilter *filter = OH_ImageEffect_GetFilter(nullptr, 0);
2531 ASSERT_EQ(filter, nullptr) << "OH_ImageEffect_GetFilter001 OH_ImageEffect_GetFilter failed";
2532
2533 GTEST_LOG_(INFO) << "OH_ImageEffect_GetFilter001 success! result: " << filter;
2534 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter001 END";
2535 }
2536
2537 /**
2538 * Feature: ImageEffect
2539 * Function: Test OH_ImageEffect_GetFilter with empty parameter and negative index
2540 * SubFunction: NA
2541 * FunctionPoints: NA
2542 * EnvConditions: NA
2543 * CaseDescription: Test OH_ImageEffect_GetFilter with empty parameter and negative index
2544 */
2545 HWTEST_F(ImageEffectCApiUnittest, OH_ImageEffect_GetFilter002, TestSize.Level1)
2546 {
2547 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter002 start";
2548 OH_EffectFilter *filter = OH_ImageEffect_GetFilter(nullptr, -1);
2549 ASSERT_EQ(filter, nullptr) << "OH_ImageEffect_GetFilter002 OH_ImageEffect_GetFilter failed";
2550
2551 GTEST_LOG_(INFO) << "OH_ImageEffect_GetFilter002 success! result: " << filter;
2552 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter002 END";
2553 }
2554 } // namespace Effect
2555 } // namespace Media
2556 } // namespace OHOS
