1 /*
2 * Copyright (c) 2020-2021 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 "layout/flex_layout.h"
17
18 #include <climits>
19 #include <gtest/gtest.h>
20
21 using namespace testing::ext;
22 namespace OHOS {
23 namespace {
CreatView()24 UIView* CreatView()
25 {
26 uint16_t width = 100; // 100 view width
27 uint16_t height = 100; // 100 view height
28 auto view = new UIView();
29 view->Resize(width, height);
30 EXPECT_EQ(view->GetX(), 0);
31 EXPECT_EQ(view->GetY(), 0);
32 return view;
33 }
34 }
35 class FlexLayoutTest : public testing::Test {
36 public:
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
39 static FlexLayout* flexLayout_;
40 };
41
42 FlexLayout* FlexLayoutTest::flexLayout_ = nullptr;
43
SetUpTestCase(void)44 void FlexLayoutTest::SetUpTestCase(void)
45 {
46 if (flexLayout_ == nullptr) {
47 flexLayout_ = new FlexLayout();
48 flexLayout_->SetPosition(0, 0, 600, 300); // 600: layout width; 300: layout height
49 }
50 }
51
TearDownTestCase(void)52 void FlexLayoutTest::TearDownTestCase(void)
53 {
54 if (flexLayout_ != nullptr) {
55 delete flexLayout_;
56 flexLayout_ = nullptr;
57 }
58 }
59
60 /**
61 * @tc.name: FlexLayout_001
62 * @tc.desc: Normal Process.
63 * @tc.type: FUNC
64 * @tc.require: AR000DSMR7
65 */
66 HWTEST_F(FlexLayoutTest, FlexLayout_001, TestSize.Level1)
67 {
68 if (flexLayout_ == nullptr) {
69 EXPECT_EQ(1, 0);
70 return;
71 }
72 flexLayout_->SetFlexWrap(false);
73 flexLayout_->SetLayoutDirection(LAYOUT_HOR);
74 flexLayout_->SetMajorAxisAlign(ALIGN_START);
75 flexLayout_->SetSecondaryAxisAlign(ALIGN_START);
76 auto view1 = CreatView();
77 flexLayout_->Add(view1);
78 auto view2 = CreatView();
79 flexLayout_->Add(view2);
80 auto view3 = CreatView();
81 flexLayout_->Add(view3);
82 flexLayout_->LayoutChildren();
83 EXPECT_EQ(view1->GetX(), 0);
84 EXPECT_EQ(view1->GetY(), 0);
85 EXPECT_EQ(view2->GetX(), 100); // 100: view x after layout
86 EXPECT_EQ(view2->GetY(), 0);
87 EXPECT_EQ(view3->GetX(), 200); // 200: view x after layout
88 EXPECT_EQ(view3->GetY(), 0);
89 flexLayout_->RemoveAll();
90 delete view1;
91 delete view2;
92 delete view3;
93 }
94
95 /**
96 * @tc.name: FlexLayout_002
97 * @tc.desc: Normal Process.
98 * @tc.type: FUNC
99 * @tc.require: AR000DSMR7
100 */
101 HWTEST_F(FlexLayoutTest, FlexLayout_002, TestSize.Level1)
102 {
103 if (flexLayout_ == nullptr) {
104 EXPECT_EQ(1, 0);
105 return;
106 }
107 flexLayout_->SetFlexWrap(false);
108 flexLayout_->SetLayoutDirection(LAYOUT_HOR);
109 flexLayout_->SetMajorAxisAlign(ALIGN_START);
110 flexLayout_->SetSecondaryAxisAlign(ALIGN_CENTER);
111 auto view1 = CreatView();
112 flexLayout_->Add(view1);
113 auto view2 = CreatView();
114 flexLayout_->Add(view2);
115 auto view3 = CreatView();
116 flexLayout_->Add(view3);
117 flexLayout_->LayoutChildren();
118 EXPECT_EQ(view1->GetX(), 0);
119 EXPECT_EQ(view1->GetY(), 100); // 100: view x after layout
120 EXPECT_EQ(view2->GetX(), 100); // 100: view x after layout
121 EXPECT_EQ(view2->GetY(), 100); // 100: view y after layout
122 EXPECT_EQ(view3->GetX(), 200); // 200: view x after layout
123 EXPECT_EQ(view3->GetY(), 100); // 100: view y after layout
124 flexLayout_->RemoveAll();
125 delete view1;
126 delete view2;
127 delete view3;
128 }
129
130 /**
131 * @tc.name: FlexLayout_003
132 * @tc.desc: Normal Process.
133 * @tc.type: FUNC
134 * @tc.require: AR000DSMR7
135 */
136 HWTEST_F(FlexLayoutTest, FlexLayout_003, TestSize.Level1)
137 {
138 if (flexLayout_ == nullptr) {
139 EXPECT_EQ(1, 0);
140 return;
141 }
142 flexLayout_->SetFlexWrap(false);
143 flexLayout_->SetLayoutDirection(LAYOUT_HOR_R);
144 flexLayout_->SetMajorAxisAlign(ALIGN_START);
145 flexLayout_->SetSecondaryAxisAlign(ALIGN_CENTER);
146 auto view1 = CreatView();
147 flexLayout_->Add(view1);
148 auto view2 = CreatView();
149 flexLayout_->Add(view2);
150 auto view3 = CreatView();
151 flexLayout_->Add(view3);
152 flexLayout_->LayoutChildren();
153 EXPECT_EQ(view1->GetX(), 500); // 500: view x after layout
154 EXPECT_EQ(view1->GetY(), 100); // 100: view x after layout
155 EXPECT_EQ(view2->GetX(), 400); // 400: view x after layout
156 EXPECT_EQ(view2->GetY(), 100); // 100: view y after layout
157 EXPECT_EQ(view3->GetX(), 300); // 300: view x after layout
158 EXPECT_EQ(view3->GetY(), 100); // 100: view y after layout
159 flexLayout_->RemoveAll();
160 delete view1;
161 delete view2;
162 delete view3;
163 }
164
165 /**
166 * @tc.name: FlexLayout_004
167 * @tc.desc: Normal Process.
168 * @tc.type: FUNC
169 * @tc.require: AR000DSMR7
170 */
171 HWTEST_F(FlexLayoutTest, FlexLayout_004, TestSize.Level1)
172 {
173 if (flexLayout_ == nullptr) {
174 EXPECT_EQ(1, 0);
175 return;
176 }
177 flexLayout_->SetFlexWrap(false);
178 flexLayout_->SetLayoutDirection(LAYOUT_HOR_R);
179 flexLayout_->SetMajorAxisAlign(ALIGN_CENTER);
180 flexLayout_->SetSecondaryAxisAlign(ALIGN_CENTER);
181 auto view1 = CreatView();
182 flexLayout_->Add(view1);
183 auto view2 = CreatView();
184 flexLayout_->Add(view2);
185 auto view3 = CreatView();
186 flexLayout_->Add(view3);
187 flexLayout_->LayoutChildren();
188 EXPECT_EQ(view1->GetX(), 350); // 350: view x after layout
189 EXPECT_EQ(view1->GetY(), 100); // 100: view x after layout
190 EXPECT_EQ(view2->GetX(), 250); // 250: view x after layout
191 EXPECT_EQ(view2->GetY(), 100); // 100: view y after layout
192 EXPECT_EQ(view3->GetX(), 150); // 150: view x after layout
193 EXPECT_EQ(view3->GetY(), 100); // 100: view y after layout
194 flexLayout_->RemoveAll();
195 delete view1;
196 delete view2;
197 delete view3;
198 }
199
200 /**
201 * @tc.name: FlexLayout_005
202 * @tc.desc: Normal Process.
203 * @tc.type: FUNC
204 * @tc.require: AR000DSMR7
205 */
206 HWTEST_F(FlexLayoutTest, FlexLayout_005, TestSize.Level1)
207 {
208 if (flexLayout_ == nullptr) {
209 EXPECT_EQ(1, 0);
210 return;
211 }
212 flexLayout_->SetFlexWrap(false);
213 flexLayout_->SetLayoutDirection(LAYOUT_VER);
214 flexLayout_->SetMajorAxisAlign(ALIGN_EVENLY);
215 flexLayout_->SetSecondaryAxisAlign(ALIGN_START);
216 auto view1 = CreatView();
217 flexLayout_->Add(view1);
218 auto view2 = CreatView();
219 flexLayout_->Add(view2);
220 auto view3 = CreatView();
221 flexLayout_->Add(view3);
222 flexLayout_->LayoutChildren();
223 EXPECT_EQ(view1->GetX(), 0);
224 EXPECT_EQ(view1->GetY(), 0);
225 EXPECT_EQ(view2->GetX(), 0);
226 EXPECT_EQ(view2->GetY(), 100); // 100: view y after layout
227 EXPECT_EQ(view3->GetX(), 0);
228 EXPECT_EQ(view3->GetY(), 200); // 200: view y after layout
229 flexLayout_->RemoveAll();
230 delete view1;
231 delete view2;
232 delete view3;
233 }
234
235 /**
236 * @tc.name: FlexLayout_006
237 * @tc.desc: Normal Process.
238 * @tc.type: FUNC
239 * @tc.require: AR000DSMR7
240 */
241 HWTEST_F(FlexLayoutTest, FlexLayout_006, TestSize.Level1)
242 {
243 if (flexLayout_ == nullptr) {
244 EXPECT_EQ(1, 0);
245 return;
246 }
247 flexLayout_->SetFlexWrap(false);
248 flexLayout_->SetLayoutDirection(LAYOUT_VER);
249 flexLayout_->SetMajorAxisAlign(ALIGN_AROUND);
250 flexLayout_->SetSecondaryAxisAlign(ALIGN_START);
251 auto view1 = CreatView();
252 flexLayout_->Add(view1);
253 auto view2 = CreatView();
254 flexLayout_->Add(view2);
255 auto view3 = CreatView();
256 flexLayout_->Add(view3);
257 flexLayout_->LayoutChildren();
258 EXPECT_EQ(view1->GetX(), 0);
259 EXPECT_EQ(view1->GetY(), 0);
260 EXPECT_EQ(view2->GetX(), 0);
261 EXPECT_EQ(view2->GetY(), 100); // 100: view y after layout
262 EXPECT_EQ(view3->GetX(), 0);
263 EXPECT_EQ(view3->GetY(), 200); // 200: view y after layout
264 flexLayout_->RemoveAll();
265 delete view1;
266 delete view2;
267 delete view3;
268 }
269
270 /**
271 * @tc.name: FlexLayout_007
272 * @tc.desc: Normal Process.
273 * @tc.type: FUNC
274 * @tc.require: AR000DSMR7
275 */
276 HWTEST_F(FlexLayoutTest, FlexLayout_007, TestSize.Level1)
277 {
278 if (flexLayout_ == nullptr) {
279 EXPECT_EQ(1, 0);
280 return;
281 }
282 flexLayout_->SetFlexWrap(false);
283 flexLayout_->SetLayoutDirection(LAYOUT_VER_R);
284 flexLayout_->SetMajorAxisAlign(ALIGN_BETWEEN);
285 flexLayout_->SetSecondaryAxisAlign(ALIGN_START);
286 auto view1 = CreatView();
287 flexLayout_->Add(view1);
288 auto view2 = CreatView();
289 flexLayout_->Add(view2);
290 auto view3 = CreatView();
291 flexLayout_->Add(view3);
292 flexLayout_->LayoutChildren();
293 EXPECT_EQ(view1->GetX(), 0);
294 EXPECT_EQ(view1->GetY(), 200);
295 EXPECT_EQ(view2->GetX(), 0);
296 EXPECT_EQ(view2->GetY(), 100); // 100: view y after layout
297 EXPECT_EQ(view3->GetX(), 0);
298 EXPECT_EQ(view3->GetY(), 0);
299 flexLayout_->RemoveAll();
300 delete view1;
301 delete view2;
302 delete view3;
303 }
304
305 /**
306 * @tc.name: FlexLayout_008
307 * @tc.desc: Normal Process.
308 * @tc.type: FUNC
309 * @tc.require: AR000DSMR7
310 */
311 HWTEST_F(FlexLayoutTest, FlexLayout_008, TestSize.Level1)
312 {
313 if (flexLayout_ == nullptr) {
314 EXPECT_EQ(1, 0);
315 return;
316 }
317 flexLayout_->SetFlexWrap(false);
318 flexLayout_->SetLayoutDirection(LAYOUT_VER_R);
319 flexLayout_->SetMajorAxisAlign(ALIGN_CENTER);
320 flexLayout_->SetSecondaryAxisAlign(ALIGN_START);
321 auto view1 = CreatView();
322 flexLayout_->Add(view1);
323 auto view2 = CreatView();
324 flexLayout_->Add(view2);
325 auto view3 = CreatView();
326 flexLayout_->Add(view3);
327 flexLayout_->LayoutChildren();
328 EXPECT_EQ(view1->GetX(), 0);
329 EXPECT_EQ(view1->GetY(), 200); // 200: view y after layout
330 EXPECT_EQ(view2->GetX(), 0);
331 EXPECT_EQ(view2->GetY(), 100); // 100: view y after layout
332 EXPECT_EQ(view3->GetX(), 0);
333 EXPECT_EQ(view3->GetY(), 0);
334 flexLayout_->RemoveAll();
335 delete view1;
336 delete view2;
337 delete view3;
338 }
339
340 /**
341 * @tc.name: FlexLayout_009
342 * @tc.desc: Normal Process.
343 * @tc.type: FUNC
344 * @tc.require: AR000DSMR7
345 */
346 HWTEST_F(FlexLayoutTest, FlexLayout_009, TestSize.Level1)
347 {
348 if (flexLayout_ == nullptr) {
349 EXPECT_EQ(1, 0);
350 return;
351 }
352 flexLayout_->SetFlexWrap(false);
353 flexLayout_->SetPosition(0, 0, 300, 300); // 300: layout width; 300: layout height
354 flexLayout_->SetLayoutDirection(LAYOUT_HOR);
355 flexLayout_->SetMajorAxisAlign(ALIGN_START);
356 flexLayout_->SetSecondaryAxisAlign(ALIGN_START);
357 auto view1 = CreatView();
358 flexLayout_->Add(view1);
359 auto view2 = CreatView();
360 flexLayout_->Add(view2);
361 auto view3 = CreatView();
362 flexLayout_->Add(view3);
363 auto view4 = CreatView();
364 flexLayout_->Add(view4);
365 flexLayout_->LayoutChildren();
366 EXPECT_EQ(view1->GetX(), 0);
367 EXPECT_EQ(view1->GetY(), 0);
368 EXPECT_EQ(view2->GetX(), 100); // 100: view x after layout
369 EXPECT_EQ(view2->GetY(), 0);
370 EXPECT_EQ(view3->GetX(), 200); // 200: view x after layout
371 EXPECT_EQ(view3->GetY(), 0);
372 EXPECT_EQ(view4->GetX(), 300); // 300: view x after layout
373 EXPECT_EQ(view4->GetY(), 0);
374 flexLayout_->RemoveAll();
375 delete view1;
376 delete view2;
377 delete view3;
378 delete view4;
379 }
380
381 /**
382 * @tc.name: FlexLayout_010
383 * @tc.desc: Normal Process.
384 * @tc.type: FUNC
385 * @tc.require: AR000DSMR7
386 */
387 HWTEST_F(FlexLayoutTest, FlexLayout_010, TestSize.Level1)
388 {
389 if (flexLayout_ == nullptr) {
390 EXPECT_EQ(1, 0);
391 return;
392 }
393 flexLayout_->SetFlexWrap(true);
394 flexLayout_->SetPosition(0, 0, 300, 300); // 300: layout width; 300: layout height
395 flexLayout_->SetLayoutDirection(LAYOUT_HOR);
396 flexLayout_->SetMajorAxisAlign(ALIGN_START);
397 flexLayout_->SetSecondaryAxisAlign(ALIGN_START);
398 auto view1 = CreatView();
399 flexLayout_->Add(view1);
400 auto view2 = CreatView();
401 flexLayout_->Add(view2);
402 auto view3 = CreatView();
403 flexLayout_->Add(view3);
404 auto view4 = CreatView();
405 flexLayout_->Add(view4);
406 flexLayout_->LayoutChildren();
407 EXPECT_EQ(view1->GetX(), 0);
408 EXPECT_EQ(view1->GetY(), 0);
409 EXPECT_EQ(view2->GetX(), 100); // 100: view x after layout
410 EXPECT_EQ(view2->GetY(), 0);
411 EXPECT_EQ(view3->GetX(), 200); // 200: view x after layout
412 EXPECT_EQ(view3->GetY(), 0);
413 EXPECT_EQ(view4->GetX(), 0);
414 EXPECT_EQ(view4->GetY(), 100); // 100: view y after layout
415 flexLayout_->RemoveAll();
416 delete view1;
417 delete view2;
418 delete view3;
419 delete view4;
420 }
421 } // namespace OHOS
422