1/*
2 * Copyright (c) 2022-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, Hardware
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 "drawing_bitmap.h"
19#include "drawing_brush.h"
20#include "drawing_canvas.h"
21#include "drawing_color.h"
22#include "drawing_color_filter.h"
23#include "drawing_filter.h"
24#include "drawing_font.h"
25#include "drawing_image.h"
26#include "drawing_mask_filter.h"
27#include "drawing_matrix.h"
28#include "drawing_path.h"
29#include "drawing_pen.h"
30#include "drawing_point.h"
31#include "drawing_rect.h"
32#include "drawing_region.h"
33#include "drawing_round_rect.h"
34#include "drawing_sampling_options.h"
35#include "drawing_shader_effect.h"
36#include "drawing_text_blob.h"
37#include "drawing_typeface.h"
38#include "drawing_memory_stream.h"
39#include "effect/color_filter.h"
40#include "effect/filter.h"
41
42using namespace testing;
43using namespace testing::ext;
44
45namespace OHOS {
46namespace Rosen {
47namespace Drawing {
48class NativeDrawingCanvasLargeValueTest : public testing::Test {
49public:
50    static void SetUpTestCase();
51    static void TearDownTestCase();
52    void SetUp() override;
53    void TearDown() override;
54    protected:
55        OH_Drawing_Canvas *canvas_ = nullptr;
56        OH_Drawing_Brush *brush_ = nullptr;
57};
58
59void NativeDrawingCanvasLargeValueTest::SetUpTestCase() {}
60void NativeDrawingCanvasLargeValueTest::TearDownTestCase() {}
61void NativeDrawingCanvasLargeValueTest::SetUp()
62{
63    canvas_ = OH_Drawing_CanvasCreate();
64    ASSERT_NE(nullptr, canvas_);
65    OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF));
66    brush_ = OH_Drawing_BrushCreate();
67    EXPECT_NE(brush_, nullptr);
68    OH_Drawing_BrushSetColor(brush_, 0xffff0000);
69    OH_Drawing_CanvasAttachBrush(canvas_, brush_);
70}
71
72void NativeDrawingCanvasLargeValueTest::TearDown()
73{
74    if (canvas_ != nullptr) {
75        OH_Drawing_CanvasDetachBrush(canvas_);
76        OH_Drawing_BrushDestroy(brush_);
77        brush_ = nullptr;
78        OH_Drawing_CanvasDestroy(canvas_);
79        canvas_ = nullptr;
80    }
81}
82
83/*
84 * @tc.name: NativeDrawingCanvasLargeValueTest_DrawPath005
85 * @tc.desc: test for OH_Drawing_CanvasDrawPath.
86 * @tc.size  : MediumTest
87 * @tc.type  : Function
88 * @tc.level : Level 1
89 */
90HWTEST_F(NativeDrawingCanvasLargeValueTest, NativeDrawingCanvasLargeValueTest_DrawPath005, TestSize.Level1)
91{
92    OH_Drawing_Path* path = OH_Drawing_PathCreate();
93    EXPECT_NE(path, nullptr);
94    constexpr int height = 4096;
95    constexpr int width = 2160;
96    constexpr float arc = 18.0f;
97    int len = height / 4;
98    float aX = width / 2;
99    float aY = height / 4;
100    float dX = aX - len * std::sin(arc);
101    float dY = aY + len * std::cos(arc);
102    float cX = aX + len * std::sin(arc);
103    float cY = dY;
104    float bX = aX + (len / 2.0);
105    float bY = aY + std::sqrt((cX - dX) * (cX - dX) + (len / 2.0) * (len / 2.0));
106    float eX = aX - (len / 2.0);
107    float eY = bY;
108    OH_Drawing_PathMoveTo(path, aX, aY);
109    OH_Drawing_PathLineTo(path, bX, bY);
110    OH_Drawing_PathLineTo(path, cX, cY);
111    OH_Drawing_PathLineTo(path, dX, dY);
112    OH_Drawing_PathLineTo(path, eX, eY);
113    OH_Drawing_PathClose(path);
114    OH_Drawing_CanvasDrawPath(canvas_, path);
115    OH_Drawing_PathDestroy(path);
116}
117
118/*
119 * @tc.name: NativeDrawingCanvasLargeValueTest_DrawBitmap021
120 * @tc.desc: test for DrawBitmap
121 * @tc.size  : MediumTest
122 * @tc.type  : Function
123 * @tc.level : Level 1
124 */
125HWTEST_F(NativeDrawingCanvasLargeValueTest, NativeDrawingCanvasLargeValueTest_DrawBitmap021, TestSize.Level1)
126{
127    OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
128    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
129    constexpr uint32_t width = 2160;
130    constexpr uint32_t height = 4096;
131    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
132    OH_Drawing_CanvasBind(canvas_, bitmap);
133    OH_Drawing_CanvasDrawBitmap(canvas_, bitmap, 0, 0);
134    OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF));
135    OH_Drawing_BitmapDestroy(bitmap);
136}
137/*
138 * @tc.name: NativeDrawingCanvasLargeValueTest_DrawBitmapRect022
139 * @tc.desc: test for DrawBitmapRect
140 * @tc.size  : MediumTest
141 * @tc.type  : Function
142 * @tc.level : Level 1
143 */
144HWTEST_F(NativeDrawingCanvasLargeValueTest, NativeDrawingCanvasLargeValueTest_DrawBitmapRect022, TestSize.Level1)
145{
146    OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
147    EXPECT_NE(bitmap, nullptr);
148    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
149    constexpr uint32_t width = 2160;
150    constexpr uint32_t height = 4096;
151    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
152    OH_Drawing_Rect* src = OH_Drawing_RectCreate(0, 0, 200, 200);
153    EXPECT_NE(src, nullptr);
154    OH_Drawing_Rect* dst = OH_Drawing_RectCreate(0, 0, 200, 200);
155    EXPECT_NE(dst, nullptr);
156    OH_Drawing_SamplingOptions* options = OH_Drawing_SamplingOptionsCreate(
157        OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
158    EXPECT_NE(options, nullptr);
159    OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, dst, options);
160    OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, dst, nullptr);
161    OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, nullptr, nullptr);
162    OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, nullptr, nullptr, nullptr);
163    OH_Drawing_CanvasDrawBitmapRect(canvas_, nullptr, nullptr, nullptr, nullptr);
164    OH_Drawing_CanvasDrawBitmapRect(nullptr, nullptr, nullptr, nullptr, nullptr);
165    OH_Drawing_BitmapDestroy(bitmap);
166}
167
168/*
169 * @tc.name: NativeDrawingCanvasLargeValueTest_DrawImageRect025
170 * @tc.desc: test for DrawImageRect
171 * @tc.size  : MediumTest
172 * @tc.type  : Function
173 * @tc.level : Level 1
174 */
175HWTEST_F(NativeDrawingCanvasLargeValueTest, NativeDrawingCanvasLargeValueTest_DrawImageRect025, TestSize.Level1)
176{
177    OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 200, 200);
178    EXPECT_NE(rect, nullptr);
179    OH_Drawing_Image* image = OH_Drawing_ImageCreate();
180    EXPECT_NE(image, nullptr);
181    OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
182    EXPECT_NE(bitmap, nullptr);
183    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
184    constexpr uint32_t width = 2160;
185    constexpr uint32_t height = 4096;
186    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
187    OH_Drawing_ImageBuildFromBitmap(image, bitmap);
188    OH_Drawing_SamplingOptions* options = OH_Drawing_SamplingOptionsCreate(
189        OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
190    EXPECT_NE(options, nullptr);
191    OH_Drawing_CanvasDrawImageRect(canvas_, image, rect, options);
192    OH_Drawing_CanvasDrawImageRect(canvas_, image, rect, nullptr);
193    OH_Drawing_CanvasDrawImageRect(canvas_, image, nullptr, nullptr);
194    OH_Drawing_CanvasDrawImageRect(canvas_, nullptr, nullptr, nullptr);
195    OH_Drawing_CanvasDrawImageRect(nullptr, nullptr, nullptr, nullptr);
196    OH_Drawing_CanvasDrawImageRectWithSrc(canvas_, image, rect, rect, options, STRICT_SRC_RECT_CONSTRAINT);
197    OH_Drawing_CanvasDrawImageRectWithSrc(nullptr, nullptr, nullptr, nullptr, nullptr, STRICT_SRC_RECT_CONSTRAINT);
198    OH_Drawing_SamplingOptionsDestroy(options);
199    OH_Drawing_BitmapDestroy(bitmap);
200    OH_Drawing_ImageDestroy(image);
201}
202
203/*
204 * @tc.name: NativeDrawingCanvasLargeValueTest_ReadPixels027
205 * @tc.desc: test for ReadPixels
206 * @tc.size  : MediumTest
207 * @tc.type  : Function
208 * @tc.level : Level 1
209 */
210HWTEST_F(NativeDrawingCanvasLargeValueTest, NativeDrawingCanvasLargeValueTest_ReadPixels027, TestSize.Level1)
211{
212    OH_Drawing_Image_Info imageInfo;
213    OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
214    EXPECT_NE(bitmap, nullptr);
215    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
216    constexpr uint32_t width = 2160;
217    constexpr uint32_t height = 4096;
218    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
219    void* pixels = OH_Drawing_BitmapGetPixels(bitmap);
220    EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, &imageInfo, pixels, 0, 0, 0));
221    EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, &imageInfo, nullptr, 0, 0, 0));
222    EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, nullptr, nullptr, 0, 0, 0));
223    EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(nullptr, nullptr, nullptr, 0, 0, 0));
224    OH_Drawing_BitmapDestroy(bitmap);
225}
226
227/*
228 * @tc.name: NativeDrawingCanvasLargeValueTest_IsClipEmpty042
229 * @tc.desc: test for if clip is empty
230 * @tc.type: FUNC
231 * @tc.require: AR000GTO5R
232 */
233HWTEST_F(NativeDrawingCanvasLargeValueTest, NativeDrawingCanvasLargeValueTest_IsClipEmpty042, TestSize.Level1)
234{
235    OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
236    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
237    // 2160: bitmap's width, 2160: bitmap's height
238    constexpr uint32_t width = 2160;
239    constexpr uint32_t height = 4096;
240    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
241    OH_Drawing_CanvasBind(canvas_, bitmap);
242
243    // 150.0f: rect's left, 100.0f: rect's top, 500.0f: rect's right, 500.0f: rect's bottom
244    OH_Drawing_Rect* rect = OH_Drawing_RectCreate(150.0f, 100.0f, 500.f, 500.f);
245
246    OH_Drawing_CanvasClipRect(canvas_, rect, OH_Drawing_CanvasClipOp::INTERSECT, false);
247
248    bool isClipEmpty = false;
249    EXPECT_EQ(OH_Drawing_CanvasIsClipEmpty(canvas_, &isClipEmpty), OH_DRAWING_SUCCESS);
250    EXPECT_EQ(isClipEmpty, false);
251
252    OH_Drawing_RectDestroy(rect);
253    OH_Drawing_BitmapDestroy(bitmap);
254}
255
256/*
257 * @tc.name: NativeDrawingCanvasLargeValueTest_GetImageInfo043
258 * @tc.desc: test for Gets ImageInfo of Canvas.
259 * @tc.type: FUNC
260 * @tc.require: AR000GTO5R
261 */
262HWTEST_F(NativeDrawingCanvasLargeValueTest, NativeDrawingCanvasLargeValueTest_GetImageInfo043, TestSize.Level1)
263{
264    OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
265    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
266    // 2160: bitmap's width, 2160: bitmap's height
267    constexpr uint32_t width = 2160;
268    constexpr uint32_t height = 4096;
269    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
270    OH_Drawing_CanvasBind(canvas_, bitmap);
271    OH_Drawing_Image_Info* imageInfo = new OH_Drawing_Image_Info();
272    EXPECT_EQ(OH_Drawing_CanvasGetImageInfo(canvas_, imageInfo), OH_DRAWING_SUCCESS);
273    EXPECT_EQ(2160, imageInfo->width);
274    EXPECT_EQ(4096, imageInfo->height);
275    EXPECT_EQ(1, imageInfo->alphaType);
276    EXPECT_EQ(4, imageInfo->colorType);
277    delete imageInfo;
278}
279
280
281/*
282 * @tc.name: NativeDrawingCanvasLargeValueTest_ClipRegion044
283 * @tc.desc: test for Drawing Canvas Clip Region.
284 * @tc.type: FUNC
285 * @tc.require: AR000GTO5R
286 */
287HWTEST_F(NativeDrawingCanvasLargeValueTest, NativeDrawingCanvasLargeValueTest_ClipRegion044, TestSize.Level1)
288{
289    OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
290    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
291    constexpr uint32_t width = 2160; // 2160: width of canvas
292    constexpr uint32_t height = 4096; // 4096: height of canvas
293    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
294    OH_Drawing_CanvasBind(canvas_, bitmap);
295
296    OH_Drawing_Region *region = OH_Drawing_RegionCreate();
297    // 0.0f: rect's left, 0.0f: rect's top, 4096.0f: rect's right, 2160.0f: rect's bottom
298    OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 2160.f, 4096.f);
299    OH_Drawing_RegionSetRect(region, rect);
300    EXPECT_EQ(OH_Drawing_CanvasClipRegion(canvas_, region, OH_Drawing_CanvasClipOp::INTERSECT), OH_DRAWING_SUCCESS);
301    EXPECT_EQ(OH_Drawing_CanvasClipRegion(nullptr, region, OH_Drawing_CanvasClipOp::INTERSECT),
302        OH_DRAWING_ERROR_INVALID_PARAMETER);
303
304    EXPECT_EQ(2160, OH_Drawing_CanvasGetWidth(canvas_));
305    EXPECT_EQ(4096, OH_Drawing_CanvasGetHeight(canvas_));
306
307    OH_Drawing_RegionDestroy(region);
308    OH_Drawing_RectDestroy(rect);
309    OH_Drawing_BitmapDestroy(bitmap);
310}
311} // namespace Drawing
312} // namespace Rosen
313} // namespace OHOS