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_inner_unittest.h"
17
18 #include "efilter_factory.h"
19 #include "brightness_efilter.h"
20 #include "contrast_efilter.h"
21 #include "test_common.h"
22 #include "external_loader.h"
23 #include "crop_efilter.h"
24 #include "mock_picture.h"
25 #include "mock_producer_surface.h"
26 #include "external_loader.h"
27 #include "color_space.h"
28
29 using namespace testing::ext;
30 using ::testing::_;
31 using ::testing::A;
32 using ::testing::InSequence;
33 using ::testing::Mock;
34 using ::testing::Return;
35 using namespace OHOS::Media::Effect::Test;
36
37 namespace {
38 constexpr uint32_t CROP_FACTOR = 2;
39 }
40
41 namespace OHOS {
42 namespace Media {
43 namespace Effect {
44 class FakeEFilter : public EFilter {
45 public:
FakeEFilter(const std::string & name)46 explicit FakeEFilter(const std::string &name) : EFilter(name) {}
~FakeEFilter()47 ~FakeEFilter() {}
48
Render(EffectBuffer * buffer,std::shared_ptr<EffectContext> & context)49 ErrorCode Render(EffectBuffer *buffer, std::shared_ptr<EffectContext> &context) override
50 {
51 return PushData(buffer, context);
52 }
53
Render(EffectBuffer * src,EffectBuffer * dst,std::shared_ptr<EffectContext> & context)54 ErrorCode Render(EffectBuffer *src, EffectBuffer *dst, std::shared_ptr<EffectContext> &context) override
55 {
56 return ErrorCode::SUCCESS;
57 }
58
Restore(const EffectJsonPtr & values)59 ErrorCode Restore(const EffectJsonPtr &values) override
60 {
61 return ErrorCode::SUCCESS;
62 }
63 };
64
65 class FakeImageEffect : public ImageEffect {
66 public:
FakeImageEffect()67 explicit FakeImageEffect() : ImageEffect("ImageEffect") {}
~FakeImageEffect()68 ~FakeImageEffect() {}
69 };
70
SetUpTestCase()71 void ImageEffectInnerUnittest::SetUpTestCase() {}
72
TearDownTestCase()73 void ImageEffectInnerUnittest::TearDownTestCase() {}
74
SetUp()75 void ImageEffectInnerUnittest::SetUp()
76 {
77 ExternLoader::Instance()->InitExt();
78 EFilterFactory::Instance()->functions_.clear();
79 EFilterFactory::Instance()->RegisterEFilter<BrightnessEFilter>(BRIGHTNESS_EFILTER);
80 EFilterFactory::Instance()->RegisterEFilter<ContrastEFilter>(CONTRAST_EFILTER);
81 EFilterFactory::Instance()->RegisterEFilter<CropEFilter>(CROP_EFILTER);
82 EFilterFactory::Instance()->delegates_.clear();
83 mockPixelMap_ = new MockPixelMap();
84 imageEffect_ = new FakeImageEffect();
85 efilter_ = new FakeEFilter(BRIGHTNESS_EFILTER);
86
87 std::shared_ptr<BufferInfo> info = std::make_unique<BufferInfo>();
88 info->width_ = mockPixelMap_->GetWidth();
89 info->height_ = mockPixelMap_->GetHeight();
90 info->rowStride_ = mockPixelMap_->GetRowStride();
91 info->len_ = mockPixelMap_->GetHeight() * mockPixelMap_->GetRowStride();
92 info->formatType_ = IEffectFormat::RGBA8888;
93 info->pixelMap_ = mockPixelMap_;
94 info->surfaceBuffer_ = nullptr;
95 std::shared_ptr<ExtraInfo> extraInfo = std::make_unique<ExtraInfo>();
96 extraInfo->dataType = DataType::PIXEL_MAP;
97 extraInfo->bufferType = BufferType::HEAP_MEMORY;
98 effectBuffer_ = new EffectBuffer(info, (void *)mockPixelMap_->GetPixels(), extraInfo);
99 }
100
TearDown()101 void ImageEffectInnerUnittest::TearDown()
102 {
103 delete(mockPixelMap_);
104 mockPixelMap_ = nullptr;
105 Mock::AllowLeak(imageEffect_);
106 Mock::AllowLeak(efilter_);
107 delete(effectBuffer_);
108 effectBuffer_ = nullptr;
109 }
110
111 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_001, TestSize.Level1)
112 {
113 InSequence s;
114 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
115 imageEffect_->AddEFilter(efilter);
116 Any value = 200.f;
117 efilter->SetValue(KEY_FILTER_INTENSITY, value);
118 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
119 ASSERT_EQ(result, ErrorCode::SUCCESS);
120 result = imageEffect_->Start();
121 ASSERT_EQ(result, ErrorCode::SUCCESS);
122 }
123
124 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_002, TestSize.Level1)
125 {
126 InSequence s;
127 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
128 Any value = 200.f;
129 efilter->SetValue(KEY_FILTER_INTENSITY, value);
130 std::shared_ptr<EffectBuffer> src = std::make_shared<EffectBuffer>(
131 effectBuffer_->bufferInfo_, effectBuffer_->buffer_, effectBuffer_->extraInfo_);
132
133 ErrorCode result = efilter->Render(src, src);
134 ASSERT_EQ(result, ErrorCode::SUCCESS);
135 }
136
137 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_003, TestSize.Level1)
138 {
139 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
140 imageEffect_->AddEFilter(efilter);
141 Any value = 100.f;
142 efilter->SetValue(KEY_FILTER_INTENSITY, value);
143 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
144 ASSERT_EQ(result, ErrorCode::SUCCESS);
145 result = imageEffect_->SetOutputPixelMap(mockPixelMap_);
146 ASSERT_EQ(result, ErrorCode::SUCCESS);
147 result = imageEffect_->Start();
148 ASSERT_EQ(result, ErrorCode::SUCCESS);
149 }
150
151 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_004, TestSize.Level1)
152 {
153 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(CROP_EFILTER);
154 imageEffect_->AddEFilter(efilter);
155 uint32_t x1 = static_cast<uint32_t>(mockPixelMap_->GetWidth() / CROP_FACTOR);
156 uint32_t y1 = static_cast<uint32_t>(mockPixelMap_->GetHeight() / CROP_FACTOR);
157 uint32_t areaInfo[] = { 0, 0, x1, y1};
158 Any value = static_cast<void *>(areaInfo);
159 efilter->SetValue(KEY_FILTER_REGION, value);
160 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
161 ASSERT_EQ(result, ErrorCode::SUCCESS);
162 result = imageEffect_->SetOutputPixelMap(mockPixelMap_);
163 ASSERT_EQ(result, ErrorCode::SUCCESS);
164 result = imageEffect_->Start();
165 ASSERT_EQ(result, ErrorCode::SUCCESS);
166 }
167
168 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_005, TestSize.Level1)
169 {
170 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(CROP_EFILTER);
171 imageEffect_->AddEFilter(efilter);
172 uint32_t x1 = static_cast<uint32_t>(mockPixelMap_->GetWidth() / CROP_FACTOR);
173 uint32_t y1 = static_cast<uint32_t>(mockPixelMap_->GetHeight() / CROP_FACTOR);
174 uint32_t areaInfo[] = { 0, 0, x1, y1};
175 Any value = static_cast<void *>(areaInfo);
176 efilter->SetValue(KEY_FILTER_REGION, value);
177 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
178 ASSERT_EQ(result, ErrorCode::SUCCESS);
179 result = imageEffect_->Start();
180 ASSERT_EQ(result, ErrorCode::SUCCESS);
181 }
182
183 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_006, TestSize.Level1)
184 {
185 DataInfo dataInfo;
186 std::shared_ptr<BufferInfo> bufferInfo = std::make_unique<BufferInfo>();
187 std::shared_ptr<ExtraInfo> extraInfo = std::make_unique<ExtraInfo>();
188 std::shared_ptr<EffectBuffer> effectBuffer = std::make_unique<EffectBuffer>(bufferInfo, nullptr, extraInfo);
189 std::shared_ptr<ImageEffect> imageEffect = std::make_unique<ImageEffect>();
190
191 dataInfo.dataType_ = DataType::PATH;
192 dataInfo.path_ = "path";
193 IEffectFormat format = IEffectFormat::RGBA8888;
194 EXPECT_EQ(imageEffect->ParseDataInfo(dataInfo, effectBuffer, true, format), ErrorCode::SUCCESS);
195
196 dataInfo.dataType_ = DataType::NATIVE_WINDOW;
197 EXPECT_EQ(imageEffect->ParseDataInfo(dataInfo, effectBuffer, false, format), ErrorCode::SUCCESS);
198
199 dataInfo.dataType_ = DataType::UNKNOWN;
200 EXPECT_EQ(imageEffect->ParseDataInfo(dataInfo, effectBuffer, false, format), ErrorCode::ERR_NO_DATA);
201
202 dataInfo.dataType_ = static_cast<DataType>(100);
203 EXPECT_EQ(imageEffect->ParseDataInfo(dataInfo, effectBuffer, false, format), ErrorCode::ERR_UNSUPPORTED_DATA_TYPE);
204 }
205
206 HWTEST_F(ImageEffectInnerUnittest, SetOutputPicture_001, TestSize.Level1)
207 {
208 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
209 ErrorCode result = imageEffect_->SetOutputPicture(nullptr);
210 ASSERT_EQ(result, ErrorCode::SUCCESS);
211 }
212
213 HWTEST_F(ImageEffectInnerUnittest, SetOutputPicture_002, TestSize.Level1)
214 {
215 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
216 std::shared_ptr<Picture> picture = std::make_shared<MockPicture>();
217 ErrorCode result = imageEffect_->SetOutputPicture(picture.get());
218 ASSERT_EQ(result, ErrorCode::SUCCESS);
219 }
220
221 HWTEST_F(ImageEffectInnerUnittest, SetInputPicture_001, TestSize.Level1)
222 {
223 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
224 ErrorCode result = imageEffect_->SetInputPicture(nullptr);
225 ASSERT_NE(result, ErrorCode::SUCCESS);
226 }
227
228 HWTEST_F(ImageEffectInnerUnittest, SetInputPicture_002, TestSize.Level1)
229 {
230 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
231 std::shared_ptr<Picture> picture = std::make_shared<MockPicture>();
232 ErrorCode result = imageEffect_->SetInputPicture(picture.get());
233 ASSERT_EQ(result, ErrorCode::SUCCESS);
234 }
235
236 HWTEST_F(ImageEffectInnerUnittest, SetExtraInfo_001, TestSize.Level1)
237 {
238 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
239 ErrorCode result = imageEffect_->SetExtraInfo(nullptr);
240 ASSERT_EQ(result, ErrorCode::SUCCESS);
241 }
242
243 HWTEST_F(ImageEffectInnerUnittest, SetOutputSurfaceBuffer_001, TestSize.Level1)
244 {
245 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
246 ErrorCode result = imageEffect_->SetOutputSurfaceBuffer(nullptr);
247 ASSERT_EQ(result, ErrorCode::SUCCESS);
248 }
249
250 HWTEST_F(ImageEffectInnerUnittest, SetOutputSurfaceBuffer_002, TestSize.Level1)
251 {
252 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
253 sptr<SurfaceBuffer> surfaceBuffer;
254 MockProducerSurface::AllocDmaMemory(surfaceBuffer);
255 ErrorCode result = imageEffect_->SetOutputSurfaceBuffer(surfaceBuffer);
256 ASSERT_EQ(result, ErrorCode::SUCCESS);
257 MockProducerSurface::ReleaseDmaBuffer(surfaceBuffer);
258 }
259
260 HWTEST_F(ImageEffectInnerUnittest, SetInputSurfaceBuffer_001, TestSize.Level1)
261 {
262 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
263 ErrorCode result = imageEffect_->SetInputSurfaceBuffer(nullptr);
264 ASSERT_NE(result, ErrorCode::SUCCESS);
265 }
266
267 HWTEST_F(ImageEffectInnerUnittest, SetInputSurfaceBuffer_002, TestSize.Level1)
268 {
269 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
270 sptr<SurfaceBuffer> surfaceBuffer;
271 MockProducerSurface::AllocDmaMemory(surfaceBuffer);
272 ErrorCode result = imageEffect_->SetInputSurfaceBuffer(surfaceBuffer);
273 EXPECT_EQ(result, ErrorCode::SUCCESS);
274
275 imageEffect_->needPreFlush_ = true;
276 result = imageEffect_->SetInputSurfaceBuffer(surfaceBuffer);
277 EXPECT_EQ(result, ErrorCode::SUCCESS);
278 MockProducerSurface::ReleaseDmaBuffer(surfaceBuffer);
279 }
280
281 HWTEST_F(ImageEffectInnerUnittest, SetOutputSurface_001, TestSize.Level1)
282 {
283 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
284 sptr<Surface> surface = nullptr;
285 ErrorCode result = imageEffect_->SetOutputSurface(surface);
286 ASSERT_NE(result, ErrorCode::SUCCESS);
287 }
288
289 HWTEST_F(ImageEffectInnerUnittest, SetOutputPixelMap_001, TestSize.Level1)
290 {
291 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
292 ErrorCode result = imageEffect_->SetOutputPixelMap(nullptr);
293 ASSERT_EQ(result, ErrorCode::SUCCESS);
294 }
295
296 HWTEST_F(ImageEffectInnerUnittest, SetInputPixelMap_001, TestSize.Level1)
297 {
298 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
299 ErrorCode result = imageEffect_->SetInputPixelMap(nullptr);
300 ASSERT_NE(result, ErrorCode::SUCCESS);
301 }
302
303 HWTEST_F(ImageEffectInnerUnittest, SetOutNativeWindow_001, TestSize.Level1)
304 {
305 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
306 ErrorCode result = imageEffect_->SetOutNativeWindow(nullptr);
307 ASSERT_NE(result, ErrorCode::SUCCESS);
308 }
309
310 HWTEST_F(ImageEffectInnerUnittest, SetOutNativeWindow_002, TestSize.Level1)
311 {
312 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
313 OHNativeWindow *nativeWindow = new OHNativeWindow();
314 nativeWindow->surface = nullptr;
315 ErrorCode result = imageEffect_->SetOutNativeWindow(nativeWindow);
316 ASSERT_NE(result, ErrorCode::SUCCESS);
317 delete nativeWindow;
318 nativeWindow = nullptr;
319 }
320
321 HWTEST_F(ImageEffectInnerUnittest, SetInputTexture_001, TestSize.Level1)
322 {
323 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
324 ErrorCode result = imageEffect_->SetInputTexture(0, 0);
325 ASSERT_NE(result, ErrorCode::SUCCESS);
326 }
327
328 HWTEST_F(ImageEffectInnerUnittest, SetInputTexture_002, TestSize.Level1)
329 {
330 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
331 ErrorCode result = imageEffect_->SetInputTexture(2, 0);
332 ASSERT_EQ(result, ErrorCode::SUCCESS);
333 }
334
335 HWTEST_F(ImageEffectInnerUnittest, SetOutputTexture_001, TestSize.Level1)
336 {
337 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
338 ErrorCode result = imageEffect_->SetOutputTexture(0);
339 ASSERT_NE(result, ErrorCode::SUCCESS);
340 }
341
342 HWTEST_F(ImageEffectInnerUnittest, SetOutputTexture_002, TestSize.Level1)
343 {
344 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
345 ErrorCode result = imageEffect_->SetOutputTexture(2);
346 ASSERT_EQ(result, ErrorCode::SUCCESS);
347 }
348
349 HWTEST_F(ImageEffectInnerUnittest, RenderTexture_001, TestSize.Level1)
350 {
351 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
352 std::shared_ptr<RenderEnvironment> env = std::make_shared<RenderEnvironment>();
353 env->Init();
354 RenderTexturePtr inTex = env->RequestBuffer(1080, 1920);
355 RenderTexturePtr outTex = env->RequestBuffer(1080, 1920);
356 ErrorCode result = imageEffect_->SetInputTexture(inTex->GetName(), ColorManager::ColorSpaceName::SRGB);
357 ASSERT_EQ(result, ErrorCode::SUCCESS);
358 result = imageEffect_->SetOutputTexture(outTex->GetName());
359 ASSERT_EQ(result, ErrorCode::SUCCESS);
360 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
361 Any value = 70.f;
362 efilter->SetValue(KEY_FILTER_INTENSITY, value);
363 imageEffect_->AddEFilter(efilter);
364 result = imageEffect_->Start();
365 ASSERT_EQ(result, ErrorCode::SUCCESS);
366 }
367
368 HWTEST_F(ImageEffectInnerUnittest, ReplaceEFilter_001, TestSize.Level1)
369 {
370 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
371 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
372 imageEffect_->AddEFilter(efilter);
373 std::shared_ptr<EFilter> efilter2 = EFilterFactory::Instance()->Create(CONTRAST_EFILTER);
374
375 ErrorCode result = imageEffect_->ReplaceEFilter(efilter2, -1);
376 ASSERT_NE(result, ErrorCode::SUCCESS);
377
378 result = imageEffect_->ReplaceEFilter(efilter2, 0);
379 ASSERT_EQ(result, ErrorCode::SUCCESS);
380 }
381
382 HWTEST_F(ImageEffectInnerUnittest, SetInputUri_001, TestSize.Level1)
383 {
384 std::string g_jpgUri = std::string("file:///data/test/resource/image_effect_1k_test1.jpg");
385 std::string g_notJpgUri = std::string("file:///data/test/resource/image_effect_1k_test1.png");
386 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
387
388 ErrorCode result = imageEffect_->SetInputUri(g_notJpgUri);
389 EXPECT_NE(result, ErrorCode::SUCCESS);
390
391 result = imageEffect_->SetInputUri(g_jpgUri);
392 EXPECT_EQ(result, ErrorCode::SUCCESS);
393 }
394
395 HWTEST_F(ImageEffectInnerUnittest, SetOutputUri_001, TestSize.Level1)
396 {
397 std::string g_jpgUri = std::string("file:///data/test/resource/image_effect_1k_test1.jpg");
398 std::string g_notJpgUri = std::string("file:///data/test/resource/image_effect_1k_test1.png");
399 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
400
401 ErrorCode result = imageEffect_->SetOutputUri("");
402 EXPECT_EQ(result, ErrorCode::SUCCESS);
403
404 result = imageEffect_->SetOutputUri(g_notJpgUri);
405 EXPECT_NE(result, ErrorCode::SUCCESS);
406
407 result = imageEffect_->SetOutputUri(g_jpgUri);
408 EXPECT_EQ(result, ErrorCode::SUCCESS);
409 }
410
411 HWTEST_F(ImageEffectInnerUnittest, SetInputPath_001, TestSize.Level1)
412 {
413 std::string g_jpgPath = std::string("/data/test/resource/image_effect_1k_test1.jpg");
414 std::string g_notJpgPath = std::string("/data/test/resource/image_effect_1k_test1.png");
415 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
416
417 ErrorCode result = imageEffect_->SetInputPath(g_notJpgPath);
418 EXPECT_NE(result, ErrorCode::SUCCESS);
419
420 result = imageEffect_->SetInputPath(g_jpgPath);
421 EXPECT_EQ(result, ErrorCode::SUCCESS);
422 }
423
424 HWTEST_F(ImageEffectInnerUnittest, SetOutputPath_001, TestSize.Level1)
425 {
426 std::string g_jpgPath = std::string("/data/test/resource/image_effect_1k_test1.jpg");
427 std::string g_notJpgPath = std::string("/data/test/resource/image_effect_1k_test1.png");
428 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
429
430 ErrorCode result = imageEffect_->SetOutputPath("");
431 EXPECT_EQ(result, ErrorCode::SUCCESS);
432
433 result = imageEffect_->SetOutputPath(g_notJpgPath);
434 EXPECT_NE(result, ErrorCode::SUCCESS);
435
436 result = imageEffect_->SetOutputPath(g_jpgPath);
437 EXPECT_EQ(result, ErrorCode::SUCCESS);
438 }
439
440 HWTEST_F(ImageEffectInnerUnittest, Save_001, TestSize.Level1)
441 {
442 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
443 EffectJsonPtr jsonValues = EffectJsonHelper::CreateObject();
444 ErrorCode result = imageEffect_->Save(jsonValues);
445 EXPECT_EQ(result, ErrorCode::SUCCESS);
446
447 EffectJsonPtr extra = EffectJsonHelper::CreateObject();
448 imageEffect_->SetExtraInfo(extra);
449 result = imageEffect_->Save(jsonValues);
450 EXPECT_EQ(result, ErrorCode::SUCCESS);
451 }
452
453 HWTEST_F(ImageEffectInnerUnittest, CacheBuffer_001, TestSize.Level1)
454 {
455 std::shared_ptr<EffectContext> effectContext = std::make_shared<EffectContext>();
456 std::shared_ptr<EffectBuffer> buffer = std::make_shared<EffectBuffer>(
457 effectBuffer_->bufferInfo_, effectBuffer_->buffer_, effectBuffer_->extraInfo_);
458 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
459
460 ErrorCode result = efilter->StartCache();
461 EXPECT_EQ(result, ErrorCode::SUCCESS);
462
463 result = efilter->CacheBuffer(buffer.get(), effectContext);
464 EXPECT_EQ(result, ErrorCode::SUCCESS);
465
466 result = efilter->GetFilterCache(buffer, effectContext);
467 EXPECT_EQ(result, ErrorCode::SUCCESS);
468
469 result = efilter->CancelCache();
470 EXPECT_EQ(result, ErrorCode::SUCCESS);
471
472 result = efilter->ReleaseCache();
473 EXPECT_EQ(result, ErrorCode::SUCCESS);
474 }
475
476 HWTEST_F(ImageEffectInnerUnittest, GetImageInfo_001, TestSize.Level1)
477 {
478 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
479 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
480 imageEffect_->AddEFilter(efilter);
481
482 imageEffect_->inDateInfo_.dataType_ = DataType::UNKNOWN;
483 ErrorCode result = imageEffect_->Render();
484
485 imageEffect_->inDateInfo_.dataType_ = DataType::TEX;
486 result = imageEffect_->Render();
487
488 imageEffect_->inDateInfo_.dataType_ = DataType::NATIVE_WINDOW;
489 result = imageEffect_->Render();
490 EXPECT_NE(result, ErrorCode::SUCCESS);
491 }
492
493 HWTEST_F(ImageEffectInnerUnittest, GetExifMetadata_001, TestSize.Level1)
494 {
495 std::shared_ptr<EffectContext> context = std::make_shared<EffectContext>();
496 context->renderStrategy_ = std::make_shared<RenderStrategy>();
497 std::shared_ptr<EffectBuffer> src = std::make_shared<EffectBuffer>(
498 effectBuffer_->bufferInfo_, effectBuffer_->buffer_, effectBuffer_->extraInfo_);
499 std::shared_ptr<EffectBuffer> dst = std::make_shared<EffectBuffer>(
500 effectBuffer_->bufferInfo_, effectBuffer_->buffer_, effectBuffer_->extraInfo_);
501 context->renderStrategy_->src_ = src;
502 context->renderStrategy_->dst_ = dst;
503 std::shared_ptr<ExifMetadata> data = context->GetExifMetadata();
504
505 context->renderStrategy_->src_->extraInfo_->dataType = DataType::PICTURE;
506 data = context->GetExifMetadata();
507 EXPECT_EQ(data, nullptr);
508 }
509
510 HWTEST_F(ImageEffectInnerUnittest, ExternLoader_001, TestSize.Level1)
511 {
512 ExternLoader *instance = ExternLoader::Instance();
513 instance->isExtLoad_ = true;
514 instance->LoadExtSo();
515 EXPECT_NE(instance, nullptr);
516 }
517
518 HWTEST_F(ImageEffectInnerUnittest, EFilter_001, TestSize.Level1)
519 {
520 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
521 ErrorCode res = efilter->ProcessConfig("START_CACHE");
522 EXPECT_EQ(res, ErrorCode::SUCCESS);
523
524 res = efilter->ProcessConfig("CANCEL_CACHE");
525 EXPECT_EQ(res, ErrorCode::SUCCESS);
526
527 std::shared_ptr<EffectContext> context = std::make_shared<EffectContext>();
528 std::shared_ptr<EffectBuffer> src = std::make_shared<EffectBuffer>(
529 effectBuffer_->bufferInfo_, effectBuffer_->buffer_, effectBuffer_->extraInfo_);
530 efilter->cacheConfig_ = std::make_shared<EFilterCacheConfig>();
531 efilter->cacheConfig_->status_ = CacheStatus::CACHE_START;
532 context->cacheNegotiate_ = std::make_shared<EFilterCacheNegotiate>();
533 context->cacheNegotiate_->config_ = nullptr;
534
535 context->cacheNegotiate_->config_ = std::make_shared<EFilterCacheConfig>();
536
537 efilter->cacheConfig_->status_ = CacheStatus::NO_CACHE;
538
539 context->cacheNegotiate_->needCache_ = true;
540 context->cacheNegotiate_->hasUsedCache_ = false;
541 efilter->cacheConfig_->status_ = CacheStatus::CACHE_USED;
542 res = efilter->PushData("test", src, context);
543 EXPECT_NE(res, ErrorCode::SUCCESS);
544
545 context->cacheNegotiate_->needCache_ = true;
546 context->cacheNegotiate_->hasUsedCache_ = false;
547 efilter->cacheConfig_->status_ = CacheStatus::NO_CACHE;
548 src = nullptr;
549 res = efilter->PushData("test", src, context);
550 EXPECT_NE(res, ErrorCode::SUCCESS);
551
552 context->cacheNegotiate_->needCache_ = true;
553 context->cacheNegotiate_->hasUsedCache_ = false;
554 efilter->cacheConfig_->status_ = CacheStatus::CACHE_ENABLED;
555 res = efilter->PushData("test", src, context);
556 EXPECT_NE(res, ErrorCode::SUCCESS);
557
558 context->cacheNegotiate_->needCache_ = true;
559 context->cacheNegotiate_->hasUsedCache_ = false;
560 efilter->cacheConfig_->status_ = CacheStatus::CACHE_START;
561 src = std::make_shared<EffectBuffer>(
562 effectBuffer_->bufferInfo_, effectBuffer_->buffer_, effectBuffer_->extraInfo_);
563 res = efilter->PushData("test", src, context);
564 EXPECT_NE(res, ErrorCode::SUCCESS);
565 }
566
567 HWTEST_F(ImageEffectInnerUnittest, PushData_001, TestSize.Level1)
568 {
569 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
570 std::shared_ptr<EffectContext> context = std::make_shared<EffectContext>();
571 std::shared_ptr<EffectBuffer> src = std::make_shared<EffectBuffer>(
572 effectBuffer_->bufferInfo_, effectBuffer_->buffer_, effectBuffer_->extraInfo_);
573 efilter->cacheConfig_ = std::make_shared<EFilterCacheConfig>();
574 context->cacheNegotiate_ = std::make_shared<EFilterCacheNegotiate>();
575
576 context->cacheNegotiate_->needCache_ = false;
577 ErrorCode res = efilter->PushData("test", src, context);
578 EXPECT_NE(res, ErrorCode::SUCCESS);
579
580 context->cacheNegotiate_->needCache_ = true;
581 context->cacheNegotiate_->config_ = nullptr;
582 res = efilter->PushData("test", src, context);
583 EXPECT_NE(res, ErrorCode::SUCCESS);
584
585 context->cacheNegotiate_->needCache_ = true;
586 context->cacheNegotiate_->config_ = std::make_shared<EFilterCacheConfig>();
587 context->cacheNegotiate_->hasUsedCache_ = true;
588 res = efilter->PushData("test", src, context);
589 EXPECT_NE(res, ErrorCode::SUCCESS);
590 }
591 } // namespace Effect
592 } // namespace Media
593 } // namespace OHOS
594
