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 #ifndef STABILITY_BITMAP_TEST_H 17 #define STABILITY_BITMAP_TEST_H 18 #include <map> 19 #include <native_drawing/drawing_canvas.h> 20 #include <native_drawing/drawing_path.h> 21 #include <native_drawing/drawing_rect.h> 22 23 #include "test_base.h" 24 #include "test_common.h" 25 26 typedef enum { 27 // Operation function 28 OPERATION_FUNCTION_BITMAP_GET_WIDTH = 0, 29 OPERATION_FUNCTION_BITMAP_GET_HEIGHT, 30 OPERATION_FUNCTION_BITMAP_GET_COLOR_FORMAT, 31 OPERATION_FUNCTION_BITMAP_GET_ALPHA_FORMAT, 32 OPERATION_FUNCTION_BITMAP_GET_PIXELS, 33 OPERATION_FUNCTION_BITMAP_GET_IMAGE_INFO, 34 OPERATION_FUNCTION_BITMAP_READ_PIXELS, 35 OPERATION_FUNCTION_BITMAP_MAX, 36 } OperationFunctionBitmap; 37 38 typedef enum { 39 // Operation function 40 OPERATION_FUNCTION_IMAGE_GET_WIDTH = 0, 41 OPERATION_FUNCTION_IMAGE_GET_HEIGHT, 42 OPERATION_FUNCTION_IMAGE_GET_IMAGE_INFO, 43 OPERATION_FUNCTION_IMAGE_MAX, 44 } OperationFunctionImage; 45 46 // BitmapCreate-BitmapBuild-相关配置接口全调用-BitmapDestroy循环调用 47 // 无配置接口 48 class StabilityBitmapCreate : public TestBase { 49 public: StabilityBitmapCreate()50 StabilityBitmapCreate() 51 { 52 bitmapWidth_ = 640; // 640宽度 53 bitmapHeight_ = 480; // 480高度 54 fileName_ = "StabilityBitmapCreate"; 55 } ~StabilityBitmapCreate()56 ~StabilityBitmapCreate() override {}; 57 58 protected: 59 void OnTestStability(OH_Drawing_Canvas* canvas) override; 60 }; 61 62 // BitmapCreateFromPixels-相关配置接口全调用-BitmapDestroy循环 63 // 无配置接口 64 class StabilityBitmapCreateFromPixels : public TestBase { 65 public: StabilityBitmapCreateFromPixels()66 StabilityBitmapCreateFromPixels() 67 { 68 bitmapWidth_ = 640; // 640宽度 69 bitmapHeight_ = 480; // 480高度 70 fileName_ = "StabilityBitmapCreateFromPixels"; 71 } ~StabilityBitmapCreateFromPixels()72 ~StabilityBitmapCreateFromPixels() override {}; 73 74 protected: 75 void OnTestStability(OH_Drawing_Canvas* canvas) override; 76 }; 77 78 // BitmapBuild多次循环调用 79 class StabilityBitmapInit : public TestBase { 80 public: StabilityBitmapInit()81 StabilityBitmapInit() 82 { 83 bitmapWidth_ = 640; // 640宽度 84 bitmapHeight_ = 480; // 480高度 85 fileName_ = "StabilityBitmapInit"; 86 } ~StabilityBitmapInit()87 ~StabilityBitmapInit() override {}; 88 89 protected: 90 void OnTestStability(OH_Drawing_Canvas* canvas) override; 91 }; 92 93 // Bitmap相关操作随机循环调用 94 class StabilityBitmapRandInvoke : public TestBase { 95 public: StabilityBitmapRandInvoke()96 StabilityBitmapRandInvoke() 97 { 98 bitmapWidth_ = 640; // 640宽度 99 bitmapHeight_ = 480; // 480高度 100 fileName_ = "StabilityBitmapRandInvoke"; 101 } ~StabilityBitmapRandInvoke()102 ~StabilityBitmapRandInvoke() override {}; 103 104 protected: 105 void OnTestStability(OH_Drawing_Canvas* canvas) override; 106 107 private: 108 void BitmapGetWidthTest(OH_Drawing_Bitmap* bitmap); 109 void BitmapGetHeightTest(OH_Drawing_Bitmap* bitmap); 110 void BitmapGetColorFormatTest(OH_Drawing_Bitmap* bitmap); 111 void BitmapGetAlphaFormatTest(OH_Drawing_Bitmap* bitmap); 112 void BitmapGetPixelsTest(OH_Drawing_Bitmap* bitmap); 113 void BitmapGetImageInfoTest(OH_Drawing_Bitmap* bitmap); 114 void BitmapReadPixelsTest(OH_Drawing_Bitmap* bitmap); 115 using HandlerFunc = std::function<void(OH_Drawing_Bitmap*)>; 116 std::map<uint32_t, HandlerFunc> handlers_ = { 117 { OPERATION_FUNCTION_BITMAP_GET_WIDTH, 118 [this](OH_Drawing_Bitmap* bitmap) { return BitmapGetWidthTest(bitmap); } }, 119 { OPERATION_FUNCTION_BITMAP_GET_HEIGHT, 120 [this](OH_Drawing_Bitmap* bitmap) { return BitmapGetHeightTest(bitmap); } }, 121 { OPERATION_FUNCTION_BITMAP_GET_COLOR_FORMAT, 122 [this](OH_Drawing_Bitmap* bitmap) { return BitmapGetColorFormatTest(bitmap); } }, 123 { OPERATION_FUNCTION_BITMAP_GET_ALPHA_FORMAT, 124 [this](OH_Drawing_Bitmap* bitmap) { return BitmapGetAlphaFormatTest(bitmap); } }, 125 { OPERATION_FUNCTION_BITMAP_GET_PIXELS, 126 [this](OH_Drawing_Bitmap* bitmap) { return BitmapGetPixelsTest(bitmap); } }, 127 { OPERATION_FUNCTION_BITMAP_GET_IMAGE_INFO, 128 [this](OH_Drawing_Bitmap* bitmap) { return BitmapGetImageInfoTest(bitmap); } }, 129 { OPERATION_FUNCTION_BITMAP_READ_PIXELS, 130 [this](OH_Drawing_Bitmap* bitmap) { return BitmapReadPixelsTest(bitmap); } } 131 }; 132 }; 133 134 // ImageCreate-ImageBuildFromBitmap-ImageDestroy循环 135 class StabilityImageCreate : public TestBase { 136 public: StabilityImageCreate()137 StabilityImageCreate() 138 { 139 bitmapWidth_ = 640; // 640宽度 140 bitmapHeight_ = 480; // 480高度 141 fileName_ = "StabilityImageCreate"; 142 } ~StabilityImageCreate()143 ~StabilityImageCreate() override {}; 144 145 protected: 146 void OnTestStability(OH_Drawing_Canvas* canvas) override; 147 }; 148 149 // ImageCreate-相关配置接口全调用-ImageDestroy循环 150 // 无配置接口 151 class StabilityImageInvoke : public TestBase { 152 public: StabilityImageInvoke()153 StabilityImageInvoke() 154 { 155 bitmapWidth_ = 640; // 640宽度 156 bitmapHeight_ = 480; // 480高度 157 fileName_ = "StabilityImageInvoke"; 158 } ~StabilityImageInvoke()159 ~StabilityImageInvoke() override {}; 160 161 protected: 162 void OnTestStability(OH_Drawing_Canvas* canvas) override; 163 }; 164 165 // Image相关操作接口随机循环调用 166 class StabilityImageRandInvoke : public TestBase { 167 public: StabilityImageRandInvoke()168 StabilityImageRandInvoke() 169 { 170 bitmapWidth_ = 640; // 640宽度 171 bitmapHeight_ = 480; // 480高度 172 fileName_ = "StabilityImageRandInvoke"; 173 } ~StabilityImageRandInvoke()174 ~StabilityImageRandInvoke() override {}; 175 176 protected: 177 void OnTestStability(OH_Drawing_Canvas* canvas) override; 178 179 private: 180 void ImageGetWidthTest(OH_Drawing_Image* image); 181 void ImageGetHeightTest(OH_Drawing_Image* image); 182 void ImageGetImageInfoTest(OH_Drawing_Image* image); 183 using HandlerFunc = std::function<void(OH_Drawing_Image*)>; 184 std::map<uint32_t, HandlerFunc> handlers_ = { 185 { OPERATION_FUNCTION_IMAGE_GET_WIDTH, [this](OH_Drawing_Image* image) { return ImageGetWidthTest(image); } }, 186 { OPERATION_FUNCTION_IMAGE_GET_HEIGHT, [this](OH_Drawing_Image* image) { return ImageGetHeightTest(image); } }, 187 { OPERATION_FUNCTION_IMAGE_GET_IMAGE_INFO, 188 [this](OH_Drawing_Image* image) { return ImageGetImageInfoTest(image); } }, 189 }; 190 }; 191 192 #endif // STABILITY_BITMAP_TEST_H