1 /*
2 * Copyright (c) 2022-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/filter.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace Rosen {
25 namespace Drawing {
26 class FilterTest : 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 FilterTest::SetUpTestCase() {}
TearDownTestCase()35 void FilterTest::TearDownTestCase() {}
SetUp()36 void FilterTest::SetUp() {}
TearDown()37 void FilterTest::TearDown() {}
38
39 /*
40 * @tc.name: CreateAndDestroy001
41 * @tc.desc:
42 * @tc.type: FUNC
43 * @tc.require: AR000GGNV3
44 * @tc.author:
45 */
46 HWTEST_F(FilterTest, CreateAndDestroy001, TestSize.Level1)
47 {
48 auto filter = std::make_unique<Filter>();
49 EXPECT_TRUE(nullptr != filter);
50 }
51
52 /*
53 * @tc.name: GetterAndSetterColorFilter001
54 * @tc.desc:
55 * @tc.type: FUNC
56 * @tc.require: AR000GGNV3
57 * @tc.author:
58 */
59 HWTEST_F(FilterTest, GetterAndSetterColorFilter001, TestSize.Level1)
60 {
61 auto filter = std::make_unique<Filter>();
62 ASSERT_TRUE(filter != nullptr);
63 auto colorFilter = std::make_shared<ColorFilter>(ColorFilter::FilterType::BLEND_MODE);
64 filter->SetColorFilter(colorFilter);
65 auto result = filter->GetColorFilter();
66 EXPECT_FALSE(result != colorFilter);
67 }
68
69 /*
70 * @tc.name: GetterAndSetterColorFilter002
71 * @tc.desc:
72 * @tc.type: FUNC
73 * @tc.require: AR000GGNV3
74 * @tc.author:
75 */
76 HWTEST_F(FilterTest, GetterAndSetterColorFilter002, TestSize.Level1)
77 {
78 auto filter = std::make_unique<Filter>();
79 ASSERT_TRUE(filter != nullptr);
80 auto colorFilter = std::make_shared<ColorFilter>(ColorFilter::FilterType::LINEAR_TO_SRGB_GAMMA);
81 filter->SetColorFilter(colorFilter);
82 auto result = filter->GetColorFilter();
83 EXPECT_FALSE(result != colorFilter);
84 }
85
86 /*
87 * @tc.name: GetterAndSetterImageFilter001
88 * @tc.desc: test for seting and geting imageFilter.
89 * @tc.type: FUNC
90 * @tc.require: I73UXK
91 */
92 HWTEST_F(FilterTest, GetterAndSetterImageFilter001, TestSize.Level1)
93 {
94 auto filter = std::make_unique<Filter>();
95 ASSERT_TRUE(filter != nullptr);
96 auto imageFilter = ImageFilter::CreateBlurImageFilter(10.0f, 10.0f, TileMode::CLAMP, nullptr);
97 ASSERT_TRUE(imageFilter != nullptr);
98 filter->SetImageFilter(imageFilter);
99 auto result = filter->GetImageFilter();
100 EXPECT_FALSE(result != imageFilter);
101 }
102
103 /*
104 * @tc.name: GetterAndSetterImageFilter002
105 * @tc.desc: test for seting and geting imageFilter.
106 * @tc.type: FUNC
107 * @tc.require: I73UXK
108 */
109 HWTEST_F(FilterTest, GetterAndSetterImageFilter002, TestSize.Level1)
110 {
111 auto filter = std::make_unique<Filter>();
112 ASSERT_TRUE(filter != nullptr);
113 auto imageFilter = ImageFilter::CreateBlurImageFilter(20.0f, 20.0f, TileMode::CLAMP, nullptr);
114 ASSERT_TRUE(imageFilter != nullptr);
115 filter->SetImageFilter(imageFilter);
116 auto result = filter->GetImageFilter();
117 EXPECT_FALSE(result != imageFilter);
118 }
119
120 /*
121 * @tc.name: GetterAndSetterMaskFilter001
122 * @tc.desc:
123 * @tc.type: FUNC
124 * @tc.require: AR000GGNV3
125 * @tc.author:
126 */
127 HWTEST_F(FilterTest, GetterAndSetterMaskFilter001, TestSize.Level1)
128 {
129 auto filter = std::make_unique<Filter>();
130 ASSERT_TRUE(filter != nullptr);
131 auto maskFilter = std::make_shared<MaskFilter>(MaskFilter::FilterType::BLUR, BlurType::SOLID, 0.5f);
132 filter->SetMaskFilter(maskFilter);
133 auto result = filter->GetMaskFilter();
134 EXPECT_FALSE(result != maskFilter);
135 }
136
137 /*
138 * @tc.name: GetterAndSetterMaskFilter002
139 * @tc.desc:
140 * @tc.type: FUNC
141 * @tc.require: AR000GGNV3
142 * @tc.author:
143 */
144 HWTEST_F(FilterTest, GetterAndSetterMaskFilter002, TestSize.Level1)
145 {
146 auto filter = std::make_unique<Filter>();
147 ASSERT_TRUE(filter != nullptr);
148 auto maskFilter = std::make_shared<MaskFilter>(MaskFilter::FilterType::NO_TYPE, BlurType::SOLID, 0.2f);
149 filter->SetMaskFilter(maskFilter);
150 auto result = filter->GetMaskFilter();
151 EXPECT_FALSE(result != maskFilter);
152 }
153
154 /*
155 * @tc.name: GetterAndSetterFilterQuality001
156 * @tc.desc:
157 * @tc.type: FUNC
158 * @tc.require: AR000GGNV3
159 * @tc.author:
160 */
161 HWTEST_F(FilterTest, GetterAndSetterFilterQuality001, TestSize.Level1)
162 {
163 auto filter = std::make_unique<Filter>();
164 ASSERT_TRUE(filter != nullptr);
165 Filter::FilterQuality filterQuality = Filter::FilterQuality::LOW;
166 filter->SetFilterQuality(filterQuality);
167 auto result = filter->GetFilterQuality();
168 EXPECT_FALSE(result != filterQuality);
169 }
170
171 /*
172 * @tc.name: GetterAndSetterFilterQuality002
173 * @tc.desc:
174 * @tc.type: FUNC
175 * @tc.require: AR000GGNV3
176 * @tc.author:
177 */
178 HWTEST_F(FilterTest, GetterAndSetterFilterQuality002, TestSize.Level1)
179 {
180 auto filter = std::make_unique<Filter>();
181 ASSERT_TRUE(filter != nullptr);
182 Filter::FilterQuality filterQuality = Filter::FilterQuality::MEDIUM;
183 filter->SetFilterQuality(filterQuality);
184 auto result = filter->GetFilterQuality();
185 EXPECT_FALSE(result != filterQuality);
186 }
187
188 /*
189 * @tc.name: OverrideEquals001
190 * @tc.desc:
191 * @tc.type: FUNC
192 * @tc.require: AR000GGNV3
193 * @tc.author:
194 */
195 HWTEST_F(FilterTest, OverrideEquals001, TestSize.Level1)
196 {
197 Filter filter1;
198 auto colorFilter = std::make_shared<ColorFilter>(ColorFilter::FilterType::BLEND_MODE);
199 filter1.SetColorFilter(colorFilter);
200 Filter filter2;
201 auto colorFilter2 = std::make_shared<ColorFilter>(ColorFilter::FilterType::LINEAR_TO_SRGB_GAMMA);
202 filter2.SetColorFilter(colorFilter2);
203 EXPECT_FALSE(filter1 == filter2);
204 }
205
206 /*
207 * @tc.name: OverrideEquals002
208 * @tc.desc:
209 * @tc.type: FUNC
210 * @tc.require: AR000GGNV3
211 * @tc.author:
212 */
213 HWTEST_F(FilterTest, OverrideEquals002, TestSize.Level1)
214 {
215 Filter filter1;
216 Filter filter2 = filter1;
217 EXPECT_TRUE(filter1 == filter2);
218 }
219
220 /*
221 * @tc.name: OverrideNotEquals001
222 * @tc.desc:
223 * @tc.type: FUNC
224 * @tc.require: AR000GGNV3
225 * @tc.author:
226 */
227 HWTEST_F(FilterTest, OverrideNotEquals001, TestSize.Level1)
228 {
229 Filter filter1;
230 auto colorFilter = std::make_shared<ColorFilter>(ColorFilter::FilterType::BLEND_MODE);
231 filter1.SetColorFilter(colorFilter);
232 Filter filter2;
233 auto colorFilter2 = std::make_shared<ColorFilter>(ColorFilter::FilterType::LINEAR_TO_SRGB_GAMMA);
234 filter2.SetColorFilter(colorFilter2);
235 EXPECT_TRUE(filter1 != filter2);
236 }
237
238 /*
239 * @tc.name: OverrideNotEquals002
240 * @tc.desc:
241 * @tc.type: FUNC
242 * @tc.require: AR000GGNV3
243 * @tc.author:
244 */
245 HWTEST_F(FilterTest, OverrideNotEquals002, TestSize.Level1)
246 {
247 Filter filter1;
248 Filter filter2;
249 EXPECT_FALSE(filter1 != filter2);
250 }
251 } // namespace Drawing
252 } // namespace Rosen
253 } // namespace OHOS
254