1 /*
2 * Copyright (c) 2023 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 <gmock/gmock.h>
17
18 #include "mock/mock_any_span.h"
19 #include "param_test_macros.h"
20 #include "texgine/typography_types.h"
21 #include "variant_span.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 namespace TextEngine {
29 struct Mockvars {
30 double tsWidth = 0;
31 double tsHeight = 0;
32 int calledTimesPaint = 0;
33 int calledTimesPaintShadow = 0;
34 TexgineCanvas *catchedPaintCanvas = nullptr;
35 double catchedPaintOffsetX = 0;
36 double catchedPaintOffsetY = 0;
37 TexgineCanvas *catchedPaintShadowCanvas = nullptr;
38 double catchedPaintShadowOffsetX = 0;
39 double catchedPaintShadowOffsetY = 0;
40 } g_variantMockvars;
41
InitMockvars(struct Mockvars && vars)42 void InitMockvars(struct Mockvars &&vars)
43 {
44 g_variantMockvars = std::move(vars);
45 }
46
GetWidth() const47 double TextSpan::GetWidth() const
48 {
49 return g_variantMockvars.tsWidth;
50 }
51
GetHeight() const52 double TextSpan::GetHeight() const
53 {
54 return g_variantMockvars.tsHeight;
55 }
56
Paint(TexgineCanvas & canvas,double offsetX,double offsetY,const TextStyle & xs,const RoundRectType & rType)57 void TextSpan::Paint(TexgineCanvas &canvas, double offsetX, double offsetY, const TextStyle &xs,
58 const RoundRectType &rType)
59 {
60 g_variantMockvars.calledTimesPaint++;
61 g_variantMockvars.catchedPaintCanvas = &canvas;
62 g_variantMockvars.catchedPaintOffsetX = offsetX;
63 g_variantMockvars.catchedPaintOffsetY = offsetY;
64 }
65
PaintShadow(TexgineCanvas & canvas,double offsetX,double offsetY,const std::vector<TextShadow> & shadows)66 void TextSpan::PaintShadow(TexgineCanvas &canvas, double offsetX, double offsetY,
67 const std::vector<TextShadow> &shadows)
68 {
69 g_variantMockvars.calledTimesPaintShadow++;
70 g_variantMockvars.catchedPaintShadowCanvas = &canvas;
71 g_variantMockvars.catchedPaintShadowOffsetX = offsetX;
72 g_variantMockvars.catchedPaintShadowOffsetY = offsetY;
73 }
74
75 class VariantSpanTest : public testing::Test {
76 public:
VariantSpanTest()77 VariantSpanTest()
78 {
79 struct AttackStruct {
80 std::shared_ptr<TextSpan> ts_ = nullptr;
81 std::shared_ptr<AnySpan> as_ = nullptr;
82 } *p = reinterpret_cast<struct AttackStruct *>(&span0);
83 p->as_ = as;
84 p->ts_ = ts;
85 }
86
87 std::shared_ptr<TextSpan> tsNullptr = nullptr;
88 std::shared_ptr<AnySpan> asNullptr = nullptr;
89 std::shared_ptr<TextSpan> ts = TextSpan::MakeFromText("");
90 std::shared_ptr<MockAnySpan> as = std::make_shared<MockAnySpan>();
91 VariantSpan span0;
92 VariantSpan span1 = nullptr;
93 VariantSpan span2 = tsNullptr;
94 VariantSpan span3 = asNullptr;
95 VariantSpan span4 = ts;
96 VariantSpan span5 = as;
97 };
98
99 /**
100 * @tc.name: TryToTextAndAnySpan
101 * @tc.desc: Verify the TryToTextAndAnySpan
102 * @tc.type:FUNC
103 */
104 HWTEST_F(VariantSpanTest, TryToTextAndAnySpan, TestSize.Level1)
105 {
106 ASSERT_EQ(span1.TryToTextSpan(), nullptr);
107 ASSERT_EQ(span2.TryToTextSpan(), nullptr);
108 ASSERT_EQ(span3.TryToTextSpan(), nullptr);
109 ASSERT_EQ(span4.TryToTextSpan(), ts);
110 ASSERT_EQ(span5.TryToTextSpan(), nullptr);
111
112 ASSERT_EQ(span1.TryToAnySpan(), nullptr);
113 ASSERT_EQ(span2.TryToAnySpan(), nullptr);
114 ASSERT_EQ(span3.TryToAnySpan(), nullptr);
115 ASSERT_EQ(span4.TryToAnySpan(), nullptr);
116 ASSERT_EQ(span5.TryToAnySpan(), as);
117 }
118
119 /**
120 * @tc.name: GetWidthAndHeight
121 * @tc.desc: Verify the GetWidthAndHeight
122 * @tc.type:FUNC
123 */
124 HWTEST_F(VariantSpanTest, GetWidthAndHeight, TestSize.Level1)
125 {
126 InitMockvars({.tsWidth = 8, .tsHeight = 4});
127 EXPECT_CALL(*as, GetWidth).Times(1).WillOnce(testing::Return(2));
128 EXPECT_CALL(*as, GetHeight).Times(1).WillOnce(testing::Return(1));
129
130 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, span0.GetWidth());
131 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span1.GetWidth());
132 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span2.GetWidth());
133 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span3.GetWidth());
134 ASSERT_EQ(span4.GetWidth(), 8);
135 ASSERT_EQ(span5.GetWidth(), 2);
136
137 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, span0.GetHeight());
138 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span1.GetHeight());
139 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span2.GetHeight());
140 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span3.GetHeight());
141 ASSERT_EQ(span4.GetHeight(), 4);
142 ASSERT_EQ(span5.GetHeight(), 1);
143 }
144
145 /**
146 * @tc.name: PaintAndPaintShadow
147 * @tc.desc: Verify the PaintAndPaintShadow
148 * @tc.type:FUNC
149 */
150 HWTEST_F(VariantSpanTest, PaintAndPaintShadow, TestSize.Level1)
151 {
152 TexgineCanvas canvas, canvas1, canvas2, canvas3, canvas4;
153 int paintX1 = 2048;
154 int paintX2 = 512;
155 int paintY1 = 4096;
156 int paintY2 = 1024;
157 InitMockvars({});
158 TexgineCanvas *pcanvas = nullptr;
159 double asX = 0;
160 double asY = 0;
__anon9093b54c0102(TexgineCanvas &canvas, double offsetX, double offsetY) 161 EXPECT_CALL(*as, Paint).Times(1).WillOnce([&](TexgineCanvas &canvas, double offsetX, double offsetY) {
162 pcanvas = &canvas;
163 asX = offsetX;
164 asY = offsetY;
165 });
166
167 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, span0.Paint(canvas, 0, 0));
168 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span1.Paint(canvas, 0, 0));
169 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span2.Paint(canvas, 0, 0));
170 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span3.Paint(canvas, 0, 0));
171 EXPECT_NO_THROW({
172 ASSERT_EQ(g_variantMockvars.calledTimesPaint, 0);
173 span4.Paint(canvas2, paintX1, paintY1);
174 ASSERT_EQ(g_variantMockvars.calledTimesPaint, 1);
175 ASSERT_EQ(g_variantMockvars.catchedPaintCanvas, &canvas2);
176 ASSERT_EQ(g_variantMockvars.catchedPaintOffsetX, paintX1);
177 ASSERT_EQ(g_variantMockvars.catchedPaintOffsetY, paintY1);
178 });
179 EXPECT_NO_THROW({
180 span5.Paint(canvas1, paintX2, paintY2);
181 ASSERT_EQ(pcanvas, &canvas1);
182 ASSERT_EQ(asX, paintX2);
183 ASSERT_EQ(asY, paintY2);
184 });
185
186 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, span0.PaintShadow(canvas, 0, 0));
187 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span1.PaintShadow(canvas, 0, 0));
188 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span2.PaintShadow(canvas, 0, 0));
189 ASSERT_EXCEPTION(ExceptionType::NULLPTR, span3.PaintShadow(canvas, 0, 0));
190 EXPECT_NO_THROW({
191 ASSERT_EQ(g_variantMockvars.calledTimesPaintShadow, 0);
192 span4.PaintShadow(canvas4, 32768, 65536);
193 ASSERT_EQ(g_variantMockvars.calledTimesPaintShadow, 1);
194 ASSERT_EQ(g_variantMockvars.catchedPaintShadowCanvas, &canvas4);
195 ASSERT_EQ(g_variantMockvars.catchedPaintShadowOffsetX, 32768);
196 ASSERT_EQ(g_variantMockvars.catchedPaintShadowOffsetY, 65536);
197 });
198 EXPECT_NO_THROW({span5.PaintShadow(canvas3, 8192, 16384);});
199 }
200
201 /**
202 * @tc.name: Operator
203 * @tc.desc: Verify the Operator
204 * @tc.type:FUNC
205 */
206 HWTEST_F(VariantSpanTest, Operator, TestSize.Level1)
207 {
208 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, (void)(bool)span0);
209 ASSERT_FALSE(span1);
210 ASSERT_FALSE(span2);
211 ASSERT_FALSE(span3);
212 ASSERT_TRUE(span4);
213 ASSERT_TRUE(span5);
214
215 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, (void)(span0 == nullptr));
216 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, (void)(span0 != nullptr));
217 ASSERT_EQ(span1, nullptr);
218 ASSERT_EQ(span2, nullptr);
219 ASSERT_EQ(span3, nullptr);
220 ASSERT_NE(span4, nullptr);
221 ASSERT_NE(span5, nullptr);
222
223 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, (void)(span0 == span1));
224 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, (void)(span0 != span1));
225 ASSERT_EQ(span1, span1);
226 ASSERT_EQ(span1, span2);
227 ASSERT_EQ(span1, span3);
228 ASSERT_NE(span1, span4);
229 ASSERT_NE(span1, span5);
230
231 ASSERT_NE(span4, span5);
232
233 auto span6 = span4;
234 ASSERT_EQ(span6, span4);
235
236 auto span7 = span5;
237 ASSERT_EQ(span7, span5);
238 }
239 } // namespace TextEngine
240 } // namespace Rosen
241 } // namespace OHOS
242