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 */
HWTEST_F(ImageEffectCApiUnittest, Image_effect_capi_unittest_001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectCreate001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectCreate002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectConfigure001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectConfigure002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectConfigure003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterCreate001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterCreate002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterCreate003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter004, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter005, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectAddFilter006, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRemoveFilter001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRemoveFilter002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRemoveFilter003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRemoveFilter004, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRemoveFilter005, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectCRUDFilter001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue004, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue005, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterSetValue006, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue004, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue005, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterGetValue006, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender004, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender005, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRender006, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRelease001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRelease002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRelease003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectSingleFilterUnittest001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectSingleFilterUnittest002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectSingleFilterUnittest003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectSingleFilterUnittest004, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectSingleFilterUnittest005, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputPixelmap001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputPixelmap002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputPixelmap003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputPixelmap004, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputPixelMap001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputPixelMap002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputPixelMap003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputPixelMap004, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectStart001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectStart002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRelease001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRelease002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectStandardFilterUnittest001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectStandardFilterUnittest002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectStandardFilterUnittest003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectStandardFilterUnittest004, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectStandardFilterUnittest005, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister001, TestSize.Level1)1711 HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister001, TestSize.Level1)
1712 {
1713 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister001 start";
1714
1715 ImageEffect_FilterDelegate delegate = {
1716 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; },
1717 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1718 pushData(filter, src);
1719 return true;
1720 },
1721 .save = [](OH_EffectFilter *filter, char **info) { return true; },
1722 .restore = [](const char *info) { return OH_EffectFilter_Create("CustomBrightnessEFilter"); }
1723 };
1724
1725 ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate);
1726 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1727 "OHEFilterRegister001 OH_EffectFilter_Register failed";
1728
1729 GTEST_LOG_(INFO) << "OHEFilterRegister001 success! result: " << errorCode;
1730 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister001 END";
1731 }
1732
1733 /**
1734 * Feature: ImageEffect
1735 * Function: Test OH_EffectFilter_Register with ImageEffect_FilterDelegate not exist OH_EffectFilter parameter
1736 * SubFunction: NA
1737 * FunctionPoints: NA
1738 * EnvConditions: NA
1739 * CaseDescription: Test OH_EffectFilter_Register with ImageEffect_FilterDelegate not exist OH_EffectFilter parameter
1740 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister002, TestSize.Level1)1741 HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister002, TestSize.Level1)
1742 {
1743 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister002 start";
1744
1745 ImageEffect_FilterDelegate delegate = {
1746 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; },
1747 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1748 pushData(filter, src);
1749 return true;
1750 },
1751 .save = [](OH_EffectFilter *filter, char **info) { return true; },
1752 .restore = [](const char *info) { return OH_EffectFilter_Create("CustomTestEFilter"); }
1753 };
1754
1755 ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate);
1756 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1757 "OHEFilterRegister002 OH_EffectFilter_Register failed";
1758
1759 GTEST_LOG_(INFO) << "OHEFilterRegister002 success! result: " << errorCode;
1760 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister002 END";
1761 }
1762
1763 /**
1764 * Feature: ImageEffect
1765 * Function: Test OH_EffectFilter_Register with ImageEffect_FilterDelegate all false parameter
1766 * SubFunction: NA
1767 * FunctionPoints: NA
1768 * EnvConditions: NA
1769 * CaseDescription: Test OH_EffectFilter_Register with ImageEffect_FilterDelegate all false parameter
1770 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister003, TestSize.Level1)1771 HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister003, TestSize.Level1)
1772 {
1773 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister003 start";
1774
1775 ImageEffect_FilterDelegate delegate = {
1776 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return false; },
1777 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1778 return false;
1779 },
1780 .save = [](OH_EffectFilter *filter, char **info) { return false; },
1781 .restore = [](const char *info) { return OH_EffectFilter_Create("CustomBrightnessEFilter"); }
1782 };
1783
1784 ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate);
1785 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1786 "OHEFilterRegister003 OH_EffectFilter_Register failed";
1787
1788 GTEST_LOG_(INFO) << "OHEFilterRegister003 success! result: " << errorCode;
1789 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister003 END";
1790 }
1791
1792 /**
1793 * Feature: ImageEffect
1794 * Function: Test OH_EffectFilter_Register with OH_EffectInfo not exist OH_EffectFilter parameter
1795 * SubFunction: NA
1796 * FunctionPoints: NA
1797 * EnvConditions: NA
1798 * CaseDescription: Test OH_EffectFilter_Register with OH_EffectInfo not exist OH_EffectFilter parameter
1799 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister004, TestSize.Level1)1800 HWTEST_F(ImageEffectCApiUnittest, OHEFilterRegister004, TestSize.Level1)
1801 {
1802 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister004 start";
1803
1804 ImageEffect_FilterDelegate delegate = {
1805 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; },
1806 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) {
1807 pushData(filter, src);
1808 return true;
1809 },
1810 .save = [](OH_EffectFilter *filter, char **info) { return true; },
1811 .restore = [](const char *info) { return OH_EffectFilter_Create("CustomBrightnessEFilter"); }
1812 };
1813
1814 ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate);
1815 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
1816 "OHEFilterRegister004 OH_EffectFilter_Register failed";
1817
1818 GTEST_LOG_(INFO) << "OHEFilterRegister004 success! result: " << errorCode;
1819 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHEFilterRegister004 END";
1820 }
1821
1822 /**
1823 * Feature: ImageEffect
1824 * Function: Test OH_EffectFilter_LookupFilterInfo with normal parameter
1825 * SubFunction: NA
1826 * FunctionPoints: NA
1827 * EnvConditions: NA
1828 * CaseDescription: Test OH_EffectFilter_LookupFilterInfo with normal parameter
1829 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterLookupFilterInfo001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterLookupFilterInfo002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterLookupFilterInfo003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterLookupFilterInfo004, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHEFilterLookupFilterInfo005, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectStop001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectStop002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSave001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSave002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRestore001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRestore002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectRestore003, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputSurface001, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputSurface002, TestSize.Level1)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 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputSurface003, TestSize.Level1)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
2131 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputSurface failed";
2132
2133 GTEST_LOG_(INFO) << "OHImageEffectSetOutputSurface003 success! result: " << errorCode;
2134 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface003 END";
2135 }
2136
2137 /**
2138 * Feature: ImageEffect
2139 * Function: Test OH_ImageEffect_SetOutputSurface with empty surfaceId parameter
2140 * SubFunction: NA
2141 * FunctionPoints: NA
2142 * EnvConditions: NA
2143 * CaseDescription: Test OH_ImageEffect_SetOutputSurface with empty surfaceId parameter
2144 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputSurface004, TestSize.Level1)2145 HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetOutputSurface004, TestSize.Level1)
2146 {
2147 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface004 start";
2148
2149 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2150 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetOutputSurface(imageEffect, nullptr);
2151
2152 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetOutputSurface failed";
2153
2154 GTEST_LOG_(INFO) << "OHImageEffectSetOutputSurface004 success! result: " << errorCode;
2155 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetOutputSurface004 END";
2156 }
2157
2158 /**
2159 * Feature: ImageEffect
2160 * Function: Test OH_ImageEffect_GetInputSurface with normal parameter
2161 * SubFunction: NA
2162 * FunctionPoints: NA
2163 * EnvConditions: NA
2164 * CaseDescription: Test OH_ImageEffect_GetInputSurface with normal parameter
2165 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectGetInputSurface001, TestSize.Level1)2166 HWTEST_F(ImageEffectCApiUnittest, OHImageEffectGetInputSurface001, TestSize.Level1)
2167 {
2168 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface001 start";
2169
2170 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2171 OHNativeWindow *nativeWindow = nullptr;
2172 ImageEffect_ErrorCode errorCode = OH_ImageEffect_GetInputSurface(imageEffect, &nativeWindow);
2173
2174 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_GetInputSurface failed";
2175 ASSERT_NE(nativeWindow, nullptr) << "OH_ImageEffect_GetInputSurface failed";
2176
2177 GTEST_LOG_(INFO) << "OHImageEffectGetInputSurface001 success! result: " << errorCode;
2178 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface001 END";
2179 }
2180
2181 /**
2182 * Feature: ImageEffect
2183 * Function: Test OH_ImageEffect_GetInputSurface with empty OH_ImageEffect parameter
2184 * SubFunction: NA
2185 * FunctionPoints: NA
2186 * EnvConditions: NA
2187 * CaseDescription: Test OH_ImageEffect_GetInputSurface with empty OH_ImageEffect parameter
2188 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectGetInputSurface002, TestSize.Level1)2189 HWTEST_F(ImageEffectCApiUnittest, OHImageEffectGetInputSurface002, TestSize.Level1)
2190 {
2191 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface002 start";
2192
2193 OHNativeWindow *nativeWindow = nullptr;
2194 ImageEffect_ErrorCode errorCode = OH_ImageEffect_GetInputSurface(nullptr, &nativeWindow);
2195
2196 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_GetInputSurface failed";
2197 ASSERT_EQ(nativeWindow, nullptr) << "OH_ImageEffect_GetInputSurface failed";
2198
2199 GTEST_LOG_(INFO) << "OHImageEffectGetInputSurface002 success! result: " << errorCode;
2200 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectGetInputSurface002 END";
2201 }
2202
2203 /**
2204 * Feature: ImageEffect
2205 * Function: Test ImageEffectSaveAndRestore with normal parameter
2206 * SubFunction: NA
2207 * FunctionPoints: NA
2208 * EnvConditions: NA
2209 * CaseDescription: Test ImageEffectSaveAndRestore with normal parameter
2210 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest001, TestSize.Level1)2211 HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest001, TestSize.Level1)
2212 {
2213 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest001 start";
2214
2215 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2216 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Create failed";
2217
2218 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
2219 ASSERT_NE(filter, nullptr) << "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_AddFilter failed";
2220
2221 ImageEffect_Any value;
2222 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2223 value.dataValue.floatValue = 100.f;
2224 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2225 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2226 "ImageEffectSaveAndRestoreUnittest001 OH_EffectFilter_SetValue failed";
2227
2228 char *imageEffectInfo = nullptr;
2229 errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2230 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2231 "ImageEffectSaveAndRestoreUnittest001 OH_EffectFilter_SetValue failed";
2232
2233 ASSERT_NE(imageEffectInfo, nullptr) << "ImageEffectSaveAndRestoreUnittest001 imageEffectInfo is null";
2234 std::string info = imageEffectInfo;
2235
2236 errorCode = OH_ImageEffect_Release(imageEffect);
2237 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2238 "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Release failed";
2239
2240 imageEffect = OH_ImageEffect_Restore(info.c_str());
2241 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Restore failed";
2242
2243 OH_EffectFilter *restoreFilter = OH_ImageEffect_GetFilter(imageEffect, 0);
2244 ASSERT_NE(restoreFilter, nullptr) << "ImageEffectSaveAndRestoreUnittest001: OH_ImageEffect_GetFilter failed";
2245
2246 ImageEffect_Any restoreValue;
2247 OH_EffectFilter_GetValue(restoreFilter, KEY_FILTER_INTENSITY, &restoreValue);
2248 ASSERT_FLOAT_EQ(restoreValue.dataValue.floatValue, 100.f) <<
2249 "ImageEffectSaveAndRestoreUnittest001 OH_EffectFilter_GetValue failed";
2250
2251 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
2252 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2253 "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_SetInputPixelmap failed";
2254
2255 errorCode = OH_ImageEffect_Start(imageEffect);
2256 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2257 "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Start failed";
2258
2259 errorCode = OH_ImageEffect_Release(imageEffect);
2260 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2261 "ImageEffectSaveAndRestoreUnittest001 OH_ImageEffect_Release failed";
2262
2263 GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest001 success! result: " << errorCode;
2264 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest001 END";
2265 }
2266
2267 /**
2268 * Feature: ImageEffect
2269 * Function: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_Create
2270 * SubFunction: NA
2271 * FunctionPoints: NA
2272 * EnvConditions: NA
2273 * CaseDescription: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_Create
2274 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest002, TestSize.Level1)2275 HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest002, TestSize.Level1)
2276 {
2277 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest002 start";
2278
2279 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(nullptr, BRIGHTNESS_EFILTER);
2280 ASSERT_EQ(filter, nullptr) << "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_AddFilter failed";
2281
2282 ImageEffect_Any value;
2283 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2284 value.dataValue.floatValue = 100.f;
2285 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2286 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2287 "ImageEffectSaveAndRestoreUnittest002 OH_EffectFilter_SetValue failed";
2288
2289 char *imageEffectInfo = nullptr;
2290 errorCode = OH_ImageEffect_Save(nullptr, &imageEffectInfo);
2291 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2292 "ImageEffectSaveAndRestoreUnittest002 OH_EffectFilter_SetValue failed";
2293
2294 errorCode = OH_ImageEffect_Release(nullptr);
2295 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2296 "ImageEffectSaveAndRestoreUnittest00 OH_ImageEffect_Release failed";
2297
2298 errorCode = OH_ImageEffect_SetInputPixelmap(nullptr, pixelmapNative_);
2299 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2300 "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_SetInputPixelmap failed";
2301
2302 errorCode = OH_ImageEffect_Start(nullptr);
2303 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2304 "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_Start failed";
2305
2306 errorCode = OH_ImageEffect_Release(nullptr);
2307 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2308 "ImageEffectSaveAndRestoreUnittest002 OH_ImageEffect_Release failed";
2309
2310 GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest002 success! result: " << errorCode;
2311 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest002 END";
2312 }
2313
2314 /**
2315 * Feature: ImageEffect
2316 * Function: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_AddFilter
2317 * SubFunction: NA
2318 * FunctionPoints: NA
2319 * EnvConditions: NA
2320 * CaseDescription: Test ImageEffectSaveAndRestore unobstructed func OH_ImageEffect_AddFilter
2321 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest003, TestSize.Level1)2322 HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest003, TestSize.Level1)
2323 {
2324 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest003 start";
2325
2326 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2327 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Create failed";
2328
2329 ImageEffect_Any value;
2330 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2331 value.dataValue.floatValue = 100.f;
2332 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(nullptr, KEY_FILTER_INTENSITY, &value);
2333 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2334 "ImageEffectSaveAndRestoreUnittest003 OH_EffectFilter_SetValue failed";
2335
2336 char *imageEffectInfo = nullptr;
2337 errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2338 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2339 "ImageEffectSaveAndRestoreUnittest003 OH_EffectFilter_SetValue failed";
2340 ASSERT_NE(imageEffectInfo, nullptr);
2341 std::string infoStr = imageEffectInfo;
2342
2343 errorCode = OH_ImageEffect_Release(imageEffect);
2344 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2345 "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Release failed";
2346
2347 imageEffect = OH_ImageEffect_Restore(infoStr.c_str());
2348 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest00 OH_ImageEffect_Restore failed";
2349
2350 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
2351 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2352 "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_SetInputPixelmap failed";
2353
2354 errorCode = OH_ImageEffect_Start(imageEffect);
2355 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2356 "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Start failed";
2357
2358 errorCode = OH_ImageEffect_Release(imageEffect);
2359 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2360 "ImageEffectSaveAndRestoreUnittest003 OH_ImageEffect_Release failed";
2361
2362 GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest003 success! result: " << errorCode;
2363 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest003 END";
2364 }
2365
2366 /**
2367 * Feature: ImageEffect
2368 * Function: Test ImageEffectSaveAndRestore with empty inputPixelmap parameter
2369 * SubFunction: NA
2370 * FunctionPoints: NA
2371 * EnvConditions: NA
2372 * CaseDescription: Test ImageEffectSaveAndRestore with empty inputPixelmap parameter
2373 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest004, TestSize.Level1)2374 HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest004, TestSize.Level1)
2375 {
2376 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest ImageEffectSaveAndRestoreUnittest004 start";
2377
2378 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2379 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Create failed";
2380
2381 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER);
2382 ASSERT_NE(filter, nullptr) << "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_AddFilter failed";
2383
2384 ImageEffect_Any value;
2385 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2386 value.dataValue.floatValue = 100.f;
2387 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2388 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2389 "ImageEffectSaveAndRestoreUnittest004 OH_EffectFilter_SetValue failed";
2390
2391 char *imageEffectInfo = nullptr;
2392 errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2393 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2394 "ImageEffectSaveAndRestoreUnittest004 OH_EffectFilter_SetValue failed";
2395
2396 ASSERT_NE(imageEffectInfo, nullptr);
2397 std::string info = imageEffectInfo;
2398
2399 errorCode = OH_ImageEffect_Release(imageEffect);
2400 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2401 "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Release failed";
2402
2403 imageEffect = OH_ImageEffect_Restore(info.c_str());
2404 ASSERT_NE(imageEffect, nullptr) << "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Restore failed";
2405
2406 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, nullptr);
2407 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2408 "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_SetInputPixelmap failed";
2409
2410 errorCode = OH_ImageEffect_Start(imageEffect);
2411 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2412 "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Start failed";
2413
2414 errorCode = OH_ImageEffect_Release(imageEffect);
2415 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) <<
2416 "ImageEffectSaveAndRestoreUnittest004 OH_ImageEffect_Release failed";
2417
2418 GTEST_LOG_(INFO) << "ImageEffectSaveAndRestoreUnittest004 success! result: " << errorCode;
2419 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: ImageEffectSaveAndRestoreUnittest004 END";
2420 }
2421
2422 /**
2423 * Feature: ImageEffect
2424 * Function: Test ImageEffectSaveAndRestore with ContrastEFilter normal parameter
2425 * SubFunction: NA
2426 * FunctionPoints: NA
2427 * EnvConditions: NA
2428 * CaseDescription: Test ImageEffectSaveAndRestore with ContrastEFilter normal parameter
2429 */
HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest005, TestSize.Level1)2430 HWTEST_F(ImageEffectCApiUnittest, ImageEffectSaveAndRestoreUnittest005, TestSize.Level1)
2431 {
2432 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2433 ASSERT_NE(imageEffect, nullptr);
2434
2435 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, CONTRAST_EFILTER);
2436 ASSERT_NE(filter, nullptr);
2437
2438 ImageEffect_Any value;
2439 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
2440 value.dataValue.floatValue = 200.f;
2441 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
2442 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2443
2444 ImageEffect_Any result;
2445 errorCode = OH_EffectFilter_GetValue(filter, KEY_FILTER_INTENSITY, &result);
2446 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2447 ASSERT_EQ(result.dataType, ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT);
2448 ASSERT_EQ(result.dataValue.floatValue, 100.f);
2449
2450 char *imageEffectInfo = nullptr;
2451 errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
2452 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2453
2454 ASSERT_NE(imageEffectInfo, nullptr);
2455 std::string info = imageEffectInfo;
2456
2457 errorCode = OH_ImageEffect_Release(imageEffect);
2458 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2459
2460 imageEffect = OH_ImageEffect_Restore(info.c_str());
2461 ASSERT_NE(imageEffect, nullptr);
2462
2463 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_);
2464 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2465
2466 std::shared_ptr<PixelMap> outputPixelmap = std::make_shared<MockPixelMap>();
2467 std::shared_ptr<OH_PixelmapNative> outputPixelmapNative = std::make_shared<OH_PixelmapNative>(outputPixelmap);
2468 errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, outputPixelmapNative.get());
2469 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2470
2471 errorCode = OH_ImageEffect_Start(imageEffect);
2472 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2473
2474 errorCode = OH_ImageEffect_Release(imageEffect);
2475 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS);
2476 }
2477
2478 /**
2479 * Feature: ImageEffect
2480 * Function: Test OH_ImageEffect_SetInputUri with empty uri parameter
2481 * SubFunction: NA
2482 * FunctionPoints: NA
2483 * EnvConditions: NA
2484 * CaseDescription: Test OH_ImageEffect_SetInputUri with empty uri parameter
2485 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputUri001, TestSize.Level1)2486 HWTEST_F(ImageEffectCApiUnittest, OHImageEffectSetInputUri001, TestSize.Level1)
2487 {
2488 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputUri001 start";
2489 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
2490 ASSERT_NE(imageEffect, nullptr) << "OHImageEffectSetInputUri001 OH_ImageEffect_Create failed";
2491
2492 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputUri(imageEffect, nullptr);
2493 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS) << "OH_ImageEffect_SetInputUri failed";
2494
2495 GTEST_LOG_(INFO) << "OHImageEffectSetInputUri001 success! result: " << errorCode;
2496 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectSetInputUri001 END";
2497 }
2498
2499 /**
2500 * Feature: ImageEffect
2501 * Function: Test OH_ImageEffect_FiltersSize with empty parameter
2502 * SubFunction: NA
2503 * FunctionPoints: NA
2504 * EnvConditions: NA
2505 * CaseDescription: Test OH_ImageEffect_FiltersSize with empty parameter
2506 */
HWTEST_F(ImageEffectCApiUnittest, OHImageEffectFiltersSize001, TestSize.Level1)2507 HWTEST_F(ImageEffectCApiUnittest, OHImageEffectFiltersSize001, TestSize.Level1)
2508 {
2509 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectFiltersSize001 start";
2510 int32_t res = OH_ImageEffect_GetFilterCount(nullptr);
2511 ASSERT_EQ(res, 0) << "OHImageEffectFiltersSize001 OH_ImageEffect_FiltersSize failed";
2512
2513 GTEST_LOG_(INFO) << "OHImageEffectFiltersSize001 success! result: " << res;
2514 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OHImageEffectFiltersSize001 END";
2515 }
2516
2517 /**
2518 * Feature: ImageEffect
2519 * Function: Test OH_ImageEffect_GetFilter with empty parameter
2520 * SubFunction: NA
2521 * FunctionPoints: NA
2522 * EnvConditions: NA
2523 * CaseDescription: Test OH_ImageEffect_GetFilter with empty parameter
2524 */
HWTEST_F(ImageEffectCApiUnittest, OH_ImageEffect_GetFilter001, TestSize.Level1)2525 HWTEST_F(ImageEffectCApiUnittest, OH_ImageEffect_GetFilter001, TestSize.Level1)
2526 {
2527 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter001 start";
2528 OH_EffectFilter *filter = OH_ImageEffect_GetFilter(nullptr, 0);
2529 ASSERT_EQ(filter, nullptr) << "OH_ImageEffect_GetFilter001 OH_ImageEffect_GetFilter failed";
2530
2531 GTEST_LOG_(INFO) << "OH_ImageEffect_GetFilter001 success! result: " << filter;
2532 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter001 END";
2533 }
2534
2535 /**
2536 * Feature: ImageEffect
2537 * Function: Test OH_ImageEffect_GetFilter with empty parameter and negative index
2538 * SubFunction: NA
2539 * FunctionPoints: NA
2540 * EnvConditions: NA
2541 * CaseDescription: Test OH_ImageEffect_GetFilter with empty parameter and negative index
2542 */
HWTEST_F(ImageEffectCApiUnittest, OH_ImageEffect_GetFilter002, TestSize.Level1)2543 HWTEST_F(ImageEffectCApiUnittest, OH_ImageEffect_GetFilter002, TestSize.Level1)
2544 {
2545 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter002 start";
2546 OH_EffectFilter *filter = OH_ImageEffect_GetFilter(nullptr, -1);
2547 ASSERT_EQ(filter, nullptr) << "OH_ImageEffect_GetFilter002 OH_ImageEffect_GetFilter failed";
2548
2549 GTEST_LOG_(INFO) << "OH_ImageEffect_GetFilter002 success! result: " << filter;
2550 GTEST_LOG_(INFO) << "ImageEffectCApiUnittest: OH_ImageEffect_GetFilter002 END";
2551 }
2552 } // namespace Effect
2553 } // namespace Media
2554 } // namespace OHOS
