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 #include <cmath>
16 #include <cstdint>
17 #include <string>
18 
19 #include "gtest/gtest.h"
20 #define private public
21 #define protected public
22 #include "test/mock/core/pipeline/mock_pipeline_context.h"
23 #include "core/components_ng/pattern/render_node/render_node_pattern.h"
24 #include "core/components_ng/pattern/render_node/render_node_paint_property.h"
25 #include "core/components_ng/pattern/render_node/render_node_paint_method.h"
26 #include "core/components_ng/pattern/render_node/render_node_modifier.h"
27 #include "core/components_ng/pattern/render_node/render_node_layout_property.h"
28 #include "core/components_ng/pattern/render_node/render_node_layout_algorithm.h"
29 #include "core/components_ng/base/frame_node.h"
30 #include "test/mock/core/render/mock_render_context.h"
31 #include "core/components_ng/render/drawing_forward.h"
32 #include "core/components_ng/render/paint_wrapper.h"
33 
34 using namespace testing;
35 using namespace testing::ext;
36 
37 namespace OHOS::Ace::NG {
38 class RenderNodeTestNg : public testing::Test {
39 public:
40     static void SetUpTestCase();
41     static void TearDownTestCase();
42 };
43 
SetUpTestCase()44 void RenderNodeTestNg::SetUpTestCase()
45 {
46     MockPipelineContext::SetUp();
47 }
48 
TearDownTestCase()49 void RenderNodeTestNg::TearDownTestCase()
50 {
51     MockPipelineContext::TearDown();
52 }
53 
54 /**
55  * @tc.name: RatingCreateTest001
56  * @tc.desc: Create Rating.
57  * @tc.type: FUNC
58  */
59 HWTEST_F(RenderNodeTestNg, RenderNodePattern001, TestSize.Level1)
60 {
61     auto frameNode = FrameNode::CreateFrameNode("Pattern", 0, AceType::MakeRefPtr<RenderNodePattern>());
62     auto renderNodePattern = frameNode->GetPattern<RenderNodePattern>();
63 
64     auto layoutAlgorithm = renderNodePattern->CreateLayoutAlgorithm();
65     EXPECT_NE(layoutAlgorithm, nullptr);
66 
67     auto layoutProperty = renderNodePattern->CreateLayoutProperty();
68     EXPECT_NE(layoutProperty, nullptr);
69 
70     auto paintProperty = renderNodePattern->CreatePaintProperty();
71     EXPECT_NE(paintProperty, nullptr);
72 
73     auto paintMethod = renderNodePattern->CreateNodePaintMethod();
74     EXPECT_NE(paintMethod, nullptr);
75 
76     renderNodePattern->Invalidate();
77     EXPECT_EQ(renderNodePattern->renderNodeModifier_->renderNodeFlag_->Get(), 1);
78 
79     renderNodePattern->SetLabel("LabelOne");
80 
81     const NG::InspectorFilter filter;
82     auto json = JsonUtil::Create(true);
83     renderNodePattern->ToJsonValue(json, filter);
84     EXPECT_EQ(json->GetString("label"), "LabelOne");
85 }
86 
87 /**
88  * @tc.name: RatingCreateTest001
89  * @tc.desc: Create Rating.
90  * @tc.type: FUNC
91  */
92 HWTEST_F(RenderNodeTestNg, RenderNodePaintMethod001, TestSize.Level1)
93 {
94     auto frameNode = FrameNode::CreateFrameNode("PaintMethod", 0, AceType::MakeRefPtr<RenderNodePattern>());
95     ASSERT_NE(frameNode, nullptr);
96     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
97     ASSERT_NE(geometryNode, nullptr);
98     auto renderNodePattern = frameNode->GetPattern<RenderNodePattern>();
99     ASSERT_NE(renderNodePattern, nullptr);
100     auto renderNodeLayoutProperty = renderNodePattern->GetLayoutProperty<RenderNodeLayoutProperty>();
101     ASSERT_NE(renderNodeLayoutProperty, nullptr);
102 
__anonf292fd3f0102(DrawingContext& context) 103     auto drawCallback = [](DrawingContext& context) {};
104     auto renderNodeModifier = AceType::MakeRefPtr<RenderNodeModifier>(drawCallback);
105     RenderNodePaintMethod renderNodePaintMethod(renderNodeModifier);
106 
107     RefPtr<RenderContext> renderContext = RenderContext::Create();
108     auto paintProperty = renderNodePattern->CreatePaintProperty();
109     auto renderNodePaintProperty = AceType::DynamicCast<RenderNodePaintProperty>(paintProperty);
110     renderNodePaintProperty->UpdateRenderNodeFlag(1);
111     auto paintWrapper = AceType::MakeRefPtr<PaintWrapper>(renderContext, geometryNode, paintProperty);
112     auto modifier = renderNodePaintMethod.GetContentModifier(AceType::RawPtr(paintWrapper));
113     EXPECT_NE(modifier, nullptr);
114 
115     renderNodePaintMethod.UpdateContentModifier(AceType::RawPtr(paintWrapper));
116     EXPECT_EQ(renderNodePaintMethod.renderNodeFlag_, 1);
117 }
118 
119 /**
120  * @tc.name: RatingCreateTest001
121  * @tc.desc: Create Rating.
122  * @tc.type: FUNC
123  */
124 HWTEST_F(RenderNodeTestNg, RenderNodeLayoutAlgorithm001, TestSize.Level1)
125 {
126     auto frameNode = FrameNode::CreateFrameNode("LayoutAlgorithm", 0, AceType::MakeRefPtr<RenderNodePattern>());
127     ASSERT_NE(frameNode, nullptr);
128     auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
129     SizeF contentSize(100, 100);
130     geometryNode->SetContentSize(contentSize);
131     ASSERT_NE(geometryNode, nullptr);
132     auto renderNodePattern = frameNode->GetPattern<RenderNodePattern>();
133     ASSERT_NE(renderNodePattern, nullptr);
134     auto renderNodeLayoutProperty = renderNodePattern->GetLayoutProperty<RenderNodeLayoutProperty>();
135     ASSERT_NE(renderNodeLayoutProperty, nullptr);
136 
137     auto renderNodeLayoutAlgorithm = AceType::MakeRefPtr<RenderNodeLayoutAlgorithm>();
138     auto layoutWrapper =
139         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
140     renderNodeLayoutAlgorithm->Measure(AceType::RawPtr(layoutWrapper));
141     EXPECT_EQ(geometryNode->GetFrameSize(), SizeF(0, 0));
142 
143     SizeF frameSize(200, 200);
144     geometryNode->SetFrameSize(frameSize);
145     renderNodeLayoutAlgorithm->Layout(AceType::RawPtr(layoutWrapper));
146     EXPECT_EQ(geometryNode->GetContentOffset(), OffsetF(0, 0));
147 }
148 
149 /**
150  * @tc.name: RenderNodeLayoutAlgorithmTest001
151  * @tc.desc: RenderNodeLayoutAlgorithm.
152  * @tc.type: FUNC
153  */
154 HWTEST_F(RenderNodeTestNg, RenderNodeLayoutAlgorithmTest001, TestSize.Level1)
155 {
156     LayoutConstraintF layoutConstraintF = {
157         .minSize = { 1, 1 },
158         .maxSize = { 10, 10 },        // 10 is the maxSize of width and height
159         .percentReference = { 5, 5 }, // 5 is the percentReference of width and height
160         .parentIdealSize = { 2, 2 },  // 2 is the parentIdealSize of width and height
161     };
162     auto frameNode = FrameNode::CreateFrameNode("frame", 0, AceType::MakeRefPtr<RenderNodePattern>());
163     ASSERT_NE(frameNode, nullptr);
164     auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
165     ASSERT_NE(geometryNode, nullptr);
166     auto layoutWrapper =
167         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
168     auto childOne = FrameNode::CreateFrameNode("RenderNode", 0, AceType::MakeRefPtr<RenderNodePattern>());
169     auto childTwo = FrameNode::CreateFrameNode("child", 0, AceType::MakeRefPtr<RenderNodePattern>());
170     auto childThree = FrameNode::CreateFrameNode("childThree", 0, AceType::MakeRefPtr<RenderNodePattern>());
171     auto renderNodeLayoutAlgorithm = AceType::MakeRefPtr<RenderNodeLayoutAlgorithm>();
172     auto childLayoutWrapperOne = childOne->CreateLayoutWrapper();
173     auto childLayoutWrapperTwo = childTwo->CreateLayoutWrapper();
174     auto childLayoutWrapperThree = childThree->CreateLayoutWrapper();
175     layoutWrapper->cachedList_ = std::list<RefPtr<LayoutWrapper>>();
176     layoutWrapper->cachedList_.push_back(childLayoutWrapperOne);
177     layoutWrapper->cachedList_.push_back(childLayoutWrapperTwo);
178     childLayoutWrapperTwo->GetLayoutProperty()->UpdateParentLayoutConstraint(layoutConstraintF);
179     layoutWrapper->cachedList_.push_back(childLayoutWrapperThree);
180     layoutWrapper->GetLayoutProperty()->calcLayoutConstraint_ = std::make_unique<MeasureProperty>();
181     layoutWrapper->GetLayoutProperty()->calcLayoutConstraint_->selfIdealSize =
182         CalcSize(CalcLength(1.0), CalcLength(0.0));
183     renderNodeLayoutAlgorithm->Measure(AceType::RawPtr(layoutWrapper));
184     EXPECT_EQ(layoutWrapper->GetGeometryNode()->GetFrameSize().ToString(), "[1.00 x 0.00]");
185 }
186 
187 /**
188  * @tc.name: RenderNodeLayoutAlgorithmTest002
189  * @tc.desc: RenderNodeLayoutAlgorithm.
190  * @tc.type: FUNC
191  */
192 HWTEST_F(RenderNodeTestNg, RenderNodeLayoutAlgorithmTest002, TestSize.Level1)
193 {
194     auto frameNode = FrameNode::CreateFrameNode("frame", 0, AceType::MakeRefPtr<RenderNodePattern>());
195     ASSERT_NE(frameNode, nullptr);
196     auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
197     ASSERT_NE(geometryNode, nullptr);
198     auto layoutWrapper =
199         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
200     auto renderNodeLayoutAlgorithm = AceType::MakeRefPtr<RenderNodeLayoutAlgorithm>();
201     layoutWrapper->GetLayoutProperty()->calcLayoutConstraint_ = std::make_unique<MeasureProperty>();
202     std::optional<CalcLength> width = CalcLength(1.0);
203     layoutWrapper->GetLayoutProperty()->calcLayoutConstraint_->selfIdealSize = CalcSize(width, std::nullopt);
204     renderNodeLayoutAlgorithm->Measure(AceType::RawPtr(layoutWrapper));
205     EXPECT_EQ(layoutWrapper->GetGeometryNode()->GetFrameSize().ToString(), "[0.00 x 0.00]");
206 }
207 
208 /**
209  * @tc.name: RenderNodeLayoutAlgorithmTest003
210  * @tc.desc: RenderNodeLayoutAlgorithm.
211  * @tc.type: FUNC
212  */
213 HWTEST_F(RenderNodeTestNg, RenderNodeLayoutAlgorithmTest003, TestSize.Level1)
214 {
215     auto frameNode = FrameNode::CreateFrameNode("frame", 0, AceType::MakeRefPtr<RenderNodePattern>());
216     ASSERT_NE(frameNode, nullptr);
217     auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
218     ASSERT_NE(geometryNode, nullptr);
219     auto layoutWrapper =
220         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
221     auto renderNodeLayoutAlgorithm = AceType::MakeRefPtr<RenderNodeLayoutAlgorithm>();
222     layoutWrapper->GetLayoutProperty()->calcLayoutConstraint_ = std::make_unique<MeasureProperty>();
223     layoutWrapper->GetLayoutProperty()->calcLayoutConstraint_->selfIdealSize = std::nullopt;
224     renderNodeLayoutAlgorithm->Measure(AceType::RawPtr(layoutWrapper));
225     EXPECT_EQ(layoutWrapper->GetGeometryNode()->GetFrameSize().ToString(), "[0.00 x 0.00]");
226 }
227 
228 /**
229  * @tc.name: RenderNodeLayoutAlgorithmTest004
230  * @tc.desc: RenderNodeLayoutAlgorithm.
231  * @tc.type: FUNC
232  */
233 HWTEST_F(RenderNodeTestNg, RenderNodeLayoutAlgorithmTest004, TestSize.Level1)
234 {
235     LayoutConstraintF layoutConstraintF = {
236         .minSize = { 1, 1 },
237         .maxSize = { 10, 10 },        // 10 is the maxSize of width and height
238         .percentReference = { 5, 5 }, // 5 is the percentReference of width and height
239         .parentIdealSize = { 2, 2 },  // 2 is the parentIdealSize of width and height
240         .selfIdealSize = OptionalSizeF(std::nullopt, std::nullopt),
241     };
242     auto frameNode = FrameNode::CreateFrameNode("frame", 0, AceType::MakeRefPtr<RenderNodePattern>());
243     ASSERT_NE(frameNode, nullptr);
244     auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
245     ASSERT_NE(geometryNode, nullptr);
246     auto layoutWrapper =
247         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
248     auto renderNodeLayoutAlgorithm = AceType::MakeRefPtr<RenderNodeLayoutAlgorithm>();
249     renderNodeLayoutAlgorithm->MeasureContent(layoutConstraintF, AceType::RawPtr(layoutWrapper));
250     EXPECT_EQ(layoutWrapper->GetGeometryNode()->GetFrameSize().ToString(), "[0.00 x 0.00]");
251 }
252 
253 /**
254  * @tc.name: RenderNodeLayoutAlgorithmTest005
255  * @tc.desc: RenderNodeLayoutAlgorithm.
256  * @tc.type: FUNC
257  */
258 HWTEST_F(RenderNodeTestNg, RenderNodeLayoutAlgorithmTest005, TestSize.Level1)
259 {
260     auto frameNode = FrameNode::CreateFrameNode("frame", 0, AceType::MakeRefPtr<RenderNodePattern>());
261     ASSERT_NE(frameNode, nullptr);
262     auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
263     ASSERT_NE(geometryNode, nullptr);
264     auto layoutWrapper =
265         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
266     auto childOne = FrameNode::CreateFrameNode("RenderNode", 0, AceType::MakeRefPtr<RenderNodePattern>());
267     auto childTwo = FrameNode::CreateFrameNode("child", 0, AceType::MakeRefPtr<RenderNodePattern>());
268     auto renderNodeLayoutAlgorithm = AceType::MakeRefPtr<RenderNodeLayoutAlgorithm>();
269     auto childLayoutWrapperOne = childOne->CreateLayoutWrapper();
270     auto childLayoutWrapperTwo = childTwo->CreateLayoutWrapper();
271     layoutWrapper->cachedList_ = std::list<RefPtr<LayoutWrapper>>();
272     layoutWrapper->cachedList_.push_back(childLayoutWrapperOne);
273     layoutWrapper->cachedList_.push_back(childLayoutWrapperTwo);
274     layoutWrapper->GetLayoutProperty()->positionProperty_ = std::make_unique<PositionProperty>();
275     Alignment align;
276     align.horizontal_ = 0.0f;
277     layoutWrapper->GetLayoutProperty()->positionProperty_->UpdateAlignment(align);
278     layoutWrapper->GetGeometryNode()->content_ = nullptr;
279     layoutWrapper->GetLayoutProperty()->calcLayoutConstraint_ = std::make_unique<MeasureProperty>();
280     layoutWrapper->GetLayoutProperty()->calcLayoutConstraint_->selfIdealSize =
281         CalcSize(CalcLength(1.0), CalcLength(0.0));
282     renderNodeLayoutAlgorithm->Layout(AceType::RawPtr(layoutWrapper));
283     EXPECT_EQ(layoutWrapper->GetGeometryNode()->GetFrameSize().ToString(), "[0.00 x 0.00]");
284 }
285 
286 /**
287  * @tc.name: RenderNodeLayoutAlgorithmTest006
288  * @tc.desc: RenderNodeLayoutAlgorithm.
289  * @tc.type: FUNC
290  */
291 HWTEST_F(RenderNodeTestNg, RenderNodeLayoutAlgorithmTest006, TestSize.Level1)
292 {
293     LayoutConstraintF layoutConstraintF = {
294         .minSize = { 1, 1 },
295         .maxSize = { 10, 10 },        // 10 is the maxSize of width and height
296         .percentReference = { 5, 5 }, // 5 is the percentReference of width and height
297         .parentIdealSize = { 2, 2 },  // 2 is the parentIdealSize of width and height
298     };
299     auto frameNode = FrameNode::CreateFrameNode("frame", 0, AceType::MakeRefPtr<RenderNodePattern>());
300     ASSERT_NE(frameNode, nullptr);
301     auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
302     ASSERT_NE(geometryNode, nullptr);
303     auto layoutWrapper =
304         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
305     auto childOne = FrameNode::CreateFrameNode("frame", 0, AceType::MakeRefPtr<RenderNodePattern>());
306     auto childTwo =
307         FrameNode::CreateFrameNode(V2::CUSTOM_FRAME_NODE_ETS_TAG, 0, AceType::MakeRefPtr<RenderNodePattern>());
308     auto childThree = FrameNode::CreateFrameNode("childThree", 0, AceType::MakeRefPtr<RenderNodePattern>());
309     auto renderNodeLayoutAlgorithm = AceType::MakeRefPtr<RenderNodeLayoutAlgorithm>();
310     auto childLayoutWrapperOne = childOne->CreateLayoutWrapper();
311     auto childLayoutWrapperTwo = childTwo->CreateLayoutWrapper();
312     auto childLayoutWrapperThree = childThree->CreateLayoutWrapper();
313     layoutWrapper->cachedList_ = std::list<RefPtr<LayoutWrapper>>();
314     layoutWrapper->cachedList_.push_back(childLayoutWrapperOne);
315     layoutWrapper->cachedList_.push_back(childLayoutWrapperTwo);
316     childLayoutWrapperTwo->GetLayoutProperty()->UpdateParentLayoutConstraint(layoutConstraintF);
317     layoutWrapper->cachedList_.push_back(childLayoutWrapperThree);
318     layoutWrapper->GetLayoutProperty()->calcLayoutConstraint_ = std::make_unique<MeasureProperty>();
319     layoutWrapper->GetLayoutProperty()->calcLayoutConstraint_->selfIdealSize =
320         CalcSize(CalcLength(1.0), CalcLength(0.0));
321     renderNodeLayoutAlgorithm->Measure(AceType::RawPtr(layoutWrapper));
322     EXPECT_EQ(layoutWrapper->GetGeometryNode()->GetFrameSize().ToString(), "[1.00 x 0.00]");
323 }
324 }
325