tawasuyu/taffy

1#[cfg(test)]
2mod root_constraints {
3    use taffy::style_helpers::{length, TaffyMaxContent};
4    use taffy::{AvailableSpace, Rect, Size, Style, TaffyTree};
5    use taffy_test_helpers::new_test_tree;
6
7    #[test]
8    fn root_with_percentage_size() {
9        let mut taffy = new_test_tree();
10        let node = taffy
11            .new_leaf(taffy::style::Style {
12                size: taffy::geometry::Size {
13                    width: taffy::style::Dimension::Percent(1.0),
14                    height: taffy::style::Dimension::Percent(1.0),
15                },
16                ..Default::default()
17            })
18            .unwrap();
19
20        taffy
21            .compute_layout(
22                node,
23                taffy::geometry::Size {
24                    width: AvailableSpace::Definite(100.0),
25                    height: AvailableSpace::Definite(200.0),
26                },
27            )
28            .unwrap();
29        let layout = taffy.layout(node).unwrap();
30
31        assert_eq!(layout.size.width, 100.0);
32        assert_eq!(layout.size.height, 200.0);
33    }
34
35    #[test]
36    fn root_with_no_size() {
37        let mut taffy = new_test_tree();
38        let node = taffy.new_leaf(taffy::style::Style::default()).unwrap();
39
40        taffy
41            .compute_layout(
42                node,
43                taffy::geometry::Size {
44                    width: AvailableSpace::Definite(100.0),
45                    height: AvailableSpace::Definite(100.0),
46                },
47            )
48            .unwrap();
49        let layout = taffy.layout(node).unwrap();
50
51        assert_eq!(layout.size.width, 0.0);
52        assert_eq!(layout.size.height, 0.0);
53    }
54
55    #[test]
56    fn root_with_larger_size() {
57        let mut taffy = new_test_tree();
58        let node = taffy
59            .new_leaf(taffy::style::Style {
60                size: taffy::geometry::Size {
61                    width: taffy::style::Dimension::Length(200.0),
62                    height: taffy::style::Dimension::Length(200.0),
63                },
64                ..Default::default()
65            })
66            .unwrap();
67
68        taffy
69            .compute_layout(
70                node,
71                taffy::geometry::Size {
72                    width: AvailableSpace::Definite(100.0),
73                    height: AvailableSpace::Definite(100.0),
74                },
75            )
76            .unwrap();
77        let layout = taffy.layout(node).unwrap();
78
79        assert_eq!(layout.size.width, 200.0);
80        assert_eq!(layout.size.height, 200.0);
81    }
82
83    #[test]
84    fn root_padding_and_border_larger_than_definite_size() {
85        let mut tree: TaffyTree<()> = TaffyTree::with_capacity(16);
86
87        let child = tree.new_leaf(Style::default()).unwrap();
88
89        let root = tree
90            .new_with_children(
91                Style {
92                    size: Size { width: length(10.0), height: length(10.0) },
93                    padding: Rect { left: length(10.0), right: length(10.0), top: length(10.0), bottom: length(10.0) },
94
95                    border: Rect { left: length(10.0), right: length(10.0), top: length(10.0), bottom: length(10.0) },
96                    ..Default::default()
97                },
98                &[child],
99            )
100            .unwrap();
101
102        tree.compute_layout(root, Size::MAX_CONTENT).unwrap();
103
104        let layout = tree.layout(root).unwrap();
105
106        assert_eq!(layout.size.width, 40.0);
107        assert_eq!(layout.size.height, 40.0);
108    }
109}