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 "effect_filter_unittest.h"
17
18 #include "effect_filter.h"
19 #include "image/pixelmap_native.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace Rosen {
26
CreatePixelMap(OH_PixelmapNative *** pixelmap)27 static void CreatePixelMap(OH_PixelmapNative*** pixelmap)
28 {
29 OH_Pixelmap_InitializationOptions *ops = nullptr;
30 OH_PixelmapInitializationOptions_Create(&ops);
31 // 2 means alphaType
32 OH_PixelmapInitializationOptions_SetAlphaType(ops, 2);
33 // 4 means height
34 OH_PixelmapInitializationOptions_SetHeight(ops, 4);
35 // 4 means width
36 OH_PixelmapInitializationOptions_SetWidth(ops, 4);
37 // 4 means pixelFormat
38 OH_PixelmapInitializationOptions_SetPixelFormat(ops, 4);
39 // 255 means rgba data
40 uint8_t data[] = {
41 255, 255, 0, 255,
42 255, 255, 0, 255,
43 255, 255, 0, 255,
44 255, 255, 0, 255
45 };
46 // 16 means data length
47 size_t dataLength = 16;
48 OH_PixelmapNative_CreatePixelmap(data, dataLength, ops, *pixelmap);
49 }
50
51 /**
52 * @tc.name: OH_Filter_CreateEffect
53 * @tc.desc: Create a effect filter with pixelmap.
54 * @tc.type: FUNC
55 * @tc.require: I9CSQ0
56 * @tc.author:
57 */
58 HWTEST_F(EffectFilterUnittest, OH_Filter_CreateEffect001, TestSize.Level1)
59 {
60 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_CreateEffect001 start";
61 OH_PixelmapNative *pixmap = nullptr;
62 /** pixmap is necessary, otherwize can not create pixelmap*/
63 OH_PixelmapNative ** pixMap = &pixmap;
64 CreatePixelMap(&pixMap);
65 ASSERT_TRUE(*pixMap != nullptr);
66 OH_Filter *filter = nullptr;
67 ASSERT_TRUE(OH_Filter_CreateEffect(nullptr, &filter) != EFFECT_SUCCESS);
68 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, nullptr) != EFFECT_SUCCESS);
69 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
70 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
71 OH_PixelmapNative_Release(*pixMap);
72 }
73
74 /**
75 * @tc.name: OH_Filter_Invert
76 * @tc.desc: Create a invert effect filter.
77 * @tc.type: FUNC
78 * @tc.require: I9CSQ0
79 * @tc.author:
80 */
81 HWTEST_F(EffectFilterUnittest, OH_Filter_Invert001, TestSize.Level1)
82 {
83 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_Invert001 start";
84 OH_PixelmapNative *pixmap = nullptr;
85 /** pixmap is necessary, otherwize can not create pixelmap*/
86 OH_PixelmapNative ** pixMap = &pixmap;
87 CreatePixelMap(&pixMap);
88 ASSERT_TRUE(*pixMap != nullptr);
89 OH_Filter *filter = nullptr;
90 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
91 ASSERT_TRUE(OH_Filter_Invert(filter) == EFFECT_SUCCESS);
92 ASSERT_TRUE(OH_Filter_Invert(nullptr) == EFFECT_BAD_PARAMETER);
93 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
94 OH_PixelmapNative_Release(*pixMap);
95 }
96
97 /**
98 * @tc.name: OH_Filter_Blur
99 * @tc.desc: Create a blur effect filter with pixelmap.
100 * @tc.type: FUNC
101 * @tc.require: I9CSQ0
102 * @tc.author:
103 */
104 HWTEST_F(EffectFilterUnittest, OH_Filter_Blur001, TestSize.Level1)
105 {
106 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_Blur001 start";
107 OH_PixelmapNative *pixmap = nullptr;
108 /** pixmap is necessary, otherwize can not create pixelmap*/
109 OH_PixelmapNative ** pixMap = &pixmap;
110 CreatePixelMap(&pixMap);
111 ASSERT_TRUE(*pixMap != nullptr);
112 OH_Filter *filter = nullptr;
113 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
114 // 0.5 for test
115 ASSERT_TRUE(OH_Filter_Blur(filter, 0.5f) == EFFECT_SUCCESS);
116 // 0.5 for test
117 ASSERT_TRUE(OH_Filter_Blur(nullptr, 0.5) == EFFECT_BAD_PARAMETER);
118 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
119 OH_PixelmapNative_Release(*pixMap);
120 }
121
122 /**
123 * @tc.name: OH_Filter_Blur
124 * @tc.desc: Create a blur effect filter with pixelmap.
125 * @tc.type: FUNC
126 * @tc.require: I9CSQ0
127 * @tc.author:
128 */
129 HWTEST_F(EffectFilterUnittest, OH_Filter_Blur002, TestSize.Level1)
130 {
131 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_Blur002 start";
132
133 OH_PixelmapNative *pixmap = nullptr;
134 /** pixmap is necessary, otherwize can not create pixelmap*/
135 OH_PixelmapNative ** pixMap = &pixmap;
136 CreatePixelMap(&pixMap);
137 ASSERT_TRUE(*pixMap != nullptr);
138 OH_Filter *filter = nullptr;
139 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
140 // -0.5 for test
141 ASSERT_TRUE(OH_Filter_Blur(filter, -0.5f) == EFFECT_BAD_PARAMETER);
142 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
143 OH_PixelmapNative_Release(*pixMap);
144
145 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_Blur002 start";
146 }
147
148 /**
149 * @tc.name: OH_Filter_Blur
150 * @tc.desc: Create a blur effect filter with tile mode.
151 * @tc.type: FUNC
152 * @tc.require: IB3UJ4
153 * @tc.author:
154 */
155 HWTEST_F(EffectFilterUnittest, OH_Filter_BlurWithTileMode, TestSize.Level1)
156 {
157 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_BlurWithTileMode start";
158 OH_PixelmapNative *pixmap = nullptr;
159 /** pixmap is necessary, otherwise can not create pixelmap*/
160 OH_PixelmapNative ** pixMap = &pixmap;
161 CreatePixelMap(&pixMap);
162 ASSERT_TRUE(*pixMap != nullptr);
163 OH_Filter *filter = nullptr;
164 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
165 // 0.5 for test
166 ASSERT_TRUE(OH_Filter_BlurWithTileMode(filter, 0.5f, CLAMP) == EFFECT_SUCCESS);
167 // 0.5 for test
168 ASSERT_TRUE(OH_Filter_BlurWithTileMode(nullptr, 0.5, CLAMP) == EFFECT_BAD_PARAMETER);
169 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
170 OH_PixelmapNative_Release(*pixMap);
171 }
172
173 /**
174 * @tc.name: OH_Filter_GrayScale
175 * @tc.desc: Create a gray scale effect filter with pixelmap.
176 * @tc.type: FUNC
177 * @tc.require: I9CSQ0
178 * @tc.author:
179 */
180 HWTEST_F(EffectFilterUnittest, OH_Filter_GrayScale001, TestSize.Level1)
181 {
182 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_GrayScale001 start";
183 OH_PixelmapNative *pixmap = nullptr;
184 /** pixmap is necessary, otherwize can not create pixelmap*/
185 OH_PixelmapNative ** pixMap = &pixmap;
186 CreatePixelMap(&pixMap);
187 ASSERT_TRUE(*pixMap != nullptr);
188 OH_Filter *filter = nullptr;
189 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
190 ASSERT_TRUE(OH_Filter_GrayScale(filter) == EFFECT_SUCCESS);
191 ASSERT_TRUE(OH_Filter_GrayScale(nullptr) == EFFECT_BAD_PARAMETER);
192 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
193 OH_PixelmapNative_Release(*pixMap);
194 }
195
196 /**
197 * @tc.name: OH_Filter_Brighten
198 * @tc.desc: Create a brighten effect filter with pixelmap.
199 * @tc.type: FUNC
200 * @tc.require: I9CSQ0
201 * @tc.author:
202 */
203 HWTEST_F(EffectFilterUnittest, OH_Filter_Brighten001, TestSize.Level1)
204 {
205 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_Brighten001 start";
206 OH_PixelmapNative *pixmap = nullptr;
207 /** pixmap is necessary, otherwize can not create pixelmap*/
208 OH_PixelmapNative ** pixMap = &pixmap;
209 CreatePixelMap(&pixMap);
210 ASSERT_TRUE(*pixMap != nullptr);
211 OH_Filter *filter = nullptr;
212 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
213 // 0.5 for test
214 ASSERT_TRUE(OH_Filter_Brighten(filter, 0.5) == EFFECT_SUCCESS);
215 // 0.5 for test
216 ASSERT_TRUE(OH_Filter_Brighten(nullptr, 0.5) == EFFECT_BAD_PARAMETER);
217 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
218 OH_PixelmapNative_Release(*pixMap);
219 }
220
221 /**
222 * @tc.name: OH_Filter_SetColorMatrix
223 * @tc.desc: Create a effect filter with pixelmap.
224 * @tc.type: FUNC
225 * @tc.require: I9CSQ0
226 * @tc.author:
227 */
228 HWTEST_F(EffectFilterUnittest, OH_Filter_SetColorMatrix001, TestSize.Level1)
229 {
230 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_SetColorMatrix001 start";
231 OH_PixelmapNative *pixmap = nullptr;
232 /** pixmap is necessary, otherwize can not create pixelmap*/
233 OH_PixelmapNative ** pixMap = &pixmap;
234 CreatePixelMap(&pixMap);
235 ASSERT_TRUE(*pixMap != nullptr);
236 OH_Filter *filter = nullptr;
237 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
238 // -1 means color matrix value for test
239 OH_Filter_ColorMatrix matrix {
240 -1.0, 0, 0, 0, 1,
241 0, -1.0, 0, 0, 1,
242 0, 0, -1.0, 0, 1,
243 0, 0, 0, 1, 0
244 };
245 ASSERT_TRUE(OH_Filter_SetColorMatrix(filter, &matrix) == EFFECT_SUCCESS);
246 ASSERT_TRUE(OH_Filter_SetColorMatrix(nullptr, &matrix) == EFFECT_BAD_PARAMETER);
247 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
248 OH_PixelmapNative_Release(*pixMap);
249 }
250
251 /**
252 * @tc.name: OH_Filter_GetEffectPixelMap
253 * @tc.desc: Get a pixelmap created by the filter.
254 * @tc.type: FUNC
255 * @tc.require: I9CSQ0
256 * @tc.author:
257 */
258 HWTEST_F(EffectFilterUnittest, OH_Filter_GetEffectPixelMap001, TestSize.Level1)
259 {
260 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_GetEffectPixelMap001 start";
261 OH_PixelmapNative *pixmap = nullptr;
262 /** pixmap is necessary, otherwize can not create pixelmap*/
263 OH_PixelmapNative ** pixMap = &pixmap;
264 CreatePixelMap(&pixMap);
265 ASSERT_TRUE(*pixMap != nullptr);
266 OH_Filter *filter = nullptr;
267 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
268 ASSERT_TRUE(OH_Filter_Invert(filter) == EFFECT_SUCCESS);
269 OH_PixelmapNative*pixelMap1 = nullptr;
270 ASSERT_TRUE(OH_Filter_GetEffectPixelMap(filter, &pixelMap1) == EFFECT_SUCCESS);
271 ASSERT_TRUE(OH_Filter_GetEffectPixelMap(nullptr, &pixelMap1) == EFFECT_BAD_PARAMETER);
272 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
273 OH_PixelmapNative_Release(*pixMap);
274 OH_PixelmapNative_Release(pixelMap1);
275 }
276
277 /**
278 * @tc.name: OH_Filter_GetEffectPixelMap
279 * @tc.desc: Get a pixelmap created by the filter.
280 * @tc.type: FUNC
281 * @tc.require: I9CSQ0
282 * @tc.author:
283 */
284 HWTEST_F(EffectFilterUnittest, OH_Filter_GetEffectPixelMap002, TestSize.Level1)
285 {
286 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_GetEffectPixelMap002 start";
287
288 OH_PixelmapNative *pixmap = nullptr;
289 /** pixmap is necessary, otherwize can not create pixelmap*/
290 OH_PixelmapNative ** pixMap = &pixmap;
291 CreatePixelMap(&pixMap);
292 ASSERT_TRUE(*pixMap != nullptr);
293 OH_Filter *filter = nullptr;
294 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
295 OH_PixelmapNative*pixelMap1 = nullptr;
296 ASSERT_TRUE(OH_Filter_GetEffectPixelMap(nullptr, &pixelMap1) == EFFECT_BAD_PARAMETER);
297 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
298 OH_PixelmapNative_Release(*pixMap);
299 OH_PixelmapNative_Release(pixelMap1);
300
301 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_GetEffectPixelMap002 start";
302 }
303
304 /**
305 * @tc.name: OH_Filter_GetEffectPixelMap003
306 * @tc.desc: Get a pixelmap created by the filter.
307 * @tc.type: FUNC
308 * @tc.require: I9CSQ0
309 * @tc.author:
310 */
311 HWTEST_F(EffectFilterUnittest, OH_Filter_GetEffectPixelMap003, TestSize.Level1)
312 {
313 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_GetEffectPixelMap003 start";
314 ASSERT_TRUE(OH_Filter_GetEffectPixelMap(nullptr, nullptr) == EFFECT_BAD_PARAMETER);
315
316 OH_PixelmapNative *pixelMap1 = nullptr;
317 ASSERT_TRUE(OH_Filter_GetEffectPixelMap(nullptr, &pixelMap1) == EFFECT_BAD_PARAMETER);
318 OH_PixelmapNative_Release(pixelMap1);
319 }
320
321 /**
322 * @tc.name: OH_Filter_Release
323 * @tc.desc: Get a pixelmap created by the filter.
324 * @tc.type: FUNC
325 * @tc.require: I9CSQ0
326 * @tc.author:
327 */
328 HWTEST_F(EffectFilterUnittest, OH_Filter_Release001, TestSize.Level1)
329 {
330 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_Release001 start";
331 OH_PixelmapNative *pixmap = nullptr;
332 /** pixmap is necessary, otherwize can not create pixelmap*/
333 OH_PixelmapNative ** pixMap = &pixmap;
334 CreatePixelMap(&pixMap);
335 ASSERT_TRUE(*pixMap != nullptr);
336 OH_Filter *filter = nullptr;
337 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
338 ASSERT_TRUE(OH_Filter_Invert(filter) == EFFECT_SUCCESS);
339 ASSERT_TRUE(OH_Filter_Release(nullptr) == EFFECT_BAD_PARAMETER);
340 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
341 OH_PixelmapNative_Release(*pixMap);
342 }
343 } // namespace Rosen
344 } // namespace OHOS
345