1 /*
2 * Copyright (c) 2023 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 "gtest/gtest.h"
17
18 #include "effect/image_filter.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace Rosen {
25 namespace Drawing {
26 class ImageFilterTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp() override;
31 void TearDown() override;
32 };
33
SetUpTestCase()34 void ImageFilterTest::SetUpTestCase() {}
TearDownTestCase()35 void ImageFilterTest::TearDownTestCase() {}
SetUp()36 void ImageFilterTest::SetUp() {}
TearDown()37 void ImageFilterTest::TearDown() {}
38
39 /*
40 * @tc.name: CreateBlurImageFilterTest001
41 * @tc.desc: test for creating a filter that blurs its input by the separate X and Y sinma value.
42 * @tc.type: FUNC
43 * @tc.require: I77M3W
44 */
45 HWTEST_F(ImageFilterTest, CreateBlurImageFilterTest001, TestSize.Level1)
46 {
47 auto input = ImageFilter::CreateBlurImageFilter(10.0f, 10.0f, TileMode::CLAMP, nullptr);
48 EXPECT_TRUE(input != nullptr);
49 auto imageFilter = ImageFilter::CreateBlurImageFilter(10.0f, 10.0f, TileMode::CLAMP, input);
50 EXPECT_TRUE(imageFilter != nullptr);
51 auto imageFilter1 = ImageFilter::CreateBlurImageFilter(-1.0f, -1.0f, TileMode::CLAMP, input);
52 EXPECT_TRUE(imageFilter1 != nullptr);
53 auto imageFilter2 = ImageFilter::CreateBlurImageFilter(-1.0f, 10.0f, TileMode::CLAMP, input);
54 EXPECT_TRUE(imageFilter2 != nullptr);
55 auto imageFilter3 = ImageFilter::CreateBlurImageFilter(10.0f, -1.0f, TileMode::CLAMP, input);
56 EXPECT_TRUE(imageFilter3 != nullptr);
57 }
58
59 /*
60 * @tc.name: CreateColorFilterImageFilterTest001
61 * @tc.desc: test for creating a filter that applies the color filter to the input filter results.
62 * @tc.type: FUNC
63 * @tc.require: I77M3W
64 */
65 HWTEST_F(ImageFilterTest, CreateColorFilterImageFilterTest001, TestSize.Level1)
66 {
67 auto colorFilter = ColorFilter::CreateBlendModeColorFilter(11, OHOS::Rosen::Drawing::BlendMode::CLEAR);
68 auto input = ImageFilter::CreateColorFilterImageFilter(*colorFilter, nullptr);
69 EXPECT_TRUE(input != nullptr);
70 auto imageFilter = ImageFilter::CreateColorFilterImageFilter(*colorFilter, input);
71 EXPECT_TRUE(imageFilter != nullptr);
72 }
73
74 /*
75 * @tc.name: CreateOffsetImageFilterTest001
76 * @tc.desc: test for creating a filter that offsets the input filter by the given vector.
77 * @tc.type: FUNC
78 * @tc.require: I77M3W
79 */
80 HWTEST_F(ImageFilterTest, CreateOffsetImageFilterTest001, TestSize.Level1)
81 {
82 auto input = ImageFilter::CreateOffsetImageFilter(10.0f, 10.0f, nullptr);
83 EXPECT_TRUE(input != nullptr);
84 auto imageFilter = ImageFilter::CreateOffsetImageFilter(10.0f, 10.0f, input);
85 EXPECT_TRUE(imageFilter != nullptr);
86 }
87
88 /*
89 * @tc.name: CreateArithmeticImageFilterTest001
90 * @tc.desc: test for creating a filter that implements a custom blend mode.
91 * @tc.type: FUNC
92 * @tc.require: I77M3W
93 */
94 HWTEST_F(ImageFilterTest, CreateArithmeticImageFilterTest001, TestSize.Level1)
95 {
96 std::vector<scalar> coefficients;
97 coefficients.push_back(10.0f);
98 coefficients.push_back(10.0f);
99 coefficients.push_back(10.0f);
100 coefficients.push_back(10.0f);
101 auto f1 = ImageFilter::CreateBlurImageFilter(10.0f, 10.0f, TileMode::CLAMP, nullptr);
102 auto f2 = ImageFilter::CreateOffsetImageFilter(10.0f, 10.0f, nullptr);
103 auto imageFilter = ImageFilter::CreateArithmeticImageFilter(coefficients, true, f1, f2);
104 EXPECT_TRUE(imageFilter != nullptr);
105 imageFilter = ImageFilter::CreateArithmeticImageFilter(coefficients, false, f1, f2);
106 EXPECT_TRUE(imageFilter != nullptr);
107 std::vector<scalar> coefficients1;
108 coefficients1.push_back(-1.0f);
109 coefficients1.push_back(0.0f);
110 coefficients1.push_back(10.0f);
111 coefficients1.push_back(10.0f);
112 imageFilter = ImageFilter::CreateArithmeticImageFilter(coefficients1, true, f1, f2);
113 EXPECT_TRUE(imageFilter != nullptr);
114 imageFilter = ImageFilter::CreateArithmeticImageFilter(coefficients, true, nullptr, f2);
115 EXPECT_TRUE(imageFilter != nullptr);
116 imageFilter = ImageFilter::CreateArithmeticImageFilter(coefficients, true, f1, nullptr);
117 EXPECT_TRUE(imageFilter != nullptr);
118 imageFilter = ImageFilter::CreateArithmeticImageFilter(coefficients, true, nullptr, nullptr);
119 EXPECT_TRUE(imageFilter != nullptr);
120 }
121
122 /*
123 * @tc.name: CreateComposeImageFilterTest001
124 * @tc.desc: test for creating a filter that composes f1 with f2.
125 * @tc.type: FUNC
126 * @tc.require: I77M3W
127 */
128 HWTEST_F(ImageFilterTest, CreateComposeImageFilterTest001, TestSize.Level1)
129 {
130 auto imageFilter1 = ImageFilter::CreateBlurImageFilter(10.0f, 20.0f, TileMode::CLAMP, nullptr);
131 auto imageFilter2 = ImageFilter::CreateOffsetImageFilter(30.0f, 40.0f, nullptr);
132 auto imageFilter = ImageFilter::CreateComposeImageFilter(imageFilter1, imageFilter2);
133 EXPECT_TRUE(imageFilter != nullptr);
134 }
135
136 /*
137 * @tc.name: ImageFilterCreateTest001
138 * @tc.desc: testing the ImageFilter Construction Method
139 * @tc.type: FUNC
140 * @tc.require: I77M3W
141 */
142 HWTEST_F(ImageFilterTest, ImageFilterCreateTest001, TestSize.Level1)
143 {
144 auto imageFilter = std::make_shared<ImageFilter>(ImageFilter::FilterType::BLUR, 10.0f, 10.0f, nullptr);
145 ASSERT_TRUE(imageFilter != nullptr);
146 }
147
148 /*
149 * @tc.name: ImageFilterCreateTest002
150 * @tc.desc: testing the ImageFilter Construction Method
151 * @tc.type: FUNC
152 * @tc.require: I77M3W
153 */
154 HWTEST_F(ImageFilterTest, ImageFilterCreateTest002, TestSize.Level1)
155 {
156 auto colorFilter = ColorFilter::CreateBlendModeColorFilter(11, OHOS::Rosen::Drawing::BlendMode::CLEAR);
157 auto imageFilter = std::make_shared<ImageFilter>(ImageFilter::FilterType::COLOR_FILTER, *colorFilter, nullptr);
158 ASSERT_TRUE(imageFilter != nullptr);
159 }
160
161 /*
162 * @tc.name: ImageFilterCreateTest003
163 * @tc.desc: testing the ImageFilter Construction Method
164 * @tc.type: FUNC
165 * @tc.require: I77M3W
166 */
167 HWTEST_F(ImageFilterTest, ImageFilterCreateTest003, TestSize.Level1)
168 {
169 std::vector<scalar> coefficients;
170 coefficients.push_back(10.0f);
171 coefficients.push_back(10.0f);
172 coefficients.push_back(10.0f);
173 coefficients.push_back(10.0f);
174 auto imageFilter = std::make_shared<ImageFilter>(ImageFilter::FilterType::ARITHMETIC, coefficients,
175 true, nullptr, nullptr);
176 ASSERT_TRUE(imageFilter != nullptr);
177 }
178
179 /*
180 * @tc.name: ImageFilterCreateTest004
181 * @tc.desc: testing the ImageFilter Construction Method
182 * @tc.type: FUNC
183 * @tc.require: I77M3W
184 */
185 HWTEST_F(ImageFilterTest, ImageFilterCreateTest004, TestSize.Level1)
186 {
187 auto imageFilter1 = ImageFilter::CreateBlurImageFilter(10.0f, 20.0f, TileMode::CLAMP, nullptr);
188 auto imageFilter2 = ImageFilter::CreateOffsetImageFilter(30.0f, 40.0f, nullptr);
189 auto imageFilter = std::make_shared<ImageFilter>(ImageFilter::FilterType::COMPOSE, imageFilter1, imageFilter2);
190 ASSERT_TRUE(imageFilter != nullptr);
191 }
192
193 /*
194 * @tc.name: CreateBlendImageFilterTest001
195 * @tc.desc: test for creating a filter takes an BlendMode
196 * and uses it to composite the two filters together.
197 * @tc.type: FUNC
198 * @tc.require: I77M3W
199 */
200 HWTEST_F(ImageFilterTest, CreateBlendImageFilterTest001, TestSize.Level1)
201 {
202 auto imageFilter1 = ImageFilter::CreateBlurImageFilter(10.0f, 20.0f, TileMode::CLAMP, nullptr);
203 auto imageFilter2 = ImageFilter::CreateOffsetImageFilter(30.0f, 40.0f, nullptr);
204 auto imageFilter = ImageFilter::CreateBlendImageFilter(BlendMode::CLEAR, imageFilter1, imageFilter2);
205 EXPECT_TRUE(imageFilter != nullptr);
206 }
207
208 /*
209 * @tc.name: CreateBlendImageFilterTest002
210 * @tc.desc: test for creating a filter takes an invalid BlendMode
211 * and uses it to composite the two filters together.
212 * @tc.type: FUNC
213 * @tc.require: I77M3W
214 */
215 HWTEST_F(ImageFilterTest, CreateBlendImageFilterTest002, TestSize.Level1)
216 {
217 auto imageFilter1 = ImageFilter::CreateBlurImageFilter(10.0f, 20.0f, TileMode::CLAMP, nullptr);
218 auto imageFilter2 = ImageFilter::CreateOffsetImageFilter(30.0f, 40.0f, nullptr);
219 auto imageFilter = ImageFilter::CreateBlendImageFilter(BlendMode::EXCLUSION, imageFilter1, imageFilter2);
220 EXPECT_TRUE(imageFilter != nullptr);
221 }
222
223 /*
224 * @tc.name: CreateBlendImageFilterTest003
225 * @tc.desc: test for creating a filter takes a BlendMode
226 * and uses it to composite the two filters together.
227 * @tc.type: FUNC
228 * @tc.require: I77M3W
229 */
230 HWTEST_F(ImageFilterTest, CreateBlendImageFilterTest003, TestSize.Level1)
231 {
232 auto imageFilter2 = ImageFilter::CreateOffsetImageFilter(30.0f, 40.0f, nullptr);
233 auto imageFilter = ImageFilter::CreateBlendImageFilter(BlendMode::CLEAR, nullptr, imageFilter2);
234 EXPECT_TRUE(imageFilter != nullptr);
235 }
236
237 /*
238 * @tc.name: CreateBlendImageFilterTest004
239 * @tc.desc: test for creating a filter takes a BlendMode
240 * and uses it to composite the two filters together.
241 * @tc.type: FUNC
242 * @tc.require: I77M3W
243 */
244 HWTEST_F(ImageFilterTest, CreateBlendImageFilterTest004, TestSize.Level1)
245 {
246 auto imageFilter1 = ImageFilter::CreateBlurImageFilter(10.0f, 20.0f, TileMode::CLAMP, nullptr);
247 auto imageFilter = ImageFilter::CreateBlendImageFilter(BlendMode::CLEAR, imageFilter1, nullptr);
248 EXPECT_TRUE(imageFilter != nullptr);
249 }
250
251 /*
252 * @tc.name: CreateBlendImageFilterTest005
253 * @tc.desc: test for creating a filter takes a BlendMode
254 * and uses it to composite the two filters together.
255 * @tc.type: FUNC
256 * @tc.require: I77M3W
257 */
258 HWTEST_F(ImageFilterTest, CreateBlendImageFilterTest005, TestSize.Level1)
259 {
260 auto imageFilter = ImageFilter::CreateBlendImageFilter(BlendMode::CLEAR, nullptr, nullptr);
261 EXPECT_TRUE(imageFilter != nullptr);
262 }
263
264 /*
265 * @tc.name: CreateShaderImageFilterTest001
266 * @tc.desc: test for creating a filter that fills the output with the per-pixel evaluation of the ShaderEffect.
267 * @tc.type: FUNC
268 * @tc.require: I77M3W
269 */
270 HWTEST_F(ImageFilterTest, CreateShaderImageFilterTest001, TestSize.Level1)
271 {
272 std::shared_ptr<ShaderEffect> effect = ShaderEffect::CreateColorShader(0);
273 auto imageFilter = ImageFilter::CreateShaderImageFilter(effect);
274 EXPECT_TRUE(imageFilter != nullptr);
275 }
276
277 /*
278 * @tc.name: CreateShaderImageFilterTest002
279 * @tc.desc: test for creating a filter that with invalid input.
280 * @tc.type: FUNC
281 * @tc.require: I77M3W
282 */
283 HWTEST_F(ImageFilterTest, CreateShaderImageFilterTest002, TestSize.Level1)
284 {
285 auto imageFilter = ImageFilter::CreateShaderImageFilter(nullptr);
286 EXPECT_TRUE(imageFilter != nullptr);
287 }
288
289 /*
290 * @tc.name: CreateShaderImageFilterTest003
291 * @tc.desc: test for creating a filter that with invalid input.
292 * @tc.type: FUNC
293 * @tc.require: I77M3W
294 */
295 HWTEST_F(ImageFilterTest, CreateShaderImageFilterTest003, TestSize.Level1)
296 {
297 std::shared_ptr<ShaderEffect> effect = ShaderEffect::CreateColorShader(0);
298 Rect rect {0, 0, 100.0f, 100.0f};
299 auto imageFilter = ImageFilter::CreateShaderImageFilter(effect, rect);
300 EXPECT_TRUE(imageFilter != nullptr);
301 }
302 } // namespace Drawing
303 } // namespace Rosen
304 } // namespace OHOS
305