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 tile mode.
125  * @tc.type: FUNC
126  * @tc.require: IB3UJ4
127  * @tc.author:
128  */
129 HWTEST_F(EffectFilterUnittest, OH_Filter_BlurWithTileMode, TestSize.Level1)
130 {
131     GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_BlurWithTileMode start";
132     OH_PixelmapNative *pixmap = nullptr;
133     /** pixmap is necessary, otherwise can not create pixelmap*/
134     OH_PixelmapNative ** pixMap = &pixmap;
135     CreatePixelMap(&pixMap);
136     ASSERT_TRUE(*pixMap != nullptr);
137     OH_Filter *filter = nullptr;
138     ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
139     // 0.5 for test
140     ASSERT_TRUE(OH_Filter_BlurWithTileMode(filter, 0.5f, CLAMP) == EFFECT_SUCCESS);
141     // 0.5 for test
142     ASSERT_TRUE(OH_Filter_BlurWithTileMode(nullptr, 0.5, CLAMP) == EFFECT_BAD_PARAMETER);
143     ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
144     OH_PixelmapNative_Release(*pixMap);
145 }
146 
147 /**
148  * @tc.name: OH_Filter_GrayScale
149  * @tc.desc: Create a gray scale effect filter with pixelmap.
150  * @tc.type: FUNC
151  * @tc.require: I9CSQ0
152  * @tc.author:
153  */
154 HWTEST_F(EffectFilterUnittest, OH_Filter_GrayScale001, TestSize.Level1)
155 {
156     GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_GrayScale001 start";
157     OH_PixelmapNative *pixmap = nullptr;
158     /** pixmap is necessary, otherwize can not create pixelmap*/
159     OH_PixelmapNative ** pixMap = &pixmap;
160     CreatePixelMap(&pixMap);
161     ASSERT_TRUE(*pixMap != nullptr);
162     OH_Filter *filter = nullptr;
163     ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
164     ASSERT_TRUE(OH_Filter_GrayScale(filter) == EFFECT_SUCCESS);
165     ASSERT_TRUE(OH_Filter_GrayScale(nullptr) == EFFECT_BAD_PARAMETER);
166     ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
167     OH_PixelmapNative_Release(*pixMap);
168 }
169 
170 /**
171  * @tc.name: OH_Filter_Brighten
172  * @tc.desc: Create a brighten effect filter with pixelmap.
173  * @tc.type: FUNC
174  * @tc.require: I9CSQ0
175  * @tc.author:
176  */
177 HWTEST_F(EffectFilterUnittest, OH_Filter_Brighten001, TestSize.Level1)
178 {
179     GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_Brighten001 start";
180     OH_PixelmapNative *pixmap = nullptr;
181     /** pixmap is necessary, otherwize can not create pixelmap*/
182     OH_PixelmapNative ** pixMap = &pixmap;
183     CreatePixelMap(&pixMap);
184     ASSERT_TRUE(*pixMap != nullptr);
185     OH_Filter *filter = nullptr;
186     ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
187     // 0.5 for test
188     ASSERT_TRUE(OH_Filter_Brighten(filter, 0.5) == EFFECT_SUCCESS);
189     // 0.5 for test
190     ASSERT_TRUE(OH_Filter_Brighten(nullptr, 0.5) == EFFECT_BAD_PARAMETER);
191     ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
192     OH_PixelmapNative_Release(*pixMap);
193 }
194 
195 /**
196  * @tc.name: OH_Filter_SetColorMatrix
197  * @tc.desc: Create a effect filter with pixelmap.
198  * @tc.type: FUNC
199  * @tc.require: I9CSQ0
200  * @tc.author:
201  */
202 HWTEST_F(EffectFilterUnittest, OH_Filter_SetColorMatrix001, TestSize.Level1)
203 {
204     GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_SetColorMatrix001 start";
205     OH_PixelmapNative *pixmap = nullptr;
206     /** pixmap is necessary, otherwize can not create pixelmap*/
207     OH_PixelmapNative ** pixMap = &pixmap;
208     CreatePixelMap(&pixMap);
209     ASSERT_TRUE(*pixMap != nullptr);
210     OH_Filter *filter = nullptr;
211     ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
212     // -1 means color matrix value for test
213     OH_Filter_ColorMatrix matrix {
214         -1.0, 0, 0, 0, 1,
215         0, -1.0, 0, 0, 1,
216         0, 0, -1.0, 0, 1,
217         0, 0, 0, 1, 0
218     };
219     ASSERT_TRUE(OH_Filter_SetColorMatrix(filter, &matrix) == EFFECT_SUCCESS);
220     ASSERT_TRUE(OH_Filter_SetColorMatrix(nullptr, &matrix) == EFFECT_BAD_PARAMETER);
221     ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
222     OH_PixelmapNative_Release(*pixMap);
223 }
224 
225 /**
226  * @tc.name: OH_Filter_GetEffectPixelMap
227  * @tc.desc: Get a pixelmap created by the filter.
228  * @tc.type: FUNC
229  * @tc.require: I9CSQ0
230  * @tc.author:
231  */
232 HWTEST_F(EffectFilterUnittest, OH_Filter_GetEffectPixelMap001, TestSize.Level1)
233 {
234     GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_GetEffectPixelMap001 start";
235     OH_PixelmapNative *pixmap = nullptr;
236     /** pixmap is necessary, otherwize can not create pixelmap*/
237     OH_PixelmapNative ** pixMap = &pixmap;
238     CreatePixelMap(&pixMap);
239     ASSERT_TRUE(*pixMap != nullptr);
240     OH_Filter *filter = nullptr;
241     ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
242     ASSERT_TRUE(OH_Filter_Invert(filter) == EFFECT_SUCCESS);
243     OH_PixelmapNative*pixelMap1 = nullptr;
244     ASSERT_TRUE(OH_Filter_GetEffectPixelMap(filter, &pixelMap1) == EFFECT_SUCCESS);
245     ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
246     OH_PixelmapNative_Release(*pixMap);
247     OH_PixelmapNative_Release(pixelMap1);
248 }
249 
250 /**
251  * @tc.name: OH_Filter_Release
252  * @tc.desc: Get a pixelmap created by the filter.
253  * @tc.type: FUNC
254  * @tc.require: I9CSQ0
255  * @tc.author:
256  */
257 HWTEST_F(EffectFilterUnittest, OH_Filter_Release001, TestSize.Level1)
258 {
259     GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_Release001 start";
260     OH_PixelmapNative *pixmap = nullptr;
261     /** pixmap is necessary, otherwize can not create pixelmap*/
262     OH_PixelmapNative ** pixMap = &pixmap;
263     CreatePixelMap(&pixMap);
264     ASSERT_TRUE(*pixMap != nullptr);
265     OH_Filter *filter = nullptr;
266     ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
267     ASSERT_TRUE(OH_Filter_Invert(filter) == EFFECT_SUCCESS);
268     ASSERT_TRUE(OH_Filter_Release(nullptr) == EFFECT_BAD_PARAMETER);
269     ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
270     OH_PixelmapNative_Release(*pixMap);
271 }
272 } // namespace Rosen
273 } // namespace OHOS
274