1 /*
2 * Copyright (c) 2025 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 #include <gtest/gtest.h>
17
18 #include "draw/color.h"
19 #include "ge_pixel_map_shader_mask.h"
20 #include "image/bitmap.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
27 namespace Drawing {
28
29 class GEPixelMapShaderMaskTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp() override;
34 void TearDown() override;
35 };
36
SetUpTestCase(void)37 void GEPixelMapShaderMaskTest::SetUpTestCase(void) {}
38
TearDownTestCase(void)39 void GEPixelMapShaderMaskTest::TearDownTestCase(void) {}
40
SetUp()41 void GEPixelMapShaderMaskTest::SetUp() {}
42
TearDown()43 void GEPixelMapShaderMaskTest::TearDown() {}
44
MakeImage()45 static std::shared_ptr<Drawing::Image> MakeImage()
46 {
47 Drawing::Bitmap bmp;
48 Drawing::BitmapFormat format { Drawing::COLORTYPE_RGBA_8888, Drawing::ALPHATYPE_PREMUL };
49 bmp.Build(50, 50, format); // 50, 50 bitmap size
50 bmp.ClearWithColor(Drawing::Color::COLOR_BLUE);
51 return bmp.MakeImage();
52 }
53
54 /**
55 * @tc.name: Constructor_001
56 * @tc.desc: Verify the constructor function
57 * @tc.type: FUNC
58 */
59 HWTEST_F(GEPixelMapShaderMaskTest, Constructor_001, TestSize.Level1)
60 {
61 GTEST_LOG_(INFO) << "GEVisualEffectTest Constructor_001 start";
62
63 GEPixelMapMaskParams param{
64 .image=MakeImage(),
65 .src=RectF(-0.5, -1.0, -0.1, -0.2),
66 .dst=RectF(1.3, 1.2, 1.6, 2.0),
67 .fillColor=Vector4f(0.2, 0.8, 0.1, 0.9),
68 };
69 auto gePixelMapShaderMask = std::make_shared<GEPixelMapShaderMask>(param);
70 EXPECT_EQ(gePixelMapShaderMask->param_.image, param.image);
71 EXPECT_EQ(gePixelMapShaderMask->param_.src, param.src);
72 EXPECT_EQ(gePixelMapShaderMask->param_.dst, param.dst);
73 EXPECT_EQ(gePixelMapShaderMask->param_.fillColor, param.fillColor);
74 GTEST_LOG_(INFO) << "GEVisualEffectTest Constructor_001 end";
75 }
76
77 /**
78 * @tc.name: GenerateBuilder_001
79 * @tc.desc: Verify the Get Builder function
80 * @tc.type: FUNC
81 */
82 HWTEST_F(GEPixelMapShaderMaskTest, GenerateBuilder_001, TestSize.Level1)
83 {
84 GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateBuilder_001 start";
85
86 GEPixelMapMaskParams param;
87 auto gePixelMapShaderMask = std::make_shared<GEPixelMapShaderMask>(param);
88 auto builder = gePixelMapShaderMask->GetPixelMapShaderMaskBuilder();
89 EXPECT_NE(builder, nullptr);
90 builder = gePixelMapShaderMask->GetPixelMapShaderNormalMaskBuilder();
91 EXPECT_NE(builder, nullptr);
92
93 GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateBuilder_001 end";
94 }
95
96 /**
97 * @tc.name: GenerateDrawingShader_001
98 * @tc.desc: Verify the GenerateDrawingShader function
99 * @tc.type: FUNC
100 */
101 HWTEST_F(GEPixelMapShaderMaskTest, GenerateDrawingShader_001, TestSize.Level1)
102 {
103 GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShader_001 start";
104
105 GEPixelMapMaskParams param;
106 auto gePixelMapShaderMask = std::make_shared<GEPixelMapShaderMask>(param);
107 auto shaderEffect = gePixelMapShaderMask->GenerateDrawingShader(50.f, 50.f);
108 EXPECT_EQ(shaderEffect, nullptr);
109 shaderEffect = gePixelMapShaderMask->GenerateDrawingShaderHasNormal(50.f, 50.f);
110 EXPECT_EQ(shaderEffect, nullptr);
111
112 GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShader_001 end";
113 }
114
115 /**
116 * @tc.name: GenerateDrawingShader_002
117 * @tc.desc: Verify the GenerateDrawingShader function
118 * @tc.type: FUNC
119 */
120 HWTEST_F(GEPixelMapShaderMaskTest, GenerateDrawingShader_002, TestSize.Level1)
121 {
122 GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShader_002 start";
123
124 GEPixelMapMaskParams param {
125 .image=MakeImage(),
126 .src=RectF(0.1, 0.2, 0.8, 0.7),
127 .dst=RectF(0.3, 0.1, 0.6, 0.5),
128 .fillColor=Vector4f(0.2, 0.8, 0.1, 0.9),
129 };
130 ASSERT_NE(param.image, nullptr);
131 auto gePixelMapShaderMask = std::make_shared<GEPixelMapShaderMask>(param);
132 auto shaderEffect = gePixelMapShaderMask->GenerateDrawingShader(50.f, 50.f);
133 EXPECT_NE(shaderEffect, nullptr);
134 shaderEffect = gePixelMapShaderMask->GenerateDrawingShaderHasNormal(50.f, 50.f);
135 EXPECT_NE(shaderEffect, nullptr);
136
137 GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShader_002 end";
138 }
139 } // namespace Drawing
140 } // namespace Rosen
141 } // namespace OHOS
142