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
21using namespace testing;
22using namespace testing::ext;
23
24namespace OHOS {
25namespace Rosen {
26
27static 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 */
58HWTEST_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 */
81HWTEST_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 */
104HWTEST_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 */
129HWTEST_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 */
152HWTEST_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 */
177HWTEST_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 */
207HWTEST_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 */
232HWTEST_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