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_color.h" 18 #include "drawing_color_filter.h" 19 #include "drawing_error_code.h" 20 #include "drawing_image.h" 21 #include "drawing_image_filter.h" 22 #include "gtest/gtest.h" 23 #include <iostream> 24 #include <random> 25 26 using namespace testing; 27 using namespace testing::ext; 28 29 namespace OHOS { 30 namespace Rosen { 31 namespace Drawing { 32 class DrawingNativeImageFilterTest : public testing::Test { 33 protected: 34 // 在每个测试用例执行前调用 SetUp()35 void SetUp() override 36 { 37 // 设置代码 38 std::cout << "DrawingNativeImageFilterTest Setup code called before each test case." << std::endl; 39 OH_Drawing_ErrorCodeReset(); 40 std::cout << "DrawingNativeImageFilterTest errorCodeReset before each test case." << std::endl; 41 } TearDown()42 void TearDown() override 43 { 44 std::cout << "DrawingNativeImageFilterTest Setup code called after each test case." << std::endl; 45 OH_Drawing_ErrorCodeReset(); 46 std::cout << "DrawingNativeImageFilterTest errorCodeReset after each test case." << std::endl; 47 } 48 }; 49 50 /* 51 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0100 52 * @tc.name: testImageFilterCreateBlurNormal 53 * @tc.desc: Test for creating a blur image filter with normal parameters. 54 * @tc.size : SmallTest 55 * @tc.type : Function 56 * @tc.level : Level 0 57 */ 58 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurNormal, TestSize.Level0) { 59 // 1. Enumerate OH_Drawing_TileMode values in OH_Drawing_ImageFilterCreateBlur 60 OH_Drawing_TileMode modes[] = {CLAMP, REPEAT, MIRROR, DECAL}; 61 for (OH_Drawing_TileMode mode : modes) { 62 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1.0f, 1.0f, mode, nullptr); 63 EXPECT_NE(filter, nullptr); 64 OH_Drawing_ImageFilterDestroy(filter); 65 } 66 // 2. Pass decimal values for sigmaX and sigmaY in OH_Drawing_ImageFilterCreateBlur 67 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1.0f, 1.0f, OH_Drawing_TileMode::MIRROR, nullptr); 68 // add assert 69 EXPECT_NE(filter, nullptr); 70 // 3. Pass integer values for sigmaX and sigmaY in OH_Drawing_ImageFilterCreateBlur 71 filter = OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 72 // add assert 73 EXPECT_NE(filter, nullptr); 74 // 4. Pass NULL for input parameter in OH_Drawing_ImageFilterCreateBlur 75 filter = OH_Drawing_ImageFilterCreateBlur(1.0f, 1.0f, OH_Drawing_TileMode::MIRROR, nullptr); 76 // add assert 77 EXPECT_NE(filter, nullptr); 78 // 5. Pass non-NULL for input parameter in OH_Drawing_ImageFilterCreateBlur 79 filter = OH_Drawing_ImageFilterCreateBlur(1.0f, 1.0f, OH_Drawing_TileMode::MIRROR, filter); 80 // add assert 81 EXPECT_NE(filter, nullptr); 82 // 6. Destroy the filter object 83 OH_Drawing_ImageFilterDestroy(filter); 84 } 85 86 /* 87 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0101 88 * @tc.name: testImageFilterCreateBlurNULL 89 * @tc.desc: Test for creating a blur image filter with NULL parameters. 90 * @tc.size : SmallTest 91 * @tc.type : Function 92 * @tc.level : Level 3 93 */ 94 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurNULL, TestSize.Level3) { 95 // 1. OH_Drawing_ImageFilterCreateBlur with the first parameter being null 96 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(0, 1.0f, OH_Drawing_TileMode::MIRROR, nullptr); 97 // add assert 98 EXPECT_NE(filter, nullptr); 99 // 2. OH_Drawing_ImageFilterCreateBlur with the second parameter being null 100 filter = OH_Drawing_ImageFilterCreateBlur(1.0f, 0, OH_Drawing_TileMode::MIRROR, nullptr); 101 // add assert 102 EXPECT_NE(filter, nullptr); 103 // 3. Destroy the filter object 104 OH_Drawing_ImageFilterDestroy(filter); 105 } 106 107 /* 108 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0102 109 * @tc.name: testImageFilterCreateBlurMultipleCalls 110 * @tc.desc: Test for multiple calls of creating a blur image filter. 111 * @tc.size : SmallTest 112 * @tc.type : Function 113 * @tc.level : Level 3 114 */ 115 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurMultipleCalls, TestSize.Level3) { 116 // 1. OH_Drawing_ImageFilterCreateBlur (pass random values for sigmaX and sigmaY, random enum value for 117 // OH_Drawing_TileMode), call 10 times 118 for (int i = 0; i < 10; i++) { 119 std::random_device rd; 120 std::mt19937 gen(rd()); 121 std::uniform_real_distribution<float> dis(0, 10); 122 std::uniform_int_distribution<int> enum_dis(0, 3); 123 OH_Drawing_TileMode tileMode = static_cast<OH_Drawing_TileMode>(enum_dis(gen)); 124 OH_Drawing_ImageFilter *filter = 125 OH_Drawing_ImageFilterCreateBlur(dis(gen), dis(gen), tileMode, nullptr); 126 EXPECT_NE(filter, nullptr); 127 OH_Drawing_ImageFilterDestroy(filter); 128 } 129 } 130 131 /* 132 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0103 133 * @tc.name: testImageFilterCreateBlurAbnormal 134 * @tc.desc: Test for creating a blur image filter with abnormal parameters. 135 * @tc.size : SmallTest 136 * @tc.type : Function 137 * @tc.level : Level 3 138 */ 139 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurAbnormal, TestSize.Level3) { 140 // 1. Pass negative values for sigmaX and sigmaY in OH_Drawing_ImageFilterCreateBlur 141 OH_Drawing_ImageFilter *filter = 142 OH_Drawing_ImageFilterCreateBlur(-1.0f, -1.0f, OH_Drawing_TileMode::MIRROR, nullptr); 143 // add assert 144 EXPECT_NE(filter, nullptr); 145 // 2. Destroy the filter object 146 OH_Drawing_ImageFilterDestroy(filter); 147 } 148 149 /* 150 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0104 151 * @tc.name: testImageFilterCreateBlurMaximum 152 * @tc.desc: Test for creating a blur image filter with maximum values. 153 * @tc.size : SmallTest 154 * @tc.type : Function 155 * @tc.level : Level 3 156 */ 157 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurMaximum, TestSize.Level3) { 158 // 1. Create a blur image filter with maximum values for sigmaX and sigmaY in OH_Drawing_ImageFilterCreateBlur 159 OH_Drawing_ImageFilter *filter = 160 OH_Drawing_ImageFilterCreateBlur(FLT_MAX, FLT_MAX, OH_Drawing_TileMode::MIRROR, nullptr); 161 // add assert 162 EXPECT_NE(filter, nullptr); 163 // 2. Destroy the filter object 164 OH_Drawing_ImageFilterDestroy(filter); 165 } 166 167 /* 168 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0200 169 * @tc.name: testImageFilterCreateFromColorFilterNormal 170 * @tc.desc: Test for creating an image filter from a color filter with normal parameters. 171 * @tc.size : SmallTest 172 * @tc.type : Function 173 * @tc.level : Level 0 174 */ 175 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateFromColorFilterNormal, TestSize.Level0) { 176 // 1. OH_Drawing_ImageFilterCreateBlur 177 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 178 // add assert 179 EXPECT_NE(filter, nullptr); 180 // 2. OH_Drawing_ColorFilterCreateLinearToSrgbGamma 181 OH_Drawing_ColorFilter *colorFilter = OH_Drawing_ColorFilterCreateLinearToSrgbGamma(); 182 // add assert 183 EXPECT_NE(colorFilter, nullptr); 184 // 3. OH_Drawing_ImageFilterCreateFromColorFilter with null input parameter 185 OH_Drawing_ImageFilter *imageFilter = OH_Drawing_ImageFilterCreateFromColorFilter(colorFilter, nullptr); 186 // add assert 187 EXPECT_NE(imageFilter, nullptr); 188 // add assert 189 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 190 // 4. OH_Drawing_ImageFilterCreateFromColorFilter with non-null input parameter 191 imageFilter = OH_Drawing_ImageFilterCreateFromColorFilter(colorFilter, filter); 192 // add assert 193 EXPECT_NE(imageFilter, nullptr); 194 // add assert 195 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 196 // 5. Free memory 197 OH_Drawing_ImageFilterDestroy(imageFilter); 198 OH_Drawing_ColorFilterDestroy(colorFilter); 199 OH_Drawing_ImageFilterDestroy(filter); 200 } 201 202 /* 203 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0201 204 * @tc.name: testImageFilterCreateFromColorFilterNULL 205 * @tc.desc: Test for creating an image filter from a color filter with NULL parameters. 206 * @tc.size : SmallTest 207 * @tc.type : Function 208 * @tc.level : Level 3 209 */ 210 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateFromColorFilterNULL, TestSize.Level3) { 211 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 212 // add assert 213 EXPECT_NE(filter, nullptr); 214 // 1. OH_Drawing_ImageFilterCreateFromColorFilter with the first parameter being null, check the error code using 215 // OH_Drawing_ErrorCodeGet 216 OH_Drawing_ImageFilterCreateFromColorFilter(nullptr, filter); 217 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 218 // 2. Free memory 219 OH_Drawing_ImageFilterDestroy(filter); 220 } 221 222 /* 223 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0202 224 * @tc.name: testImageFilterCreateFromColorFilterMultipleCalls 225 * @tc.desc: Test for multiple calls of creating an image filter from a color filter. 226 * @tc.size : SmallTest 227 * @tc.type : Function 228 * @tc.level : Level 3 229 */ 230 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateFromColorFilterMultipleCalls, TestSize.Level3) { 231 for (int i = 0; i < 10; i++) { 232 OH_Drawing_ColorFilter *colorFilter = OH_Drawing_ColorFilterCreateLinearToSrgbGamma(); 233 // add assert 234 EXPECT_NE(colorFilter, nullptr); 235 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateFromColorFilter(colorFilter, nullptr); 236 EXPECT_NE(filter, nullptr); 237 // add assert 238 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 239 OH_Drawing_ImageFilterDestroy(filter); 240 OH_Drawing_ColorFilterDestroy(colorFilter); 241 } 242 } 243 244 /* 245 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0300 246 * @tc.name: testImageFilterDestroyNormal 247 * @tc.desc: Test for destroying an image filter with normal parameters. 248 * @tc.size : SmallTest 249 * @tc.type : Function 250 * @tc.level : Level 0 251 */ 252 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterDestroyNormal, TestSize.Level0) { 253 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 254 // add assert 255 EXPECT_NE(filter, nullptr); 256 OH_Drawing_ImageFilterDestroy(filter); 257 } 258 259 /* 260 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0301 261 * @tc.name: testImageFilterDestroyNULL 262 * @tc.desc: Test for destroying an image filter with NULL parameters. 263 * @tc.size : SmallTest 264 * @tc.type : Function 265 * @tc.level : Level 3 266 */ 267 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterDestroyNULL, TestSize.Level3) { 268 OH_Drawing_ImageFilterDestroy(nullptr); 269 // add assert 270 EXPECT_TRUE(true); 271 } 272 273 /* 274 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0302 275 * @tc.name: testImageFilterDestroyMultipleCalls 276 * @tc.desc: Test for multiple calls of destroying an image filter. 277 * @tc.size : SmallTest 278 * @tc.type : Function 279 * @tc.level : Level 3 280 */ 281 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterDestroyMultipleCalls, TestSize.Level3) { 282 // 1. Call OH_Drawing_ImageFilterCreateFromColorFilter 10 times 283 OH_Drawing_ColorFilter *colorFilters[10]; 284 OH_Drawing_ImageFilter *filters[10]; 285 for (int i = 0; i < 10; i++) { 286 colorFilters[i] = OH_Drawing_ColorFilterCreateLinearToSrgbGamma(); 287 // add assert 288 EXPECT_NE(colorFilters[i], nullptr); 289 filters[i] = OH_Drawing_ImageFilterCreateFromColorFilter(colorFilters[i], nullptr); 290 // add assert 291 EXPECT_NE(filters[i], nullptr); 292 } 293 // 2. Call OH_Drawing_ImageFilterDestroy 10 times 294 for (int i = 0; i < 10; i++) { 295 OH_Drawing_ImageFilterDestroy(filters[i]); 296 OH_Drawing_ColorFilterDestroy(colorFilters[i]); 297 } 298 // 3. Call OH_Drawing_ImageFilterCreateBlur and OH_Drawing_ImageFilterDestroy alternately 10 times 299 for (int i = 0; i < 10; i++) { 300 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 301 // add assert 302 EXPECT_NE(filter, nullptr); 303 OH_Drawing_ImageFilterDestroy(filter); 304 } 305 } 306 307 } // namespace Drawing 308 } // namespace Rosen 309 } // namespace OHOS