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 50 /* 51 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0100 52 * @tc.name: testFilterCreateDestroyNormal 53 * @tc.desc: Test for creating and destroying a filter with normal parameters. 54 * @tc.size : SmallTest 55 * @tc.type : Function 56 * @tc.level : Level 0 57 */ 58 HWTEST_F(DrawingNativeFilterTest, testFilterCreateDestroyNormal, TestSize.Level0) { 59 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 60 EXPECT_NE(filter, nullptr); 61 62 OH_Drawing_FilterDestroy(filter); 63 } 64 65 /* 66 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0101 67 * @tc.name: testFilterCreateDestroyNULL 68 * @tc.desc: Test for destroying a filter with NULL parameter. 69 * @tc.size : SmallTest 70 * @tc.type : Function 71 * @tc.level : Level 3 72 */ 73 HWTEST_F(DrawingNativeFilterTest, testFilterCreateDestroyNULL, TestSize.Level3) { OH_Drawing_FilterDestroy(nullptr); } 74 75 /* 76 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0102 77 * @tc.name: testFilterCreateDestroyMultipleCalls 78 * @tc.desc: Test for creating and destroying a filter multiple times and in loops. 79 * @tc.size : SmallTest 80 * @tc.type : Function 81 * @tc.level : Level 3 82 */ 83 HWTEST_F(DrawingNativeFilterTest, testFilterCreateDestroyMultipleCalls, TestSize.Level3) { 84 for (int i = 0; i < 10; i++) { 85 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 86 EXPECT_NE(filter, nullptr); 87 OH_Drawing_FilterDestroy(filter); 88 } 89 } 90 91 /* 92 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0200 93 * @tc.name: testFilterSetImageFilterNormal 94 * @tc.desc: Test for setting an image filter with normal parameters. 95 * @tc.size : SmallTest 96 * @tc.type : Function 97 * @tc.level : Level 0 98 */ 99 HWTEST_F(DrawingNativeFilterTest, testFilterSetImageFilterNormal, TestSize.Level0) { 100 OH_Drawing_Filter *cFilter = OH_Drawing_FilterCreate(); 101 OH_Drawing_ImageFilter *cImageFilter = 102 OH_Drawing_ImageFilterCreateBlur(10, 10, OH_Drawing_TileMode::CLAMP, nullptr); 103 104 OH_Drawing_FilterSetImageFilter(cFilter, cImageFilter); 105 106 OH_Drawing_FilterDestroy(cFilter); 107 OH_Drawing_ImageFilterDestroy(cImageFilter); 108 } 109 110 /* 111 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0201 112 * @tc.name: testFilterSetImageFilterNULL 113 * @tc.desc: Test for setting an image filter with NULL parameters. 114 * @tc.size : SmallTest 115 * @tc.type : Function 116 * @tc.level : Level 3 117 */ 118 HWTEST_F(DrawingNativeFilterTest, testFilterSetImageFilterNULL, TestSize.Level3) { 119 OH_Drawing_Filter *cFilter = OH_Drawing_FilterCreate(); 120 OH_Drawing_ImageFilter *cImageFilter = 121 OH_Drawing_ImageFilterCreateBlur(10, 10, OH_Drawing_TileMode::CLAMP, nullptr); 122 OH_Drawing_FilterSetImageFilter(nullptr, cImageFilter); 123 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 124 125 OH_Drawing_FilterSetImageFilter(cFilter, nullptr); 126 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 127 128 OH_Drawing_FilterDestroy(cFilter); 129 OH_Drawing_ImageFilterDestroy(cImageFilter); 130 } 131 132 /* 133 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0202 134 * @tc.name: testFilterSetImageFilterMultipleCalls 135 * @tc.desc: Test for setting an image filter multiple times with different objects. 136 * @tc.size : SmallTest 137 * @tc.type : Function 138 * @tc.level : Level 3 139 */ 140 HWTEST_F(DrawingNativeFilterTest, testFilterSetImageFilterMultipleCalls, TestSize.Level3) { 141 for (int i = 0; i < 10; i++) { 142 OH_Drawing_Filter *cFilter = OH_Drawing_FilterCreate(); 143 OH_Drawing_ImageFilter *cImageFilter = 144 OH_Drawing_ImageFilterCreateBlur(10 + i, 10 + i, OH_Drawing_TileMode::CLAMP, nullptr); 145 OH_Drawing_FilterSetImageFilter(cFilter, cImageFilter); 146 OH_Drawing_FilterDestroy(cFilter); 147 OH_Drawing_ImageFilterDestroy(cImageFilter); 148 } 149 } 150 151 /* 152 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0300 153 * @tc.name: testFilterSetMaskFilterNormal 154 * @tc.desc: Test for setting a mask filter with normal parameters. 155 * @tc.size : SmallTest 156 * @tc.type : Function 157 * @tc.level : Level 0 158 */ 159 HWTEST_F(DrawingNativeFilterTest, testFilterSetMaskFilterNormal, TestSize.Level0) { 160 // 1. Create OH_Drawing_Filter using OH_Drawing_FilterCreate and OH_Drawing_MaskFilter using 161 // OH_Drawing_MaskFilterCreateBlur 162 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 163 OH_Drawing_MaskFilter *maskFilter = OH_Drawing_MaskFilterCreateBlur(OH_Drawing_BlurType::NORMAL, 10, true); 164 // 2. Set mask filter using OH_Drawing_FilterSetMaskFilter, should return OH_DRAWING_SUCCESS 165 OH_Drawing_FilterSetMaskFilter(filter, maskFilter); 166 // 3. Destroy objects, should be successful 167 OH_Drawing_FilterDestroy(filter); 168 OH_Drawing_MaskFilterDestroy(maskFilter); 169 } 170 171 /* 172 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0301 173 * @tc.name: testFilterSetMaskFilterNULL 174 * @tc.desc: Test for setting a mask filter with NULL parameters. 175 * @tc.size : SmallTest 176 * @tc.type : Function 177 * @tc.level : Level 3 178 */ 179 HWTEST_F(DrawingNativeFilterTest, testFilterSetMaskFilterNULL, TestSize.Level3) { 180 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 181 OH_Drawing_MaskFilter *maskFilter = OH_Drawing_MaskFilterCreateBlur(OH_Drawing_BlurType::NORMAL, 10, true); 182 // 1. Pass nullptr as the first parameter to OH_Drawing_FilterSetMaskFilter and check the error code using 183 // OH_Drawing_ErrorCodeGet, 184 // 1. No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 185 OH_Drawing_FilterSetMaskFilter(nullptr, maskFilter); 186 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 187 188 // 2. Pass nullptr as the second parameter to OH_Drawing_FilterSetMaskFilter and check the error code using 189 // OH_Drawing_ErrorCodeGet, 190 // 2. No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 191 OH_Drawing_FilterSetMaskFilter(filter, nullptr); 192 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 193 194 // 3. Free memory 195 OH_Drawing_FilterDestroy(filter); 196 OH_Drawing_MaskFilterDestroy(maskFilter); 197 } 198 199 /* 200 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0302 201 * @tc.name: testFilterSetMaskFilterMultipleCalls 202 * @tc.desc: Test for setting a mask filter multiple times with different objects. 203 * @tc.size : SmallTest 204 * @tc.type : Function 205 * @tc.level : Level 3 206 */ 207 HWTEST_F(DrawingNativeFilterTest, testFilterSetMaskFilterMultipleCalls, TestSize.Level3) { 208 // 1. Call OH_Drawing_FilterSetMaskFilter 10 times with different OH_Drawing_Filter and OH_Drawing_MaskFilter 209 // objects. 210 for (int i = 0; i < 10; i++) { 211 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 212 OH_Drawing_MaskFilter *maskFilter = OH_Drawing_MaskFilterCreateBlur(OH_Drawing_BlurType::NORMAL, 10 + i, true); 213 OH_Drawing_FilterSetMaskFilter(filter, maskFilter); 214 OH_Drawing_FilterDestroy(filter); 215 OH_Drawing_MaskFilterDestroy(maskFilter); 216 } 217 } 218 219 /* 220 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0400 221 * @tc.name: testFilterSetColorFilterNormal 222 * @tc.desc: Test for setting a color filter with normal parameters. 223 * @tc.size : SmallTest 224 * @tc.type : Function 225 * @tc.level : Level 0 226 */ 227 HWTEST_F(DrawingNativeFilterTest, testFilterSetColorFilterNormal, TestSize.Level0) { 228 // 1. Create OH_Drawing_Filter using OH_Drawing_FilterCreate 229 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 230 OH_Drawing_ColorFilter *outerFilter = OH_Drawing_ColorFilterCreateLuma(); 231 OH_Drawing_ColorFilter *innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear(); 232 OH_Drawing_ColorFilter *colorFilter = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter); 233 // 2. Set color filter using OH_Drawing_FilterSetColorFilter 234 OH_Drawing_FilterSetColorFilter(filter, colorFilter); 235 // 3. Destroy objects, should be successful 236 OH_Drawing_FilterDestroy(filter); 237 OH_Drawing_ColorFilterDestroy(outerFilter); 238 OH_Drawing_ColorFilterDestroy(innerFilter); 239 OH_Drawing_ColorFilterDestroy(colorFilter); 240 } 241 242 /* 243 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0401 244 * @tc.name: testFilterSetColorFilterNULL 245 * @tc.desc: Test for setting a color filter with NULL parameters. 246 * @tc.size : SmallTest 247 * @tc.type : Function 248 * @tc.level : Level 3 249 */ 250 HWTEST_F(DrawingNativeFilterTest, testFilterSetColorFilterNULL, TestSize.Level3) { 251 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 252 OH_Drawing_ColorFilter *outerFilter = OH_Drawing_ColorFilterCreateLuma(); 253 OH_Drawing_ColorFilter *innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear(); 254 OH_Drawing_ColorFilter *colorFilter = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter); 255 // 1. Pass nullptr as the first parameter to OH_Drawing_FilterSetColorFilter and check the error code using 256 // OH_Drawing_ErrorCodeGet, No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 257 OH_Drawing_FilterSetColorFilter(nullptr, colorFilter); 258 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 259 260 // 2. Pass nullptr as the second parameter to OH_Drawing_FilterSetColorFilter and check the error code using 261 // OH_Drawing_ErrorCodeGet, No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 262 OH_Drawing_FilterSetColorFilter(filter, nullptr); 263 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 264 265 // 3. Pass nullptr as the first parameter to OH_Drawing_FilterGetColorFilter and check the error code using 266 // OH_Drawing_ErrorCodeGet, No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 267 OH_Drawing_FilterGetColorFilter(nullptr, colorFilter); 268 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 269 270 // 4. Pass nullptr as the second parameter to OH_Drawing_FilterGetColorFilter and check the error code using 271 // OH_Drawing_ErrorCodeGet, No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 272 OH_Drawing_FilterGetColorFilter(filter, nullptr); 273 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 274 275 // 5. Free memory 276 OH_Drawing_FilterDestroy(filter); 277 OH_Drawing_ColorFilterDestroy(outerFilter); 278 OH_Drawing_ColorFilterDestroy(innerFilter); 279 OH_Drawing_ColorFilterDestroy(colorFilter); 280 } 281 282 /* 283 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FILTER_0402 284 * @tc.name: testFilterSetColorFilterMultipleCalls 285 * @tc.desc: Test for setting a color filter multiple times with different objects. 286 * @tc.size : SmallTest 287 * @tc.type : Function 288 * @tc.level : Level 3 289 */ 290 HWTEST_F(DrawingNativeFilterTest, testFilterSetColorFilterMultipleCalls, TestSize.Level3) { 291 // 1. Call OH_Drawing_FilterSetColorFilter 10 times with different OH_Drawing_Filter and OH_Drawing_ColorFilter 292 // objects. Call successful, errorcode returns OH_DRAWING_SUCCESS 293 for (int i = 0; i < 10; i++) { 294 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 295 OH_Drawing_ColorFilter *outerFilter = OH_Drawing_ColorFilterCreateLuma(); 296 OH_Drawing_ColorFilter *innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear(); 297 OH_Drawing_ColorFilter *colorFilter = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter); 298 OH_Drawing_FilterSetColorFilter(filter, colorFilter); 299 OH_Drawing_FilterDestroy(filter); 300 OH_Drawing_ColorFilterDestroy(outerFilter); 301 OH_Drawing_ColorFilterDestroy(innerFilter); 302 OH_Drawing_ColorFilterDestroy(colorFilter); 303 } 304 } 305 306 } // namespace Drawing 307 } // namespace Rosen 308 } // namespace OHOS