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 */
HWTEST_F(EffectFilterUnittest, OH_Filter_CreateEffect001, TestSize.Level1)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 */
HWTEST_F(EffectFilterUnittest, OH_Filter_Invert001, TestSize.Level1)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 */
HWTEST_F(EffectFilterUnittest, OH_Filter_Blur001, TestSize.Level1)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_GrayScale
124 * @tc.desc: Create a gray scale effect filter with pixelmap.
125 * @tc.type: FUNC
126 * @tc.require: I9CSQ0
127 * @tc.author:
128 */
HWTEST_F(EffectFilterUnittest, OH_Filter_GrayScale001, TestSize.Level1)129 HWTEST_F(EffectFilterUnittest, OH_Filter_GrayScale001, TestSize.Level1)
130 {
131 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_GrayScale001 start";
132 OH_PixelmapNative *pixmap = nullptr;
133 /** pixmap is necessary, otherwize 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 ASSERT_TRUE(OH_Filter_GrayScale(filter) == EFFECT_SUCCESS);
140 ASSERT_TRUE(OH_Filter_GrayScale(nullptr) == EFFECT_BAD_PARAMETER);
141 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
142 OH_PixelmapNative_Release(*pixMap);
143 }
144
145 /**
146 * @tc.name: OH_Filter_Brighten
147 * @tc.desc: Create a brighten effect filter with pixelmap.
148 * @tc.type: FUNC
149 * @tc.require: I9CSQ0
150 * @tc.author:
151 */
HWTEST_F(EffectFilterUnittest, OH_Filter_Brighten001, TestSize.Level1)152 HWTEST_F(EffectFilterUnittest, OH_Filter_Brighten001, TestSize.Level1)
153 {
154 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_Brighten001 start";
155 OH_PixelmapNative *pixmap = nullptr;
156 /** pixmap is necessary, otherwize can not create pixelmap*/
157 OH_PixelmapNative ** pixMap = &pixmap;
158 CreatePixelMap(&pixMap);
159 ASSERT_TRUE(*pixMap != nullptr);
160 OH_Filter *filter = nullptr;
161 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
162 // 0.5 for test
163 ASSERT_TRUE(OH_Filter_Brighten(filter, 0.5) == EFFECT_SUCCESS);
164 // 0.5 for test
165 ASSERT_TRUE(OH_Filter_Brighten(nullptr, 0.5) == 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_SetColorMatrix
172 * @tc.desc: Create a effect filter with pixelmap.
173 * @tc.type: FUNC
174 * @tc.require: I9CSQ0
175 * @tc.author:
176 */
HWTEST_F(EffectFilterUnittest, OH_Filter_SetColorMatrix001, TestSize.Level1)177 HWTEST_F(EffectFilterUnittest, OH_Filter_SetColorMatrix001, TestSize.Level1)
178 {
179 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_SetColorMatrix001 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 // -1 means color matrix value for test
188 OH_Filter_ColorMatrix matrix {
189 -1.0, 0, 0, 0, 1,
190 0, -1.0, 0, 0, 1,
191 0, 0, -1.0, 0, 1,
192 0, 0, 0, 1, 0
193 };
194 ASSERT_TRUE(OH_Filter_SetColorMatrix(filter, &matrix) == EFFECT_SUCCESS);
195 ASSERT_TRUE(OH_Filter_SetColorMatrix(nullptr, &matrix) == EFFECT_BAD_PARAMETER);
196 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
197 OH_PixelmapNative_Release(*pixMap);
198 }
199
200 /**
201 * @tc.name: OH_Filter_GetEffectPixelMap
202 * @tc.desc: Get a pixelmap created by the filter.
203 * @tc.type: FUNC
204 * @tc.require: I9CSQ0
205 * @tc.author:
206 */
HWTEST_F(EffectFilterUnittest, OH_Filter_GetEffectPixelMap001, TestSize.Level1)207 HWTEST_F(EffectFilterUnittest, OH_Filter_GetEffectPixelMap001, TestSize.Level1)
208 {
209 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_GetEffectPixelMap001 start";
210 OH_PixelmapNative *pixmap = nullptr;
211 /** pixmap is necessary, otherwize can not create pixelmap*/
212 OH_PixelmapNative ** pixMap = &pixmap;
213 CreatePixelMap(&pixMap);
214 ASSERT_TRUE(*pixMap != nullptr);
215 OH_Filter *filter = nullptr;
216 ASSERT_TRUE(OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS);
217 ASSERT_TRUE(OH_Filter_Invert(filter) == EFFECT_SUCCESS);
218 OH_PixelmapNative*pixelMap1 = nullptr;
219 ASSERT_TRUE(OH_Filter_GetEffectPixelMap(filter, &pixelMap1) == EFFECT_SUCCESS);
220 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
221 OH_PixelmapNative_Release(*pixMap);
222 OH_PixelmapNative_Release(pixelMap1);
223 }
224
225 /**
226 * @tc.name: OH_Filter_Release
227 * @tc.desc: Get a pixelmap created by the filter.
228 * @tc.type: FUNC
229 * @tc.require: I9CSQ0
230 * @tc.author:
231 */
HWTEST_F(EffectFilterUnittest, OH_Filter_Release001, TestSize.Level1)232 HWTEST_F(EffectFilterUnittest, OH_Filter_Release001, TestSize.Level1)
233 {
234 GTEST_LOG_(INFO) << "EffectFilterUnittest OH_Filter_Release001 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 ASSERT_TRUE(OH_Filter_Release(nullptr) == EFFECT_BAD_PARAMETER);
244 ASSERT_TRUE(OH_Filter_Release(filter) == EFFECT_SUCCESS);
245 OH_PixelmapNative_Release(*pixMap);
246 }
247 } // namespace Rosen
248 } // namespace OHOS
249