1 /* 2 * Copyright (c) 2024 Shenzhen Kaihong Digital Industry Development 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 "drawing_bitmap.h" 17 #include "drawing_brush.h" 18 #include "drawing_canvas.h" 19 #include "drawing_color.h" 20 #include "drawing_color_filter.h" 21 #include "drawing_error_code.h" 22 #include "drawing_filter.h" 23 #include "drawing_font.h" 24 #include "drawing_image.h" 25 #include "drawing_image_filter.h" 26 #include "drawing_mask_filter.h" 27 #include "drawing_matrix.h" 28 #include "drawing_memory_stream.h" 29 #include "drawing_path.h" 30 #include "drawing_pen.h" 31 #include "drawing_point.h" 32 #include "drawing_rect.h" 33 #include "drawing_region.h" 34 #include "drawing_round_rect.h" 35 #include "drawing_sampling_options.h" 36 #include "drawing_shader_effect.h" 37 #include "drawing_shadow_layer.h" 38 #include "drawing_text_blob.h" 39 #include "drawing_typeface.h" 40 #include "gtest/gtest.h" 41 42 using namespace testing; 43 using namespace testing::ext; 44 45 namespace OHOS { 46 namespace Rosen { 47 namespace Drawing { 48 class DrawingNativeFilterTest : public testing::Test { 49 protected: 50 // 在每个测试用例执行前调用 SetUp()51 void SetUp() override 52 { 53 // 设置代码 54 std::cout << "DrawingNativeFilterTest Setup code called before each test case." << std::endl; 55 OH_Drawing_ErrorCodeReset(); 56 std::cout << "DrawingNativeFilterTest errorCodeReset before each test case." << std::endl; 57 } TearDown()58 void TearDown() override 59 { 60 std::cout << "DrawingNativeFilterTest Setup code called after each test case." << std::endl; 61 OH_Drawing_ErrorCodeReset(); 62 std::cout << "DrawingNativeFilterTest errorCodeReset after each test case." << std::endl; 63 } 64 }; 65 66 /* 67 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0100 68 * @tc.name: testFilterCreateDestroyNormal 69 * @tc.desc: Test for creating and destroying a filter with normal parameters. 70 * @tc.size : SmallTest 71 * @tc.type : Function 72 * @tc.level : Level 0 73 */ 74 HWTEST_F(DrawingNativeFilterTest, testFilterCreateDestroyNormal, Function | SmallTest | Level0) { 75 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 76 EXPECT_NE(filter, nullptr); 77 78 OH_Drawing_FilterDestroy(filter); 79 } 80 81 /* 82 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0101 83 * @tc.name: testFilterCreateDestroyNULL 84 * @tc.desc: Test for destroying a filter with NULL parameter. 85 * @tc.size : SmallTest 86 * @tc.type : Function 87 * @tc.level : Level 3 88 */ 89 HWTEST_F(DrawingNativeFilterTest, testFilterCreateDestroyNULL, Function | SmallTest | Level3) { 90 OH_Drawing_FilterDestroy(nullptr); 91 // add assert 92 EXPECT_TRUE(true); 93 } 94 95 /* 96 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0102 97 * @tc.name: testFilterCreateDestroyMultipleCalls 98 * @tc.desc: Test for creating and destroying a filter multiple times and in loops. 99 * @tc.size : SmallTest 100 * @tc.type : Function 101 * @tc.level : Level 3 102 */ 103 HWTEST_F(DrawingNativeFilterTest, testFilterCreateDestroyMultipleCalls, Function | SmallTest | Level3) { 104 105 for (int i = 0; i < 10; i++) { 106 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 107 EXPECT_NE(filter, nullptr); 108 OH_Drawing_FilterDestroy(filter); 109 } 110 } 111 112 /* 113 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0200 114 * @tc.name: testFilterSetImageFilterNormal 115 * @tc.desc: Test for setting an image filter with normal parameters. 116 * @tc.size : SmallTest 117 * @tc.type : Function 118 * @tc.level : Level 0 119 */ 120 HWTEST_F(DrawingNativeFilterTest, testFilterSetImageFilterNormal, Function | SmallTest | Level0) { 121 OH_Drawing_Filter *cFilter = OH_Drawing_FilterCreate(); 122 // add assert 123 EXPECT_NE(cFilter, nullptr); 124 OH_Drawing_ImageFilter *cImageFilter = 125 OH_Drawing_ImageFilterCreateBlur(10, 10, OH_Drawing_TileMode::CLAMP, nullptr); 126 // add assert 127 EXPECT_NE(cImageFilter, nullptr); 128 129 OH_Drawing_FilterSetImageFilter(cFilter, cImageFilter); 130 // add assert 131 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 132 133 OH_Drawing_FilterDestroy(cFilter); 134 OH_Drawing_ImageFilterDestroy(cImageFilter); 135 } 136 137 /* 138 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0201 139 * @tc.name: testFilterSetImageFilterNULL 140 * @tc.desc: Test for setting an image filter with NULL parameters. 141 * @tc.size : SmallTest 142 * @tc.type : Function 143 * @tc.level : Level 3 144 */ 145 HWTEST_F(DrawingNativeFilterTest, testFilterSetImageFilterNULL, Function | SmallTest | Level3) { 146 OH_Drawing_Filter *cFilter = OH_Drawing_FilterCreate(); 147 // add assert 148 EXPECT_NE(cFilter, nullptr); 149 OH_Drawing_ImageFilter *cImageFilter = 150 OH_Drawing_ImageFilterCreateBlur(10, 10, OH_Drawing_TileMode::CLAMP, nullptr); 151 // add assert 152 EXPECT_NE(cImageFilter, nullptr); 153 OH_Drawing_FilterSetImageFilter(nullptr, cImageFilter); 154 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 155 OH_Drawing_ErrorCodeReset(); 156 OH_Drawing_FilterSetImageFilter(cFilter, nullptr); 157 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 158 159 OH_Drawing_FilterDestroy(cFilter); 160 OH_Drawing_ImageFilterDestroy(cImageFilter); 161 } 162 163 /* 164 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0202 165 * @tc.name: testFilterSetImageFilterMultipleCalls 166 * @tc.desc: Test for setting an image filter multiple times with different objects. 167 * @tc.size : SmallTest 168 * @tc.type : Function 169 * @tc.level : Level 3 170 */ 171 HWTEST_F(DrawingNativeFilterTest, testFilterSetImageFilterMultipleCalls, Function | SmallTest | Level3) { 172 for (int i = 0; i < 10; i++) { 173 OH_Drawing_Filter *cFilter = OH_Drawing_FilterCreate(); 174 // add assert 175 EXPECT_NE(cFilter, nullptr); 176 OH_Drawing_ImageFilter *cImageFilter = 177 OH_Drawing_ImageFilterCreateBlur(10 + i, 10 + i, OH_Drawing_TileMode::CLAMP, nullptr); 178 // add assert 179 EXPECT_NE(cImageFilter, nullptr); 180 OH_Drawing_FilterSetImageFilter(cFilter, cImageFilter); 181 // add assert 182 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 183 OH_Drawing_FilterDestroy(cFilter); 184 OH_Drawing_ImageFilterDestroy(cImageFilter); 185 } 186 } 187 188 /* 189 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0300 190 * @tc.name: testFilterSetMaskFilterNormal 191 * @tc.desc: Test for setting a mask filter with normal parameters. 192 * @tc.size : SmallTest 193 * @tc.type : Function 194 * @tc.level : Level 0 195 */ 196 HWTEST_F(DrawingNativeFilterTest, testFilterSetMaskFilterNormal, Function | SmallTest | Level0) { 197 // 1. Create OH_Drawing_Filter using OH_Drawing_FilterCreate and OH_Drawing_MaskFilter using 198 // OH_Drawing_MaskFilterCreateBlur 199 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 200 // add assert 201 EXPECT_NE(filter, nullptr); 202 OH_Drawing_MaskFilter *maskFilter = OH_Drawing_MaskFilterCreateBlur(OH_Drawing_BlurType::NORMAL, 10, true); 203 // add assert 204 EXPECT_NE(maskFilter, nullptr); 205 // 2. Set mask filter using OH_Drawing_FilterSetMaskFilter, should return OH_DRAWING_SUCCESS 206 OH_Drawing_FilterSetMaskFilter(filter, maskFilter); 207 // add assert 208 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 209 // 3. Destroy objects, should be successful 210 OH_Drawing_FilterDestroy(filter); 211 OH_Drawing_MaskFilterDestroy(maskFilter); 212 } 213 214 /* 215 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0301 216 * @tc.name: testFilterSetMaskFilterNULL 217 * @tc.desc: Test for setting a mask filter with NULL parameters. 218 * @tc.size : SmallTest 219 * @tc.type : Function 220 * @tc.level : Level 3 221 */ 222 HWTEST_F(DrawingNativeFilterTest, testFilterSetMaskFilterNULL, Function | SmallTest | Level3) { 223 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 224 // add assert 225 EXPECT_NE(filter, nullptr); 226 OH_Drawing_MaskFilter *maskFilter = OH_Drawing_MaskFilterCreateBlur(OH_Drawing_BlurType::NORMAL, 10, true); 227 // add assert 228 EXPECT_NE(maskFilter, nullptr); 229 // 1. Pass nullptr as the first parameter to OH_Drawing_FilterSetMaskFilter and check the error code using 230 // OH_Drawing_ErrorCodeGet, 231 // 1. No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 232 OH_Drawing_FilterSetMaskFilter(nullptr, maskFilter); 233 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 234 OH_Drawing_ErrorCodeReset(); 235 236 // 2. Pass nullptr as the second parameter to OH_Drawing_FilterSetMaskFilter and check the error code using 237 // OH_Drawing_ErrorCodeGet, 238 // 2. No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 239 OH_Drawing_FilterSetMaskFilter(filter, nullptr); 240 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 241 242 // 3. Free memory 243 OH_Drawing_FilterDestroy(filter); 244 OH_Drawing_MaskFilterDestroy(maskFilter); 245 } 246 247 /* 248 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0302 249 * @tc.name: testFilterSetMaskFilterMultipleCalls 250 * @tc.desc: Test for setting a mask filter multiple times with different objects. 251 * @tc.size : SmallTest 252 * @tc.type : Function 253 * @tc.level : Level 3 254 */ 255 HWTEST_F(DrawingNativeFilterTest, testFilterSetMaskFilterMultipleCalls, Function | SmallTest | Level3) { 256 // 1. Call OH_Drawing_FilterSetMaskFilter 10 times with different OH_Drawing_Filter and OH_Drawing_MaskFilter 257 // objects. 258 for (int i = 0; i < 10; i++) { 259 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 260 // add assert 261 EXPECT_NE(filter, nullptr); 262 OH_Drawing_MaskFilter *maskFilter = OH_Drawing_MaskFilterCreateBlur(OH_Drawing_BlurType::NORMAL, 10 + i, true); 263 // add assert 264 EXPECT_NE(maskFilter, nullptr); 265 OH_Drawing_FilterSetMaskFilter(filter, maskFilter); 266 OH_Drawing_FilterDestroy(filter); 267 OH_Drawing_MaskFilterDestroy(maskFilter); 268 } 269 } 270 271 /* 272 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0400 273 * @tc.name: testFilterSetColorFilterNormal 274 * @tc.desc: Test for setting a color filter with normal parameters. 275 * @tc.size : SmallTest 276 * @tc.type : Function 277 * @tc.level : Level 0 278 */ 279 HWTEST_F(DrawingNativeFilterTest, testFilterSetColorFilterNormal, Function | SmallTest | Level0) { 280 // 1. Create OH_Drawing_Filter using OH_Drawing_FilterCreate 281 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 282 // add assert 283 EXPECT_NE(filter, nullptr); 284 OH_Drawing_ColorFilter *outerFilter = OH_Drawing_ColorFilterCreateLuma(); 285 // add assert 286 EXPECT_NE(outerFilter, nullptr); 287 OH_Drawing_ColorFilter *innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear(); 288 // add assert 289 EXPECT_NE(innerFilter, nullptr); 290 OH_Drawing_ColorFilter *colorFilter = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter); 291 // add assert 292 EXPECT_NE(colorFilter, nullptr); 293 // 2. Set color filter using OH_Drawing_FilterSetColorFilter 294 OH_Drawing_FilterSetColorFilter(filter, colorFilter); 295 // add assert 296 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 297 OH_Drawing_FilterGetColorFilter(filter, colorFilter); 298 // add assert 299 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 300 // 3. Destroy objects, should be successful 301 OH_Drawing_FilterDestroy(filter); 302 OH_Drawing_ColorFilterDestroy(outerFilter); 303 OH_Drawing_ColorFilterDestroy(innerFilter); 304 OH_Drawing_ColorFilterDestroy(colorFilter); 305 } 306 307 /* 308 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0401 309 * @tc.name: testFilterSetColorFilterNULL 310 * @tc.desc: Test for setting a color filter with NULL parameters. 311 * @tc.size : SmallTest 312 * @tc.type : Function 313 * @tc.level : Level 3 314 */ 315 HWTEST_F(DrawingNativeFilterTest, testFilterSetColorFilterNULL, Function | SmallTest | Level3) { 316 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 317 // add assert 318 EXPECT_NE(filter, nullptr); 319 OH_Drawing_ColorFilter *outerFilter = OH_Drawing_ColorFilterCreateLuma(); 320 // add assert 321 EXPECT_NE(outerFilter, nullptr); 322 OH_Drawing_ColorFilter *innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear(); 323 // add assert 324 EXPECT_NE(innerFilter, nullptr); 325 OH_Drawing_ColorFilter *colorFilter = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter); 326 // add assert 327 EXPECT_NE(colorFilter, nullptr); 328 // 1. Pass nullptr as the first parameter to OH_Drawing_FilterSetColorFilter and check the error code using 329 // OH_Drawing_ErrorCodeGet, No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 330 OH_Drawing_FilterSetColorFilter(nullptr, colorFilter); 331 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 332 OH_Drawing_ErrorCodeReset(); 333 334 // 2. Pass nullptr as the second parameter to OH_Drawing_FilterSetColorFilter and check the error code using 335 // OH_Drawing_ErrorCodeGet, No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 336 OH_Drawing_FilterSetColorFilter(filter, nullptr); 337 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 338 OH_Drawing_ErrorCodeReset(); 339 340 // 3. Pass nullptr as the first parameter to OH_Drawing_FilterGetColorFilter and check the error code using 341 // OH_Drawing_ErrorCodeGet, No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 342 OH_Drawing_FilterGetColorFilter(nullptr, colorFilter); 343 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 344 OH_Drawing_ErrorCodeReset(); 345 346 // 4. Pass nullptr as the second parameter to OH_Drawing_FilterGetColorFilter and check the error code using 347 // OH_Drawing_ErrorCodeGet, No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 348 OH_Drawing_FilterGetColorFilter(filter, nullptr); 349 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 350 351 // 5. Free memory 352 OH_Drawing_FilterDestroy(filter); 353 OH_Drawing_ColorFilterDestroy(outerFilter); 354 OH_Drawing_ColorFilterDestroy(innerFilter); 355 OH_Drawing_ColorFilterDestroy(colorFilter); 356 } 357 358 /* 359 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0402 360 * @tc.name: testFilterSetColorFilterMultipleCalls 361 * @tc.desc: Test for setting a color filter multiple times with different objects. 362 * @tc.size : SmallTest 363 * @tc.type : Function 364 * @tc.level : Level 3 365 */ 366 HWTEST_F(DrawingNativeFilterTest, testFilterSetColorFilterMultipleCalls, Function | SmallTest | Level3) { 367 // 1. Call OH_Drawing_FilterSetColorFilter 10 times with different OH_Drawing_Filter and OH_Drawing_ColorFilter 368 // objects. Call successful, errorcode returns OH_DRAWING_SUCCESS 369 for (int i = 0; i < 10; i++) { 370 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 371 // add assert 372 EXPECT_NE(filter, nullptr); 373 OH_Drawing_ColorFilter *outerFilter = OH_Drawing_ColorFilterCreateLuma(); 374 // add assert 375 EXPECT_NE(outerFilter, nullptr); 376 OH_Drawing_ColorFilter *innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear(); 377 // add assert 378 EXPECT_NE(innerFilter, nullptr); 379 OH_Drawing_ColorFilter *colorFilter = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter); 380 // add assert 381 EXPECT_NE(colorFilter, nullptr); 382 OH_Drawing_FilterSetColorFilter(filter, colorFilter); 383 OH_Drawing_FilterDestroy(filter); 384 OH_Drawing_ColorFilterDestroy(outerFilter); 385 OH_Drawing_ColorFilterDestroy(innerFilter); 386 OH_Drawing_ColorFilterDestroy(colorFilter); 387 } 388 } 389 390 } // namespace Drawing 391 } // namespace Rosen 392 } // namespace OHOS