tawasuyu/taffy

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